DocType: Accounting Period,Period Name,Název období
DocType: Employee,Salary Mode,Mode Plat
apps/erpnext/erpnext/public/js/hub/marketplace.js,Register,Registrovat
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Received,Částečně přijato
DocType: Patient,Divorced,Rozvedený
DocType: Support Settings,Post Route Key,Zadejte klíč trasy
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html,Event Link,Odkaz na událost
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,"Povolit položky, které se přidávají vícekrát v transakci"
DocType: Content Question,Content Question,Obsahová otázka
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Cancel Material Visit {0} before cancelling this Warranty Claim,Materiál Navštivte {0} před zrušením této záruční reklamaci Zrušit
DocType: Customer Feedback Table,Qualitative Feedback,Kvalitativní zpětná vazba
apps/erpnext/erpnext/config/education.py,Assessment Reports,Zprávy o hodnocení
DocType: Invoice Discounting,Accounts Receivable Discounted Account,Účty pohledávek se slevou
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting_list.js,Canceled,Zrušeno
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consumer Products,Spotřební zboží
DocType: Supplier Scorecard,Notify Supplier,Informujte dodavatele
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.js,Please select Party Type first,"Prosím, vyberte typ Party první"
DocType: Item,Customer Items,Zákazník položky
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Liabilities,Pasiva
DocType: Project,Costing and Billing,Kalkulace a fakturace
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Advance account currency should be same as company currency {0},Advance měna účtu by měla být stejná jako měna společnosti {0}
DocType: QuickBooks Migrator,Token Endpoint,Koncový bod tokenu
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} can not be a ledger,Účet {0}: Nadřazený účet {1} nemůže být hlavní kniha
DocType: Item,Publish Item to hub.erpnext.com,Publikování položku do hub.erpnext.com
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Cannot find active Leave Period,Nelze najít aktivní období dovolené
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Evaluation,ohodnocení
DocType: Item,Default Unit of Measure,Výchozí Měrná jednotka
DocType: SMS Center,All Sales Partner Contact,Všechny Partneři Kontakt
DocType: Department,Leave Approvers,Schvalovatelé dovolených
DocType: Employee,Bio / Cover Letter,Bio / krycí dopis
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Search Items ...,Prohledat položky ...
DocType: Patient Encounter,Investigations,Vyšetřování
DocType: Restaurant Order Entry,Click Enter To Add,Klepněte na tlačítko Zadat pro přidání
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py,"Missing value for Password, API Key or Shopify URL","Chybějící hodnota pro heslo, klíč API nebo URL obchodu"
DocType: Employee,Rented,Pronajato
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,All Accounts,Všechny účty
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Cannot transfer Employee with status Left,Nelze přenést zaměstnance se stavem doleva
DocType: Vehicle Service,Mileage,Najeto
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Do you really want to scrap this asset?,Opravdu chcete zrušit tuto pohledávku?
DocType: Drug Prescription,Update Schedule,Aktualizovat plán
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Select Default Supplier,Vybrat Výchozí Dodavatel
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Show Employee,Zobrazit zaměstnance
DocType: Payroll Period,Standard Tax Exemption Amount,Standardní částka osvobození od daně
DocType: Exchange Rate Revaluation Account,New Exchange Rate,Nový směnný kurz
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áno pro Ceníku {0}
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Bude se vypočítá v transakci.
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Nastavte prosím systém názvů zaměstnanců v části Lidské zdroje&gt; Nastavení lidských zdrojů
DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
DocType: Purchase Order,Customer Contact,Kontakt se zákazníky
DocType: Shift Type,Enable Auto Attendance,Povolit automatickou účast
apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Zadejte prosím sklad a datum
DocType: Lost Reason Detail,Opportunity Lost Reason,Příležitost Ztracený důvod
DocType: Patient Appointment,Check availability,Zkontrolujte dostupnost
DocType: Retention Bonus,Bonus Payment Date,Bonus Datum platby
DocType: Employee,Job Applicant,Job Žadatel
DocType: Job Card,Total Time in Mins,Celkový čas v minách
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 proti tomuto dodavateli. Viz časovou osu níže podrobnosti
DocType: Manufacturing Settings,Overproduction Percentage For Work Order,Procento nadvýroby pro pracovní pořadí
DocType: Landed Cost Voucher,MAT-LCV-.YYYY.-,MAT-LCV-.YYYY.-
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Legal,Právní
DocType: Sales Invoice,Transport Receipt Date,Datum přijetí dopravy
DocType: Shopify Settings,Sales Order Series,Série objednávek
DocType: Vital Signs,Tongue,Jazyk
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Actual type tax cannot be included in Item rate in row {0},Aktuální typ daň nemůže být zahrnutý v ceně Položka v řádku {0}
DocType: Allowed To Transact With,Allowed To Transact With,Povoleno k transakci s
DocType: Bank Guarantee,Customer,Zákazník
DocType: Purchase Receipt Item,Required By,Vyžadováno
DocType: Delivery Note,Return Against Delivery Note,Návrat Proti dodací list
DocType: Asset Category,Finance Book Detail,Detail knihy financí
apps/erpnext/erpnext/assets/doctype/asset/asset.py,All the depreciations has been booked,Všechny odpisy byly zaúčtovány
DocType: Purchase Order,% Billed,% Fakturováno
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Payroll Number,Mzdové číslo
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Exchange Rate must be same as {0} {1} ({2}),Exchange Rate musí být stejná jako {0} {1} ({2})
DocType: Employee Tax Exemption Declaration,HRA Exemption,HRA výjimka
DocType: Sales Invoice,Customer Name,Jméno zákazníka
DocType: Vehicle,Natural Gas,Zemní plyn
DocType: Project,Message will sent to users to get their status on the project,Uživatelům bude zaslána zpráva o stavu jejich projektu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Bank account cannot be named as {0},Bankovní účet nemůže být jmenován jako {0}
DocType: Employee Tax Exemption Declaration,HRA as per Salary Structure,HRA podle platové struktury
DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,"Heads (nebo skupiny), proti nimž účetní zápisy jsou vyrobeny a stav je veden."
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Outstanding for {0} cannot be less than zero ({1}),Vynikající pro {0} nemůže být nižší než nula ({1})
apps/erpnext/erpnext/public/js/controllers/transaction.js,Service Stop Date cannot be before Service Start Date,Datum ukončení servisu nemůže být před datem zahájení servisu
DocType: Manufacturing Settings,Default 10 mins,Výchozí 10 min
DocType: Leave Type,Leave Type Name,Jméno typu absence
apps/erpnext/erpnext/templates/pages/projects.js,Show open,Ukázat otevřené
apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Employee ID is linked with another instructor,ID zaměstnance je spojeno s jiným instruktorem
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Series Updated Successfully,Řada Aktualizováno Úspěšně
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html,Checkout,Odhlásit se
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Non stock items,Není skladem
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} in row {1},{0} v řádku {1}
DocType: Asset Finance Book,Depreciation Start Date,Datum zahájení odpisování
DocType: Pricing Rule,Apply On,Naneste na
DocType: Item Price,Multiple Item prices.,Více ceny položku.
,Purchase Order Items To Be Received,Položky vydané objednávky k přijetí
DocType: SMS Center,All Supplier Contact,Vše Dodavatel Kontakt
DocType: Support Settings,Support Settings,Nastavení podpůrných
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0} is added in the child company {1},Účet {0} je přidán do podřízené společnosti {1}
apps/erpnext/erpnext/erpnext_integrations/doctype/exotel_settings/exotel_settings.py,Invalid credentials,Neplatné přihlašovací údaje
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Available (whether in full op part),ITC k dispozici (ať už v plné op části)
DocType: Amazon MWS Settings,Amazon MWS Settings,Amazon MWS Nastavení
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Vouchers,Zpracování poukázek
apps/erpnext/erpnext/utilities/transaction_base.py,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,"Řádek # {0}: Cena musí být stejné, jako {1}: {2} ({3} / {4})"
,Batch Item Expiry Status,Batch položky vypršení platnosti Stav
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Bank Draft,Bank Návrh
DocType: Journal Entry,ACC-JV-.YYYY.-,ACC-JV-.YYYY.-
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Late Entries,Celkem pozdních záznamů
DocType: Mode of Payment Account,Mode of Payment Account,Způsob platby účtu
apps/erpnext/erpnext/config/healthcare.py,Consultation,Konzultace
DocType: Accounts Settings,Show Payment Schedule in Print,Zobrazit plán placení v tisku
apps/erpnext/erpnext/stock/doctype/item/item.py,Item Variants updated,Varianty položek byly aktualizovány
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py,Sales and Returns,Prodej a výnosy
apps/erpnext/erpnext/stock/doctype/item/item.js,Show Variants,Zobrazit Varianty
DocType: Academic Term,Academic Term,Akademický Term
DocType: Employee Tax Exemption Sub Category,Employee Tax Exemption Sub Category,Osvobození od daně z příjmů zaměstnanců
apps/erpnext/erpnext/regional/italy/utils.py,Please set an Address on the Company '%s',Zadejte prosím adresu společnosti &#39;% s&#39;
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py,Material,Materiál
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í užitek zaměstnance {0} přesahuje {1} součtem {2} částky pro-rata složky žádosti o dávku \ částka a předchozí nárokovaná částka
DocType: Opening Invoice Creation Tool Item,Quantity,Množství
,Customers Without Any Sales Transactions,Zákazníci bez jakýchkoli prodejních transakcí
DocType: Manufacturing Settings,Disable Capacity Planning,Zakázat plánování kapacity
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Accounts table cannot be blank.,Účty tabulka nemůže být prázdné.
DocType: Delivery Trip,Use Google Maps Direction API to calculate estimated arrival times,Pro výpočet odhadovaných časů příjezdu použijte rozhraní Google Maps Direction API
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Loans (Liabilities),Úvěry (závazky)
DocType: Patient Encounter,Encounter Time,Čas setkání
DocType: Staffing Plan Detail,Total Estimated Cost,Celkové odhadované náklady
DocType: Employee Education,Year of Passing,Rok Passing
DocType: Routing,Routing Name,Název směrování
DocType: Item,Country of Origin,Země původu
DocType: Soil Texture,Soil Texture Criteria,Kritéria textury půdy
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,In Stock,Na skladě
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js,Primary Contact Details,Primární kontaktní údaje
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Issues,otevřené problémy
DocType: Production Plan Item,Production Plan Item,Výrobní program Item
DocType: Leave Ledger Entry,Leave Ledger Entry,Opusťte zápis do knihy
apps/erpnext/erpnext/hr/doctype/employee/employee.py,User {0} is already assigned to Employee {1},Uživatel {0} je již přiřazena k Employee {1}
DocType: Lab Test Groups,Add new line,Přidat nový řádek
apps/erpnext/erpnext/utilities/activation.py,Create Lead,Vytvořit potenciálního zákazníka
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Health Care,Péče o zdraví
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í s platbou (dny)
DocType: Payment Terms Template Detail,Payment Terms Template Detail,Platební podmínky
DocType: Hotel Room Reservation,Guest Name,Jméno hosta
DocType: Delivery Note,Issue Credit Note,Vystavení kreditní poznámky
DocType: Lab Prescription,Lab Prescription,Lab Předpis
,Delay Days,Delay Dny
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,Service Expense,Service Expense
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: Bank Statement Transaction Invoice Item,Invoice,Faktura
DocType: Employee Tax Exemption Declaration Category,Maximum Exempted Amount,Maximální osvobozená částka
DocType: Purchase Invoice Item,Item Weight Details,Položka podrobnosti o hmotnosti
DocType: Asset Maintenance Log,Periodicity,Periodicita
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} is required,Fiskální rok {0} je vyžadována
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py,Net Profit/Loss,Čistý zisk / ztráta
DocType: Employee Group Table,ERPNext User ID,ERPDalší ID uživatele
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
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Please select Patient to get prescribed procedure,"Chcete-li získat předepsaný postup, vyberte možnost Pacient"
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Defense,Obrana
DocType: Salary Component,Abbr,Zkr
DocType: Appraisal Goal,Score (0-5),Score (0-5)
DocType: Tally Migration,Tally Creditors Account,Účet věřitelů
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: {1} {2} does not match with {3},Řádek {0}: {1} {2} se neshoduje s {3}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Row # {0}:,Řádek č. {0}:
DocType: Timesheet,Total Costing Amount,Celková kalkulace Částka
DocType: Sales Invoice,Vehicle No,Vozidle
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select Price List,"Prosím, vyberte Ceník"
DocType: Accounts Settings,Currency Exchange Settings,Nastavení směnného kurzu
DocType: Appointment Booking Slots,Appointment Booking Slots,Výherní automaty pro jmenování
DocType: Work Order Operation,Work In Progress,Na cestě
DocType: Leave Control Panel,Branch (optional),Větev (volitelné)
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Please select date,"Prosím, vyberte datum"
DocType: Item Price,Minimum Qty ,Minimální počet
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,BOM recursion: {0} cannot be child of {1},Rekurze kusovníku: {0} nemůže být dítě {1}
DocType: Finance Book,Finance Book,Finanční kniha
DocType: Patient Encounter,HLC-ENC-.YYYY.-,HLC-ENC-.YYYY.-
DocType: Appointment Booking Settings,Holiday List,Seznam dovolené
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,The parent account {0} does not exists,Nadřazený účet {0} neexistuje
apps/erpnext/erpnext/config/quality_management.py,Review and Action,Přezkum a akce
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,This employee already has a log with the same timestamp.{0},Tento zaměstnanec již má záznam se stejným časovým razítkem. {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Accountant,Účetní
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Selling Price List,Prodejní ceník
DocType: Patient,Tobacco Current Use,Aktuální tabákové použití
apps/erpnext/erpnext/selling/report/customer_wise_item_price/customer_wise_item_price.py,Selling Rate,Prodejní sazba
DocType: Cost Center,Stock User,Sklad Uživatel
DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
DocType: Delivery Stop,Contact Information,Kontaktní informace
apps/erpnext/erpnext/public/js/hub/pages/Category.vue,Search for anything ...,Hledat cokoli ...
,Stock and Account Value Comparison,Porovnání hodnoty akcií a účtu
DocType: Company,Phone No,Telefon
DocType: Delivery Trip,Initial Email Notification Sent,Původní e-mailové oznámení bylo odesláno
DocType: Bank Statement Settings,Statement Header Mapping,Mapování hlaviček výpisu
,Sales Partners Commission,Obchodní partneři Komise
DocType: Soil Texture,Sandy Clay Loam,Sandy Clay Loam
DocType: Purchase Invoice,Rounding Adjustment,Nastavení zaoblení
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: Amazon MWS Settings,AU,AU
DocType: Payment Order,Payment Request,Platba Poptávka
apps/erpnext/erpnext/config/retail.py,To view logs of Loyalty Points assigned to a Customer.,Zobrazení logů věrnostních bodů přidělených zákazníkovi.
DocType: Asset,Value After Depreciation,Hodnota po odpisech
DocType: Student,O+,O +
apps/erpnext/erpnext/stock/doctype/material_request/material_request_dashboard.py,Related,Příbuzný
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance date can not be less than employee's joining date,Datum návštěvnost nemůže být nižší než spojovací data zaměstnance
DocType: Grading Scale,Grading Scale Name,Klasifikační stupnice Name
DocType: Employee Training,Training Date,Datum školení
apps/erpnext/erpnext/public/js/hub/marketplace.js,Add Users to Marketplace,Přidejte uživatele do Marketplace
apps/erpnext/erpnext/accounts/doctype/account/account.js,This is a root account and cannot be edited.,To je kořen účtu a nelze upravovat.
DocType: POS Profile,Company Address,adresa společnosti
DocType: BOM,Operations,Operace
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Cannot set authorization on basis of Discount for {0},Nelze nastavit oprávnění na základě Sleva pro {0}
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill JSON cannot be generated for Sales Return as of now,Účet e-Way Bill JSON již nelze vygenerovat pro vrácení prodeje
DocType: Subscription,Subscription Start Date,Datum zahájení předplatného
DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Appointment charges.,"Výchozí pohledávkové účty, které se použijí, pokud nejsou nastaveny v Pacientovi pro účtování poplatků za schůzku."
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Připojit CSV soubor se dvěma sloupci, jeden pro starý název a jeden pro nový název"
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Address 2,Z adresy 2
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_proof_submission/employee_tax_exemption_proof_submission.js,Get Details From Declaration,Získejte podrobnosti z prohlášení
apps/erpnext/erpnext/accounts/utils.py,{0} {1} not in any active Fiscal Year.,{0} {1} není v žádném aktivním fiskální rok.
DocType: Packed Item,Parent Detail docname,Parent Detail docname
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/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
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 datem zahájení zkušebního období
DocType: Tax Withholding Category,Tax Withholding Category,Daňové zadržení kategorie
apps/erpnext/erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py,Cancel the journal entry {0} first,Nejprve zrušte záznam žurnálu {0}
DocType: Purchase Invoice,ACC-PINV-.YYYY.-,ACC-PINV-.YYYY.-
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 subdodavatelskou položku {0} na řádku {1}
DocType: Vital Signs,Reflexes,Reflexy
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,{0} Result submittted,{0} Výsledek byl předložen
DocType: Item Attribute,Increment,Přírůstek
apps/erpnext/erpnext/templates/pages/search_help.py,Help Results for,Výsledky nápovědy pro
apps/erpnext/erpnext/public/js/stock_analytics.js,Select Warehouse...,Vyberte sklad ...
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Advertising,Reklama
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py,Same Company is entered more than once,Stejný Společnost je zapsána více než jednou
DocType: Patient,Married,Ženatý
apps/erpnext/erpnext/accounts/party.py,Not permitted for {0},Není dovoleno {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get items from,Položka získaná z
DocType: Stock Entry,Send to Subcontractor,Odeslat subdodavateli
DocType: Purchase Invoice,Apply Tax Withholding Amount,Použijte částku s odečtením daně
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Stock cannot be updated against Delivery Note {0},Sklad nelze aktualizovat na dodací list {0}
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Total Amount Credited,Celková částka připsána
apps/erpnext/erpnext/templates/generators/item_group.html,No items listed,Žádné položky nejsou uvedeny
DocType: Asset Repair,Error Description,Popis chyby
DocType: Payment Reconciliation,Reconcile,Srovnat
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Grocery,Potraviny
DocType: Quality Inspection Reading,Reading 1,Čtení 1
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Pension Funds,Penzijní fondy
DocType: Exchange Rate Revaluation Account,Gain/Loss,Zisk / ztráta
DocType: Crop,Perennial,Trvalka
DocType: Program,Is Published,Je publikováno
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Delivery Notes,Zobrazit dodací listy
apps/erpnext/erpnext/controllers/status_updater.py,"To allow over billing, update ""Over Billing Allowance"" in Accounts Settings or the Item.","Chcete-li povolit přeúčtování, aktualizujte položku „Příplatek za fakturaci“ v Nastavení účtů nebo v položce."
DocType: Patient Appointment,Procedure,Postup
DocType: Accounts Settings,Use Custom Cash Flow Format,Použijte formát vlastní peněžní toky
DocType: SMS Center,All Sales Person,Všichni obchodní zástupci
DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"** Měsíční Distribuce ** umožňuje distribuovat Rozpočet / Target celé měsíce, pokud máte sezónnosti ve vaší firmě."
apps/erpnext/erpnext/accounts/page/pos/pos.js,Not items found,Nebyl nalezen položek
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Structure Missing,Plat Struktura Chybějící
DocType: Lead,Person Name,Osoba Jméno
,Supplier Ledger Summary,Shrnutí účetní knihy dodavatele
DocType: Sales Invoice Item,Sales Invoice Item,Položka prodejní faktury
apps/erpnext/erpnext/projects/doctype/project/project.js,Duplicate project has been created,Byl vytvořen duplicitní projekt
DocType: Quality Procedure Table,Quality Procedure Table,Tabulka kvality
DocType: Account,Credit,Úvěr
DocType: POS Profile,Write Off Cost Center,Odepsat nákladové středisko
apps/erpnext/erpnext/public/js/setup_wizard.js,"e.g. ""Primary School"" or ""University""",například &quot;Základní škola&quot; nebo &quot;univerzita&quot;
apps/erpnext/erpnext/config/stock.py,Stock Reports,Stock Reports
DocType: Warehouse,Warehouse Detail,Sklad Detail
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Last carbon check date cannot be a future date,Datum poslední kontroly uhlíku nemůže být budoucí
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.,"Termínovaný Datum ukončení nemůže být později než v roce Datum ukončení akademického roku, ke kterému termín je spojena (akademický rok {}). Opravte data a zkuste to znovu."
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","""Je dlouhodobý majetek"" nemůže být nezaškrtnutý protože existuje zápis aktiva oproti této položce"
DocType: Delivery Trip,Departure Time,Čas odjezdu
DocType: Vehicle Service,Brake Oil,Brake Oil
DocType: Tax Rule,Tax Type,Daňové Type
,Completed Work Orders,Dokončené pracovní příkazy
DocType: Support Settings,Forum Posts,Příspěvky ve fóru
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 označen jako úloha na pozadí. V případě jakéhokoli problému se zpracováním na pozadí přidá systém komentář k chybě v tomto smíření zásob a vrátí se do fáze konceptu.
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot delete item {1} which has work order assigned to it.,"Řádek # {0}: Nelze odstranit položku {1}, která má přiřazen pracovní příkaz."
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Litujeme, platnost kódu kupónu nezačala"
apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Zdanitelná částka
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 údaje před {0}
DocType: Leave Policy,Leave Policy Details,Zanechat podrobnosti o zásadách
DocType: BOM,Item Image (if not slideshow),Item Image (ne-li slideshow)
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} množství hotového zboží v objednávce {3}. Aktualizujte prosím provozní stav pomocí Job Card {4}.
DocType: Work Order Operation,(Hour Rate / 60) * Actual Operation Time,(Hodinová sazba / 60) * Skutečný čas operace
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}: Referenční typ dokumentu musí být jedním z nákladového tvrzení nebo záznamu v deníku
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select BOM,Vybrat BOM
DocType: SMS Log,SMS Log,SMS Log
DocType: Call Log,Ringing,Zvoní
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Delivered Items,Náklady na dodávaných výrobků
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 Datum od a do dnešního dne
DocType: Inpatient Record,Admission Scheduled,Přijetí naplánováno
DocType: Student Log,Student Log,Student Log
apps/erpnext/erpnext/config/buying.py,Templates of supplier standings.,Šablony dodavatelů.
DocType: Lead,Interested,Zájemci
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,Opening,Otvor
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Program: ,Program:
DocType: Item,Copy From Item Group,Kopírovat z bodu Group
DocType: Journal Entry,Opening Entry,Otevření Entry
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Account Pay Only,Účet Pay Pouze
DocType: Loan,Repay Over Number of Periods,Splatit Over počet období
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Quantity to Produce can not be less than Zero,Množství na výrobu nesmí být menší než nula
DocType: Stock Entry,Additional Costs,Dodatečné náklady
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction can not be converted to group.,Účet s transakcemi nelze převést na skupinu.
DocType: Lead,Product Enquiry,Dotaz Product
DocType: Education Settings,Validate Batch for Students in Student Group,Ověřit dávku pro studenty ve skupině studentů
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,No leave record found for employee {0} for {1},Žádný záznam volno nalezených pro zaměstnance {0} na {1}
DocType: Company,Unrealized Exchange Gain/Loss Account,Nerealizovaný účet zisku / ztráty na účtu Exchange
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter company first,"Prosím, nejprave zadejte společnost"
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Please select Company first,"Prosím, vyberte první firma"
DocType: Employee Education,Under Graduate,Za absolventa
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Status Notification in HR Settings.,Prosím nastavte výchozí šablonu pro ohlášení stavu o stavu v HR nastaveních.
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/sales_partner_target_variance_based_on_item_group.js,Target On,Target On
DocType: BOM,Total Cost,Celkové náklady
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.js,Allocation Expired!,Platnost přidělení vypršela!
DocType: Soil Analysis,Ca/K,Ca / K
DocType: Leave Type,Maximum Carry Forwarded Leaves,Maximální počet přepravených listů
DocType: Salary Slip,Employee Loan,zaměstnanec Loan
DocType: Additional Salary,HR-ADS-.YY.-.MM.-,HR-ADS-.YY .- MM.-
DocType: Fee Schedule,Send Payment Request Email,Odeslat e-mail s žádostí o platbu
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Item {0} does not exist in the system or has expired,Bod {0} neexistuje v systému nebo vypršela
DocType: Supplier,Leave blank if the Supplier is blocked indefinitely,"Nechte prázdné, pokud je dodavatel blokován neomezeně"
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Real Estate,Nemovitost
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Statement of Account,Výpis z účtu
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Pharmaceuticals,Farmaceutické
DocType: Purchase Invoice Item,Is Fixed Asset,Je dlouhodobý majetek
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Future Payments,Zobrazit budoucí platby
DocType: Patient,HLC-PAT-.YYYY.-,HLC-PAT-.YYYY.-
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,This bank account is already synchronized,Tento bankovní účet je již synchronizován
DocType: Homepage,Homepage Section,Sekce domovské stránky
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work Order has been {0},Pracovní příkaz byl {0}
DocType: Budget,Applicable on Purchase Order,Platí pro objednávku
DocType: Item,STO-ITEM-.YYYY.-,STO-ITEM-.YYYY.-
apps/erpnext/erpnext/hr/doctype/hr_settings/hr_settings.py,Password policy for Salary Slips is not set,Zásady hesla pro platové lístky nejsou nastaveny
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate customer group found in the cutomer group table,Duplicitní skupinu zákazníků uvedeny v tabulce na knihy zákazníků skupiny
DocType: Location,Location Name,Název umístění
DocType: Quality Procedure Table,Responsible Individual,Odpovědná osoba
DocType: Naming Series,Prefix,Prefix
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html,Event Location,Umístění události
apps/erpnext/erpnext/selling/report/customer_wise_item_price/customer_wise_item_price.py,Available Stock,Dostupné skladem
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Spotřební
DocType: Student,B-,B-
DocType: Assessment Result,Grade,Školní známka
DocType: Restaurant Table,No of Seats,Počet sedadel
DocType: Sales Invoice,Overdue and Discounted,Po lhůtě splatnosti a se slevou
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Asset {0} does not belongs to the custodian {1},Aktivum {0} nepatří do úschovy {1}
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Hovor byl odpojen
DocType: Sales Invoice Item,Delivered By Supplier,Dodává se podle dodavatele
DocType: Asset Maintenance Task,Asset Maintenance Task,Úloha údržby aktiv
DocType: SMS Center,All Contact,Vše Kontakt
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Annual Salary,Roční Plat
DocType: Daily Work Summary,Daily Work Summary,Denní práce Souhrn
DocType: Period Closing Voucher,Closing Fiscal Year,Uzavření fiskálního roku
apps/erpnext/erpnext/accounts/party.py,{0} {1} is frozen,{0} {1} je zmrazený
apps/erpnext/erpnext/setup/doctype/company/company.py,Please select Existing Company for creating Chart of Accounts,Vyberte existující společnosti pro vytváření účtový rozvrh
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Expenses,Stock Náklady
DocType: Appointment,Calendar Event,Událost kalendáře
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Select Target Warehouse,Vyberte objekt Target Warehouse
apps/erpnext/erpnext/hr/doctype/employee/employee.js,Please enter Preferred Contact Email,"Prosím, zadejte Preferred Kontakt e-mail"
DocType: Purchase Invoice Item,Accepted Qty,Přijato Množství
DocType: Journal Entry,Contra Entry,Contra Entry
DocType: Journal Entry Account,Credit in Company Currency,Úvěrové společnosti v měně
DocType: Lab Test UOM,Lab Test UOM,Laboratorní test UOM
DocType: Delivery Note,Installation Status,Stav instalace
DocType: BOM,Quality Inspection Template,Šablona inspekce kvality
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 docházku? <br> Present: {0} \ <br> Chybí: {1}
apps/erpnext/erpnext/controllers/buying_controller.py,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Schválené + Zamítnuté množství se musí rovnat množství Přijaté u položky {0}
DocType: Item,Supply Raw Materials for Purchase,Dodávky suroviny pro nákup
DocType: Agriculture Analysis Criteria,Fertilizer,Hnojivo
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 dodávku podle sériového čísla, protože je přidána položka {0} se službou Zajistit dodání podle \ sériového čísla"
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 nutná alespoň jeden způsob platby.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Batch no is required for batched item {0},Šarže č. Je vyžadována pro dávkovou položku {0}
DocType: Bank Statement Transaction Invoice Item,Bank Statement Transaction Invoice Item,Položka faktury bankovního výpisu
DocType: Salary Detail,Tax on flexible benefit,Daň z flexibilní výhody
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item {0} is not active or end of life has been reached,"Bod {0} není aktivní, nebo byl dosažen konec života"
DocType: Student Admission Program,Minimum Age,Minimální věk
DocType: Customer,Primary Address,primární adresa
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Diff Qty,Rozdílové množství
DocType: Production Plan,Material Request Detail,Podrobnosti o vyžádání materiálu
DocType: Appointment Booking Settings,Notify customer and agent via email on the day of the appointment.,V den schůzky informujte zákazníka a agenta e-mailem.
DocType: Selling Settings,Default Quotation Validity Days,Výchozí dny platnosti kotací
apps/erpnext/erpnext/controllers/accounts_controller.py,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Chcete-li zahrnout daně na řádku v poměru Položka {0}, daně v řádcích {1} musí být zahrnuty"
apps/erpnext/erpnext/config/quality_management.py,Quality Procedure.,Postup kvality.
DocType: SMS Center,SMS Center,SMS centrum
DocType: Payroll Entry,Validate Attendance,Ověřit účast
DocType: Sales Invoice,Change Amount,změna Částka
DocType: Party Tax Withholding Config,Certificate Received,Certifikát byl přijat
DocType: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Nastavte hodnotu faktury pro B2C. B2CL a B2CS vypočítané na základě této fakturované hodnoty.
DocType: BOM Update Tool,New BOM,Nový BOM
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Prescribed Procedures,Předepsané postupy
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show only POS,Zobrazit pouze POS
DocType: Supplier Group,Supplier Group Name,Název skupiny dodavatelů
DocType: Driver,Driving License Categories,Kategorie řidičských oprávnění
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please enter Delivery Date,Zadejte prosím datum doručení
DocType: Depreciation Schedule,Make Depreciation Entry,Udělat Odpisy Entry
DocType: Closed Document,Closed Document,Uzavřený dokument
DocType: HR Settings,Leave Settings,Ponechte nastavení
DocType: Appraisal Template Goal,KRA,KRA
DocType: Lead,Request Type,Typ požadavku
DocType: Purpose of Travel,Purpose of Travel,Účel cesty
DocType: Payroll Period,Payroll Periods,Mzdové lhůty
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Broadcasting,Vysílání
apps/erpnext/erpnext/config/retail.py,Setup mode of POS (Online / Offline),Režim nastavení POS (Online / Offline)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Select a Supplier from the Default Supplier List of the items below.,Vyberte dodavatele z výchozího seznamu dodavatelů níže uvedených položek.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Execution,Provedení
apps/erpnext/erpnext/config/manufacturing.py,Details of the operations carried out.,Podrobnosti o prováděných operací.
DocType: Asset Maintenance Log,Maintenance Status,Status Maintenance
DocType: Purchase Invoice Item,Item Tax Amount Included in Value,Částka daně z položky zahrnutá v hodnotě
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Membership Details,Podrobnosti o členství
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Dodavatel je vyžadován oproti splatnému účtu {2}
apps/erpnext/erpnext/config/buying.py,Items and Pricing,Položky a Ceny
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í
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Total hours: {0},Celkem hodin: {0}
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ěla být v rámci fiskálního roku. Za předpokladu, že od data = {0}"
DocType: Patient Medical Record,HLC-PMR-.YYYY.-,HLC-PMR-.YYYY.-
DocType: Drug Prescription,Interval,Interval
DocType: Pricing Rule,Promotional Scheme Id,ID propagačního schématu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Preference,Přednost
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward Supplies(liable to reverse charge,Dočasné dodávky (podléhají zpětnému poplatku
DocType: Supplier,Individual,Individuální
DocType: Academic Term,Academics User,akademici Uživatel
DocType: Cheque Print Template,Amount In Figure,Na obrázku výše
DocType: Loan Application,Loan Info,Informace o úvěr
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,All Other ITC,Všechny ostatní ITC
apps/erpnext/erpnext/config/crm.py,Plan for maintenance visits.,Plán pro návštěvy údržby.
DocType: Supplier Scorecard Period,Supplier Scorecard Period,Období dodavatele skóre karty
DocType: Support Settings,Search APIs,API vyhledávání
DocType: Share Transfer,Share Transfer,Sdílet přenos
,Expiring Memberships,Platnost členství
apps/erpnext/erpnext/templates/pages/home.html,Read blog,Přečtěte si blog
DocType: POS Profile,Customer Groups,Skupiny zákazníků
apps/erpnext/erpnext/public/js/financial_statements.js,Financial Statements,Finanční výkazy
DocType: Guardian,Students,studenti
apps/erpnext/erpnext/config/buying.py,Rules for applying pricing and discount.,Pravidla pro používání cen a slevy.
DocType: Daily Work Summary,Daily Work Summary Group,Denní shrnutí skupiny práce
DocType: Practitioner Schedule,Time Slots,Časové úseky
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py,Price List must be applicable for Buying or Selling,Ceník musí být použitelný pro nákup nebo prodej
DocType: Shift Assignment,Shift Request,Žádost o posun
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í pro bod {0}
DocType: Purchase Invoice Item,Discount on Price List Rate (%),Sleva na Ceník Rate (%)
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,Item Template,Šablona položky
DocType: Job Offer,Select Terms and Conditions,Vyberte Podmínky
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Out Value,limitu
DocType: Bank Statement Settings Item,Bank Statement Settings Item,Položka nastavení bankovního výpisu
DocType: Woocommerce Settings,Woocommerce Settings,Nastavení Woocommerce
DocType: Leave Ledger Entry,Transaction Name,Název transakce
DocType: Production Plan,Sales Orders,Prodejní objednávky
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Multiple Loyalty Program found for the Customer. Please select manually.,Pro zákazníka byl nalezen vícenásobný věrnostní program. Zvolte prosím ručně.
DocType: Purchase Taxes and Charges,Valuation,Ocenění
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Set as Default,Nastavit jako výchozí
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Expiry date is mandatory for selected item.,Datum vypršení platnosti je pro vybranou položku povinné.
,Purchase Order Trends,Nákupní objednávka trendy
DocType: Hotel Room Reservation,Late Checkin,Pozdní checkin
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Finding linked payments,Nalezení propojených plateb
apps/erpnext/erpnext/templates/emails/request_for_quotation.html,The request for quotation can be accessed by clicking on the following link,Žádost o cenovou nabídku lze přistupovat kliknutím na následující odkaz
DocType: Quiz Result,Selected Option,Vybraná možnost
DocType: SG Creation Tool Course,SG Creation Tool Course,SG nástroj pro tvorbu hřiště
DocType: Bank Statement Transaction Invoice Item,Payment Description,Popis platby
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Nastavte Naming Series pro {0} prostřednictvím Setup&gt; Settings&gt; Naming Series
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Insufficient Stock,nedostatečná Sklad
DocType: Email Digest,New Sales Orders,Nové Prodejní objednávky
DocType: Bank Account,Bank Account,Bankovní účet
DocType: Travel Itinerary,Check-out Date,Zkontrolovat datum
DocType: Leave Type,Allow Negative Balance,Povolit záporný zůstatek
apps/erpnext/erpnext/projects/doctype/project_type/project_type.py,You cannot delete Project Type 'External',Nelze odstranit typ projektu &quot;Externí&quot;
apps/erpnext/erpnext/public/js/utils.js,Select Alternate Item,Vyberte alternativní položku
DocType: Employee,Create User,Vytvořit uživatele
DocType: Selling Settings,Default Territory,Výchozí Territory
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Television,Televize
DocType: Work Order Operation,Updated via 'Time Log',"Aktualizováno přes ""Time Log"""
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Select the customer or supplier.,Vyberte zákazníka nebo dodavatele.
apps/erpnext/erpnext/regional/doctype/import_supplier_invoice/import_supplier_invoice.py,Country Code in File does not match with country code set up in the system,Kód země v souboru neodpovídá kódu země nastavenému v systému
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Select only one Priority as Default.,Jako výchozí vyberte pouze jednu prioritu.
apps/erpnext/erpnext/controllers/taxes_and_totals.py,Advance amount cannot be greater than {0} {1},Množství předem nemůže být větší než {0} {1}
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Časový interval přeskočil, slot {0} až {1} překrýval existující slot {2} na {3}"
DocType: Naming Series,Series List for this Transaction,Řada seznam pro tuto transakci
DocType: Company,Enable Perpetual Inventory,Povolit trvalý inventář
DocType: Bank Guarantee,Charges Incurred,Poplatky vznikly
apps/erpnext/erpnext/public/js/education/lms/quiz.js,Something went wrong while evaluating the quiz.,Při vyhodnocování kvízu se něco pokazilo.
DocType: Appointment Booking Settings,Success Settings,Nastavení úspěchu
DocType: Company,Default Payroll Payable Account,"Výchozí mzdy, splatnou Account"
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Edit Details,Upravit detaily
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Update Email Group,Aktualizace Email Group
DocType: POS Profile,Only show Customer of these Customer Groups,Zobrazovat pouze Zákazníka těchto skupin zákazníků
DocType: Sales Invoice,Is Opening Entry,Je vstupní otvor
apps/erpnext/erpnext/public/js/conf.js,Documentation,Dokumentace
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, bude položka zobrazena v faktuře prodeje, ale může být použita při vytváření skupinových testů."
DocType: Customer Group,Mention if non-standard receivable account applicable,Zmínka v případě nestandardní pohledávky účet použitelná
DocType: Course Schedule,Instructor Name,instruktor Name
DocType: Company,Arrear Component,Součást výdajů
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.py,Stock Entry has been already created against this Pick List,Položka Zásoby již byla vytvořena na základě tohoto výběrového seznamu
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,"The unallocated amount of Payment Entry {0} \
			is greater than the Bank Transaction's unallocated amount",Nealokovaná částka Platební položky {0} \ je větší než nepřidělená částka Bankovní transakce
DocType: Supplier Scorecard,Criteria Setup,Nastavení kritérií
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,For Warehouse is required before Submit,Pro Sklad je povinné před Odesláním
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Received On,Přijaté On
DocType: Codification Table,Medical Code,Lékařský zákoník
apps/erpnext/erpnext/config/integrations.py,Connect Amazon with ERPNext,Spojte Amazon s ERPNext
apps/erpnext/erpnext/templates/generators/item/item_configure.html,Contact Us,Kontaktujte nás
DocType: Delivery Note Item,Against Sales Invoice Item,Proti položce vydané faktury
DocType: Agriculture Analysis Criteria,Linked Doctype,Linked Doctype
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Financing,Čistý peněžní tok z financování
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full , did not save","Místní úložiště je plná, nezachránil"
DocType: Lead,Address & Contact,Adresa a kontakt
DocType: Leave Allocation,Add unused leaves from previous allocations,Přidat nevyužité listy z předchozích přídělů
DocType: Sales Partner,Partner website,webové stránky Partner
DocType: Restaurant Order Entry,Add Item,Přidat položku
DocType: Party Tax Withholding Config,Party Tax Withholding Config,Konz
DocType: Lab Test,Custom Result,Vlastní výsledek
apps/erpnext/erpnext/templates/emails/confirm_appointment.html,Click on the link below to verify your email and confirm the appointment,Kliknutím na odkaz níže ověřte svůj e-mail a potvrďte schůzku
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.js,Bank accounts added,Bankovní účty přidány
DocType: Call Log,Contact Name,Kontakt Jméno
DocType: Plaid Settings,Synchronize all accounts every hour,Synchronizujte všechny účty každou hodinu
DocType: Course Assessment Criteria,Course Assessment Criteria,Hodnotící kritéria hřiště
DocType: Pricing Rule Detail,Rule Applied,Platí pravidlo
DocType: Service Level Priority,Resolution Time Period,Časové rozlišení řešení
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Tax Id: ,DIČ:
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student ID: ,Student ID:
DocType: POS Customer Group,POS Customer Group,POS Customer Group
DocType: Healthcare Practitioner,Practitioner Schedules,Pracovník plánuje
DocType: Cheque Print Template,Line spacing for amount in words,řádkování za částku ve slovech
DocType: Vehicle,Additional Details,další detaily
apps/erpnext/erpnext/templates/generators/bom.html,No description given,No vzhledem k tomu popis
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Načíst položky ze skladu
apps/erpnext/erpnext/config/buying.py,Request for purchase.,Žádost o koupi.
DocType: POS Closing Voucher Details,Collected Amount,Sběrná částka
DocType: Lab Test,Submitted Date,Datum odeslání
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Company field is required,Pole společnosti je povinné
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 výkazů vytvořených proti tomuto projektu
DocType: Item,Minimum quantity should be as per Stock UOM,Minimální množství by mělo být podle zásob UOM
DocType: Call Log,Recording URL,Záznam URL
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,Start Date cannot be before the current date,Datum zahájení nemůže být před aktuálním datem
,Open Work Orders,Otevřete pracovní objednávky
DocType: Healthcare Practitioner,Out Patient Consulting Charge Item,Položka pro poplatek za konzultaci s pacientem
DocType: Payment Term,Credit Months,Kreditní měsíce
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Net Pay cannot be less than 0,Čistý Pay nemůže být nižší než 0
DocType: Contract,Fulfilled,Splnil
DocType: Inpatient Record,Discharge Scheduled,Plnění je naplánováno
DocType: POS Closing Voucher,Cashier,Pokladní
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Leaves per Year,Dovolených za rok
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.,"Row {0}: Zkontrolujte ""Je Advance"" proti účtu {1}, pokud je to záloha záznam."
apps/erpnext/erpnext/stock/utils.py,Warehouse {0} does not belong to company {1},Sklad {0} nepatří ke společnosti {1}
DocType: Email Digest,Profit & Loss,Ztráta zisku
DocType: Task,Total Costing Amount (via Time Sheet),Celková kalkulace Částka (přes Time Sheet)
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py,Please setup Students under Student Groups,"Prosím, nastavte studenty pod studentskými skupinami"
DocType: Item Website Specification,Item Website Specification,Položka webových stránek Specifikace
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave Blocked,Absence blokována
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 na {1}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Bank Entries,bankovní Příspěvky
DocType: Customer,Is Internal Customer,Je interní zákazník
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 Auto Opt In, zákazníci budou automaticky propojeni s daným věrným programem (při uložení)"
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Reklamní Odsouhlasení Item
DocType: Stock Entry,Sales Invoice No,Prodejní faktuře č
DocType: Website Filter Field,Website Filter Field,Pole filtru webových stránek
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Supply Type,Druh napájení
DocType: Material Request Item,Min Order Qty,Min Objednané množství
DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Student Group Creation Tool hřiště
DocType: Lead,Do Not Contact,Nekontaktujte
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Software Developer,Software Developer
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Create Sample Retention Stock Entry,Vytvořte položku Vzorek retenčních zásob
DocType: Item,Minimum Order Qty,Minimální objednávka Množství
DocType: Supplier,Supplier Type,Dodavatel Type
DocType: Course Scheduling Tool,Course Start Date,Začátek Samozřejmě Datum
,Student Batch-Wise Attendance,Student Batch-Wise Účast
DocType: POS Profile,Allow user to edit Rate,Umožnit uživateli upravovat Rate
DocType: Item,Publish in Hub,Publikovat v Hub
DocType: Student Admission,Student Admission,Student Vstupné
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is cancelled,Položka {0} je zrušen
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Depreciation Start Date is entered as past date,Odpisový řádek {0}: Datum zahájení odpisování je zadáno jako poslední datum
DocType: Contract Template,Fulfilment Terms and Conditions,Smluvní podmínky
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material Request,Požadavek na materiál
DocType: Bank Reconciliation,Update Clearance Date,Aktualizace Výprodej Datum
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,Bundle Qty,Balíček Množství
,GSTR-2,GSTR-2
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} nebyl nalezen v &quot;suroviny dodané&quot; tabulky v objednávce {1}
DocType: Salary Slip,Total Principal Amount,Celková hlavní částka
DocType: Student Guardian,Relation,Vztah
DocType: Quiz Result,Correct,Opravit
DocType: Student Guardian,Mother,Matka
DocType: Restaurant Reservation,Reservation End Time,Doba ukončení rezervace
DocType: Crop,Biennial,Dvouletý
,BOM Variance Report,Zpráva o odchylce kusovníku
apps/erpnext/erpnext/config/selling.py,Confirmed orders from Customers.,Potvrzené objednávky od zákazníků.
DocType: Purchase Receipt Item,Rejected Quantity,Odmíntnuté množství
apps/erpnext/erpnext/education/doctype/fees/fees.py,Payment request {0} created,Byla vytvořena žádost o platbu {0}
DocType: Inpatient Record,Admitted Datetime,Přidané datum
DocType: Work Order,Backflush raw materials from work-in-progress warehouse,Zpětné suroviny z nedokončeného skladu
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Open Orders,Otevřené objednávky
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Unable to find Salary Component {0},Nelze najít komponentu platu {0}
apps/erpnext/erpnext/healthcare/setup.py,Low Sensitivity,Nízká citlivost
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_log/shopify_log.js,Order rescheduled for sync,Objednávka byla přepracována pro synchronizaci
apps/erpnext/erpnext/templates/emails/training_event.html,Please confirm once you have completed your training,Potvrďte prosím po dokončení školení
DocType: Lead,Suggestions,Návrhy
DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Set Položka Skupina-moudrý rozpočty na tomto území. Můžete také sezónnosti nastavením distribuce.
DocType: Woocommerce Settings,This company will be used to create Sales Orders.,Tato společnost bude použita k vytváření prodejních objednávek.
DocType: Plaid Settings,Plaid Public Key,Plaid Public Key
DocType: Payment Term,Payment Term Name,Název platebního termínu
DocType: Healthcare Settings,Create documents for sample collection,Vytvořte dokumenty pro výběr vzorků
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 větší než dlužné částky {2}
apps/erpnext/erpnext/patches/v11_0/add_healthcare_service_unit_tree_root.py,All Healthcare Service Units,Všechny jednotky zdravotnických služeb
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Converting Opportunity,O převodu příležitostí
DocType: Bank Account,Address HTML,Adresa HTML
DocType: Lead,Mobile No.,Mobile No.
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html,Mode of Payments,Způsob platby
DocType: Maintenance Schedule,Generate Schedule,Generování plán
DocType: Purchase Invoice Item,Expense Head,Náklady Head
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select Charge Type first,"Prosím, vyberte druh tarifu první"
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.. ","Můžete definovat všechny úkoly, které je třeba provést pro tuto plodinu zde. Denní pole se používá k uvedení den, kdy má být úkol proveden, 1 je 1. den atd."
DocType: Student Group Student,Student Group Student,Student Skupina Student
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Latest,Nejnovější
DocType: Packed Item,Actual Batch Quantity,Skutečné množství šarže
DocType: Asset Maintenance Task,2 Yearly,2 Každoročně
DocType: Education Settings,Education Settings,Nastavení vzdělávání
DocType: Vehicle Service,Inspection,Inspekce
apps/erpnext/erpnext/regional/italy/utils.py,E-Invoicing Information Missing,Chybí informace o elektronické fakturaci
DocType: Leave Allocation,HR-LAL-.YYYY.-,HR-LAL-.YYYY.-
DocType: Exchange Rate Revaluation Account,Balance In Base Currency,Zůstatek v základní měně
DocType: Supplier Scorecard Scoring Standing,Max Grade,Max stupeň
DocType: Email Digest,New Quotations,Nové Citace
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as {1} on leave.,Ústředna nebyla odeslána do {0} jako {1}.
DocType: Journal Entry,Payment Order,Platební příkaz
apps/erpnext/erpnext/www/book_appointment/verify/index.html,Verify Email,ověřovací email
DocType: Employee Tax Exemption Declaration,Income From Other Sources,Příjmy z jiných zdrojů
DocType: Warehouse,"If blank, parent Warehouse Account or company default will be considered","Pokud je prázdné, bude se brát v úvahu výchozí rodičovský účet nebo výchozí společnost"
DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,"E-maily výplatní pásce, aby zaměstnanci na základě přednostního e-mailu vybraného v zaměstnaneckých"
DocType: Tax Rule,Shipping County,vodní doprava County
DocType: Currency Exchange,For Selling,Pro prodej
apps/erpnext/erpnext/config/desktop.py,Learn,Učit se
,Trial Balance (Simple),Zkušební zůstatek (jednoduchý)
DocType: Purchase Invoice Item,Enable Deferred Expense,Aktivovat odložený náklad
apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Kód použitého kupónu
DocType: Asset,Next Depreciation Date,Vedle Odpisy Datum
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Náklady na činnost na jednoho zaměstnance
DocType: Accounts Settings,Settings for Accounts,Nastavení účtů
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice No exists in Purchase Invoice {0},Dodavatelské faktury No existuje ve faktuře {0}
apps/erpnext/erpnext/config/crm.py,Manage Sales Person Tree.,Správa obchodník strom.
DocType: Job Applicant,Cover Letter,Průvodní dopis
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Outstanding Cheques and Deposits to clear,Vynikající Šeky a vklady s jasnými
DocType: Item,Synced With Hub,Synchronizovány Hub
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward supplies from ISD,Spotřební materiál od ISD
DocType: Driver,Fleet Manager,Fleet manager
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 negativní na položku {2}
apps/erpnext/erpnext/setup/doctype/company/company.js,Wrong Password,Špatné Heslo
DocType: POS Profile,Offline POS Settings,Nastavení offline offline
DocType: Stock Entry Detail,Reference Purchase Receipt,Referenční potvrzení o nákupu
DocType: Stock Reconciliation,MAT-RECO-.YYYY.-,MAT-RECO-.YYYY.-
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Variant Of,Varianta
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_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í do výroby"""
apps/erpnext/erpnext/public/js/purchase_trends_filters.js,Period based On,Období založené na
DocType: Period Closing Voucher,Closing Account Head,Závěrečný účet hlava
DocType: Employee,External Work History,Vnější práce History
apps/erpnext/erpnext/projects/doctype/task/task.py,Circular Reference Error,Kruhové Referenční Chyba
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Report Card,Studentská karta
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Pin Code,Z kódu PIN
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Sales Person,Zobrazit prodejní osobu
DocType: Appointment Type,Is Inpatient,Je hospitalizován
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Name,Jméno Guardian1
DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,"Ve slovech (export) budou viditelné, jakmile uložíte doručení poznámku."
DocType: Cheque Print Template,Distance from left edge,Vzdálenost od levého okraje
apps/erpnext/erpnext/utilities/bot.py,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} jednotek [{1}] (# Form / bodu / {1}) byla nalezena v [{2}] (# Form / sklad / {2})
DocType: Lead,Industry,Průmysl
DocType: BOM Item,Rate & Amount,Cena a částka
apps/erpnext/erpnext/config/website.py,Settings for website product listing,Nastavení pro seznam produktů na webu
apps/erpnext/erpnext/accounts/report/sales_register/sales_register.py,Tax Total,Daň celkem
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Amount of Integrated Tax,Výše integrované daně
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Upozornit e-mailem na tvorbu automatických Materiál Poptávka
DocType: Accounting Dimension,Dimension Name,Název dimenze
apps/erpnext/erpnext/healthcare/setup.py,Resistant,Odolný
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Please set Hotel Room Rate on {},"Prosím, nastavte Hotel Room Rate na {}"
DocType: Journal Entry,Multi Currency,Více měn
DocType: Bank Statement Transaction Invoice Item,Invoice Type,Typ faktury
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from date must be less than valid upto date,Platné od data musí být kratší než platné datum
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Exception occurred while reconciling {0},Při sladění došlo k výjimce {0}
DocType: Purchase Invoice,Set Accepted Warehouse,Nastavit přijímaný sklad
DocType: Employee Benefit Claim,Expense Proof,Výkaz výdajů
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.py,Saving {0},Uložení {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Delivery Note,Dodací list
DocType: Patient Encounter,Encounter Impression,Setkání s impresi
apps/erpnext/erpnext/config/help.py,Setting up Taxes,Nastavení Daně
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Sold Asset,Náklady prodaných aktiv
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Target Location is required while receiving Asset {0} from an employee,Cílová poloha je vyžadována při příjmu aktiva {0} od zaměstnance
DocType: Volunteer,Morning,Ráno
apps/erpnext/erpnext/accounts/utils.py,Payment Entry has been modified after you pulled it. Please pull it again.,"Vstup Platba byla změněna poté, co ji vytáhl. Prosím, vytáhněte ji znovu."
DocType: Program Enrollment Tool,New Student Batch,Nová studentská dávka
apps/erpnext/erpnext/accounts/doctype/item_tax_template/item_tax_template.py,{0} entered twice in Item Tax,{0} vloženo dvakrát v Daňové Položce
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ím činnostem
DocType: Student Applicant,Admitted,"připustil,"
DocType: Workstation,Rent Cost,Rent Cost
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Item listing removed,Seznam položek byl odstraněn
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid transactions sync error,Chyba synchronizace plaidních transakcí
DocType: Leave Ledger Entry,Is Expired,Platnost vypršela
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py,Amount After Depreciation,Částka po odpisech
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Upcoming Calendar Events,Nadcházející Události v kalendáři
apps/erpnext/erpnext/public/js/templates/item_quick_entry.html,Variant Attributes,Variant atributy
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Please select month and year,Vyberte měsíc a rok
DocType: Employee,Company Email,Společnost E-mail
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,User has not applied rule on the invoice {0},Uživatel na fakturu neuplatnil pravidlo {0}
DocType: GL Entry,Debit Amount in Account Currency,Debetní Částka v měně účtu
DocType: Supplier Scorecard,Scoring Standings,Hodnocení bodů
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Value,Hodnota objednávky
DocType: Certified Consultant,Certified Consultant,Certifikovaný konzultant
apps/erpnext/erpnext/config/accounts.py,Bank/Cash transactions against party or for internal transfer,Banka / Hotovostní operace proti osobě nebo pro interní převod
DocType: Shipping Rule,Valid for Countries,"Platí pro země,"
apps/erpnext/erpnext/hr/doctype/training_event/training_event.py,End time cannot be before start time,Čas ukončení nemůže být před časem zahájení
apps/erpnext/erpnext/templates/generators/item/item_configure.js,1 exact match.,1 přesná shoda.
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,"Tento bod je šablona a nemůže být použit v transakcích. Atributy položky budou zkopírovány do variant, pokud je nastaveno ""No Copy"""
DocType: Grant Application,Grant Application,Žádost o grant
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Total Order Considered,Celková objednávka Zvážil
DocType: Certification Application,Not Certified,Není certifikováno
DocType: Asset Value Adjustment,New Asset Value,Nová hodnota aktiv
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"
DocType: Course Scheduling Tool,Course Scheduling Tool,Samozřejmě Plánování Tool
DocType: Crop Cycle,LInked Analysis,Llnked Analysis
DocType: POS Closing Voucher,POS Closing Voucher,POS uzávěrka
DocType: Invoice Discounting,Loan Start Date,Datum zahájení půjčky
DocType: Contract,Lapsed,Zrušeno
DocType: Item Tax Template Detail,Tax Rate,Tax Rate
apps/erpnext/erpnext/education/doctype/course_activity/course_activity.py,Course Enrollment {0} does not exists,Zápis do kurzu {0} neexistuje
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Application period cannot be across two allocation records,Období žádosti nesmí být v rámci dvou alokačních záznamů
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} na dobu {2} až {3}
DocType: Buying Settings,Backflush Raw Materials of Subcontract Based On,Backflush Suroviny subdodávky založené na
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Purchase Invoice {0} is already submitted,Přijatá faktura {0} je již odeslána
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Batch No must be same as {1} {2},"Row # {0}: Batch No musí být stejné, jako {1} {2}"
DocType: Material Request Plan Item,Material Request Plan Item,Položka materiálu požadovaného plánu
DocType: Leave Type,Allow Encashment,Povolit nákres
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to non-Group,Převést na non-Group
DocType: Exotel Settings,Account SID,SID účtu
DocType: Bank Statement Transaction Invoice Item,Invoice Date,Datum Fakturace
DocType: GL Entry,Debit Amount,Debetní Částka
apps/erpnext/erpnext/accounts/party.py,There can only be 1 Account per Company in {0} {1},Tam může být pouze 1 účet na společnosti v {0} {1}
DocType: Support Search Source,Response Result Key Path,Cesta k klíčovému výsledku odpovědi
DocType: Journal Entry,Inter Company Journal Entry,Inter Company Entry Journal
apps/erpnext/erpnext/accounts/party.py,Due Date cannot be before Posting / Supplier Invoice Date,Datum splatnosti nesmí být před datem odeslání / fakturace dodavatele
DocType: Employee Training,Employee Training,Školení zaměstnanců
DocType: Quotation Item,Additional Notes,Další poznámky
DocType: Purchase Order,% Received,% Přijaté
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Create Student Groups,Vytvoření skupiny studentů
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Available quantity is {0}, you need {1}","Dostupné množství je {0}, potřebujete {1}"
DocType: Volunteer,Weekends,Víkendy
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Credit Note Amount,Částka kreditní poznámky
DocType: Setup Progress Action,Action Document,Akční dokument
DocType: Chapter Member,Website URL,URL webu
apps/erpnext/erpnext/controllers/stock_controller.py,Row #{0}: Serial No {1} does not belong to Batch {2},Řádek # {0}: Sériové číslo {1} nepatří do dávky {2}
,Finished Goods,Hotové zboží
DocType: Delivery Note,Instructions,Instrukce
DocType: Quality Inspection,Inspected By,Zkontrolován
DocType: Asset,ACC-ASS-.YYYY.-,ACC-ASS-.YYYY.-
DocType: Asset Maintenance Log,Maintenance Type,Typ Maintenance
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Course {2},{0} - {1} není zařazen do kurzu {2}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Name: ,Jméno studenta:
DocType: POS Closing Voucher,Difference,Rozdíl
DocType: Delivery Settings,Delay between Delivery Stops,Zpoždění mezi doručením
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Serial No {0} does not belong to Delivery Note {1},Pořadové číslo {0} není součástí dodávky Poznámka: {1}
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 existuje problém se konfigurací serveru GoCardless. Nebojte se, v případě selhání bude částka vrácena na váš účet."
apps/erpnext/erpnext/templates/pages/demo.html,ERPNext Demo,ERPNext Demo
apps/erpnext/erpnext/public/js/utils/item_selector.js,Add Items,Přidat položky
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Položka Kontrola jakosti Parametr
DocType: Leave Application,Leave Approver Name,Jméno schvalovatele dovolené
DocType: Depreciation Schedule,Schedule Date,Plán Datum
DocType: Amazon MWS Settings,FR,FR
DocType: Packed Item,Packed Item,Zabalená položka
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Service End Date cannot be before Invoice Posting Date,Řádek # {0}: Datum ukončení služby nesmí být před datem účtování faktury
DocType: Job Offer Term,Job Offer Term,Termín nabídky práce
apps/erpnext/erpnext/config/buying.py,Default settings for buying transactions.,Výchozí nastavení pro nákup transakcí.
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,Activity Cost exists for Employee {0} against Activity Type - {1},Existuje Náklady aktivity pro zaměstnance {0} proti Typ aktivity - {1}
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Get Students From,Povinná pole - Získajte studenty z
DocType: Program Enrollment,Enrolled courses,Zapsané kurzy
DocType: Currency Exchange,Currency Exchange,Směnárna
apps/erpnext/erpnext/support/doctype/issue/issue.js,Resetting Service Level Agreement.,Obnovení dohody o úrovni služeb.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Item Name,Název položky
DocType: Authorization Rule,Approving User  (above authorized value),Schválení uživatele (nad oprávněné hodnoty)
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Credit Balance,Credit Balance
DocType: Employee,Widowed,Ovdovělý
DocType: Request for Quotation,Request for Quotation,Žádost o cenovou nabídku
DocType: Healthcare Settings,Require Lab Test Approval,Požadovat schválení testu laboratoře
DocType: Attendance,Working Hours,Pracovní doba
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Total Outstanding,Naprosto vynikající
DocType: Naming Series,Change the starting / current sequence number of an existing series.,Změnit výchozí / aktuální pořadové číslo existujícího série.
DocType: Accounts Settings,Percentage you are allowed to bill more against the amount ordered. For example: If the order value is $100 for an item and tolerance is set as 10% then you are allowed to bill for $110.,"Procento, které máte možnost vyúčtovat více oproti objednané částce. Například: Pokud je hodnota objednávky 100 $ pro položku a tolerance je nastavena na 10%, pak máte možnost vyúčtovat za 110 $."
DocType: Dosage Strength,Strength,Síla
apps/erpnext/erpnext/public/js/controllers/transaction.js,Cannot find Item with this barcode,Nelze najít položku s tímto čárovým kódem
apps/erpnext/erpnext/accounts/page/pos/pos.js,Create a new Customer,Vytvořit nový zákazník
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Expiring On,Vypnuto Zapnuto
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.","Je-li více pravidla pro tvorbu cen i nadále přednost, jsou uživatelé vyzváni k nastavení priority pro vyřešení konfliktu."
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Purchase Return,Nákup Return
apps/erpnext/erpnext/utilities/activation.py,Create Purchase Orders,Vytvoření objednávek
,Purchase Register,Nákup Register
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Patient not found,Pacient nebyl nalezen
DocType: Landed Cost Item,Applicable Charges,Použitelné Poplatky
DocType: Workstation,Consumable Cost,Spotřební Cost
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Response Time for {0} at index {1} can't be greater than Resolution Time.,Doba odezvy pro {0} při indexu {1} nemůže být delší než doba řešení.
DocType: Purchase Receipt,Vehicle Date,Datum Vehicle
DocType: Campaign Email Schedule,Campaign Email Schedule,Plán e-mailu kampaně
DocType: Student Log,Medical,Lékařský
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Drug,Vyberte prosím lék
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Lead Owner cannot be same as the Lead,Olovo Majitel nemůže být stejný jako olovo
DocType: Announcement,Receiver,Přijímač
DocType: Location,Area UOM,Oblast UOM
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,Workstation is closed on the following dates as per Holiday List: {0},Workstation je uzavřena v následujících dnech podle Prázdninový Seznam: {0}
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Opportunities,Příležitosti
DocType: Lab Test Template,Single,Jednolůžkový
DocType: Compensatory Leave Request,Work From Date,Práce od data
DocType: Salary Slip,Total Loan Repayment,Celková splátky
DocType: Project User,View attachments,Zobrazit přílohy
DocType: Account,Cost of Goods Sold,Náklady na prodej zboží
DocType: Article,Publish Date,Datum publikování
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please enter Cost Center,"Prosím, zadejte nákladové středisko"
DocType: Drug Prescription,Dosage,Dávkování
DocType: DATEV Settings,DATEV Settings,Nastavení DATEV
DocType: Journal Entry Account,Sales Order,Prodejní objednávky
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Avg. Selling Rate,Avg. Prodej Rate
DocType: Assessment Plan,Examiner Name,Jméno Examiner
DocType: Lab Test Template,No Result,Žádný výsledek
DocType: Woocommerce Settings,"The fallback series is ""SO-WOO-"".",Záložní řada je „SO-WOO-“.
DocType: Purchase Invoice Item,Quantity and Rate,Množství a cena
DocType: Delivery Note,% Installed,% Instalováno
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Company currencies of both the companies should match for Inter Company Transactions.,Společné měny obou společností by měly odpovídat mezipodnikovým transakcím.
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Please enter company name first,"Prosím, zadejte nejprve název společnosti"
DocType: Travel Itinerary,Non-Vegetarian,Nevegetarián
DocType: Purchase Invoice,Supplier Name,Dodavatel Name
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Read the ERPNext Manual,Přečtěte si ERPNext Manuál
DocType: HR Settings,Show Leaves Of All Department Members In Calendar,Zobrazit listy všech členů katedry v kalendáři
DocType: Purchase Invoice,01-Sales Return,01-Návrat prodeje
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Qty per BOM Line,Množství na řádek kusovníku
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,Temporarily on Hold,Dočasně pozdrženo
DocType: Account,Is Group,Is Group
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/selling/doctype/sales_order/sales_order.js,Request for Raw Materials,Žádost o suroviny
DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Automaticky nastavit sériových čísel na základě FIFO
DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,"Zkontrolujte, zda dodavatelské faktury Počet Jedinečnost"
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js,Primary Address Details,Údaje o primární adrese
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Public token is missing for this bank,Pro tuto banku chybí veřejný token
DocType: Vehicle Service,Oil Change,Výměna oleje
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Operating Cost as per Work Order / BOM,Provozní náklady podle objednávky / kusovníku
DocType: Leave Encashment,Leave Balance,Nechat zůstatek
DocType: Asset Maintenance Log,Asset Maintenance Log,Protokol o údržbě aktiv
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,'To Case No.' cannot be less than 'From Case No.',"""DO Případu č.' nesmí být menší než ""Od Případu č.'"
DocType: Certification Application,Non Profit,Non Profit
DocType: Production Plan,Not Started,Nezahájeno
DocType: Lead,Channel Partner,Channel Partner
DocType: Account,Old Parent,Staré nadřazené
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Academic Year,Povinná oblast - Akademický rok
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} is not associated with {2} {3},{0} {1} není přidružen k {2} {3}
DocType: Opportunity,Converted By,Převedeno
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,You need to login as a Marketplace User before you can add any reviews.,"Než budete moci přidat recenze, musíte se přihlásit jako uživatel Marketplace."
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0} : Operation is required against the raw material item {1},Řádek {0}: vyžaduje se operace proti položce suroviny {1}
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}
DocType: Setup Progress Action,Min Doc Count,Minimální počet dokumentů
apps/erpnext/erpnext/config/manufacturing.py,Global settings for all manufacturing processes.,Globální nastavení pro všechny výrobní procesy.
DocType: Accounts Settings,Accounts Frozen Upto,Účty Frozen aľ
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Day Book Data,Zpracovat data denní knihy
DocType: SMS Log,Sent On,Poslán na
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Incoming call from {0},Příchozí hovor od {0}
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute {0} selected multiple times in Attributes Table,Atribut {0} vybraný několikrát v atributech tabulce
DocType: HR Settings,Employee record is created using selected field. ,Záznam Zaměstnanec je vytvořena pomocí vybrané pole.
DocType: Sales Order,Not Applicable,Nehodí se
DocType: Amazon MWS Settings,UK,Spojené království
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Opening Invoice Item,Otevření položky faktury
DocType: Request for Quotation Item,Required Date,Požadovaná data
DocType: Accounts Settings,Billing Address,Fakturační adresa
DocType: Bank Statement Settings,Statement Headers,Záhlaví prohlášení
DocType: Travel Request,Costing,Rozpočet
DocType: Tax Rule,Billing County,fakturace County
DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Je-li zaškrtnuto, bude částka daně považovat za již zahrnuty v tisku Rate / Tisk Částka"
DocType: Request for Quotation,Message for Supplier,Zpráva pro dodavatele
DocType: BOM,Work Order,Zakázka
DocType: Sales Invoice,Total Qty,Celkem Množství
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ID e-mailu Guardian2
DocType: Item,Show in Website (Variant),Show do webových stránek (Variant)
DocType: Employee,Health Concerns,Zdravotní Obavy
DocType: Payroll Entry,Select Payroll Period,Vyberte mzdové
apps/erpnext/erpnext/regional/india/utils.py,"Invalid {0}! The check digit validation has failed.
			Please ensure you've typed the {0} correctly.","Neplatné {0}! Ověření kontrolní číslice selhalo. Ujistěte se, že jste správně zadali {0}."
DocType: Purchase Invoice,Unpaid,Nezaplacený
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sale,Vyhrazeno pro prodej
DocType: Packing Slip,From Package No.,Od č balíčku
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Row #{0}: Payment document is required to complete the transaction,Řádek # {0}: K dokončení transakce je vyžadován platební doklad
DocType: Item Attribute,To Range,K Rozsah
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
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","Metoda oceňování nelze změnit, neboť existují transakce proti některým položkám, které nemají vlastní metodu oceňování"
DocType: Student Report Generation Tool,Attended by Parents,Zúčastnili se rodiče
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}:
DocType: Inpatient Record,AB Positive,AB pozitivní
DocType: Job Opening,Description of a Job Opening,Popis jednoho volných pozic
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Pending activities for today,Nevyřízené aktivity pro dnešek
DocType: Salary Structure,Salary Component for timesheet based payroll.,Plat komponent pro mzdy časového rozvrhu.
DocType: Driver,Applicable for external driver,Platí pro externí ovladač
DocType: Sales Order Item,Used for Production Plan,Používá se pro výrobní plán
DocType: BOM,Total Cost (Company Currency),Celkové náklady (měna společnosti)
DocType: Loan,Total Payment,Celková platba
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Cannot cancel transaction for Completed Work Order.,Nelze zrušit transakci pro dokončenou pracovní objednávku.
DocType: Manufacturing Settings,Time Between Operations (in mins),Doba mezi operací (v min)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,PO already created for all sales order items,PO již vytvořeno pro všechny položky prodejní objednávky
DocType: Healthcare Service Unit,Occupied,Obsazený
DocType: Clinical Procedure,Consumables,Spotřební materiál
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js,Include Default Book Entries,Zahrnout výchozí položky knihy
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled so the action cannot be completed,"{0} {1} je zrušena, takže akce nemůže být dokončena"
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é byla zvýšena pracovní objednávka, ale čeká na výrobu."
DocType: Customer,Buyer of Goods and Services.,Kupující zboží a služeb.
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,'employee_field_value' and 'timestamp' are required.,jsou vyžadovány &#39;customer_field_value&#39; a &#39;timestamp&#39;.
DocType: Journal Entry,Accounts Payable,Účty za úplatu
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.,"Část {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: Patient,Allergies,Alergie
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 stejné položky
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
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Item Code,Změnit kód položky
DocType: Supplier Scorecard Standing,Notify Other,Upozornit ostatní
DocType: Vital Signs,Blood Pressure (systolic),Krevní tlak (systolický)
apps/erpnext/erpnext/controllers/buying_controller.py,{0} {1} is {2},{0} {1} je {2}
DocType: Item Price,Valid Upto,Valid aľ
DocType: Leave Type,Expire Carry Forwarded Leaves (Days),Vyprší doručené listy (dny)
DocType: Training Event,Workshop,Dílna
DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Upozornění na nákupní objednávky
DocType: Employee Tax Exemption Proof Submission,Rented From Date,Pronajato od data
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Enough Parts to Build,Dost Části vybudovat
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Please save first,Nejprve prosím uložte
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Items are required to pull the raw materials which is associated with it.,"Položky jsou vyžadovány pro tahání surovin, které jsou s ním spojeny."
DocType: POS Profile User,POS Profile User,Uživatel profilu POS
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Row {0}: Depreciation Start Date is required,Řádek {0}: Je vyžadován počáteční datum odpisování
DocType: Purchase Invoice Item,Service Start Date,Datum zahájení služby
DocType: Subscription Invoice,Subscription Invoice,Předplatné faktura
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Income,Přímý příjmů
DocType: Patient Appointment,Date TIme,Čas schůzky
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 seskupeny podle účtu"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Administrative Officer,Správní ředitel
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Course,Vyberte možnost Kurz
DocType: Codification Table,Codification Table,Kodifikační tabulka
DocType: Timesheet Detail,Hrs,hod
apps/erpnext/erpnext/regional/report/datev/datev.py,<b>To Date</b> is a mandatory filter.,<b>Do dneška</b> je povinný filtr.
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Changes in {0},Změny v {0}
DocType: Employee Skill,Employee Skill,Dovednost zaměstnanců
DocType: Employee Advance,Returned Amount,Vrácená částka
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Difference Account,Rozdíl účtu
DocType: Pricing Rule,Discount on Other Item,Sleva na další položku
DocType: Purchase Invoice,Supplier GSTIN,Dodavatel GSTIN
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,View Form,Zobrazit formulář
DocType: Work Order,Additional Operating Cost,Další provozní náklady
DocType: Lab Test Template,Lab Routine,Lab Rutine
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Cosmetics,Kosmetika
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Please select Completion Date for Completed Asset Maintenance Log,Zvolte datum dokončení dokončeného protokolu údržby aktiv
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} is not the default supplier for any items.,{0} není výchozím dodavatelem pro žádné položky.
apps/erpnext/erpnext/stock/doctype/item/item.py,"To merge, following properties must be same for both items","Chcete-li sloučit, tyto vlastnosti musí být stejné pro obě položky"
DocType: Supplier,Block Supplier,Zablokujte dodavatele
DocType: Shipping Rule,Net Weight,Hmotnost
DocType: Job Opening,Planned number of Positions,Plánovaný počet pozic
DocType: Employee,Emergency Phone,Nouzový telefon
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/stock/doctype/item/item_dashboard.py,Buy,Koupit
,Serial No Warranty Expiry,Pořadové č záruční lhůty
DocType: Sales Invoice,Offline POS Name,Offline POS Name
DocType: Task,Dependencies,Závislosti
DocType: Bank Statement Transaction Payment Item,Payment Reference,Odkaz na platby
DocType: Supplier,Hold Type,Typ zadržení
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Please define grade for Threshold 0%,Zadejte prosím stupeň pro Threshold 0%
DocType: Bank Statement Transaction Payment Item,Bank Statement Transaction Payment Item,Položka platební transakce bankovního účtu
DocType: Sales Order,To Deliver,Dodat
DocType: Purchase Invoice Item,Item,Položka
apps/erpnext/erpnext/healthcare/setup.py,High Sensitivity,Vysoká citlivost
apps/erpnext/erpnext/config/non_profit.py,Volunteer Type information.,Informace o typu dobrovolníka.
DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Šablona mapování peněžních toků
DocType: Travel Request,Costing Details,Kalkulovat podrobnosti
apps/erpnext/erpnext/selling/report/sales_partner_transaction_summary/sales_partner_transaction_summary.js,Show Return Entries,Zobrazit položky návratu
apps/erpnext/erpnext/accounts/page/pos/pos.js,Serial no item cannot be a fraction,Sériové žádná položka nemůže být zlomkem
DocType: Journal Entry,Difference (Dr - Cr),Rozdíl (Dr - Cr)
DocType: Bank Guarantee,Providing,Poskytování
DocType: Account,Profit and Loss,Zisky a ztráty
DocType: Tally Migration,Tally Migration,Tally Migration
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,"Not permitted, configure Lab Test Template as required","Není povoleno, podle potřeby nastavte šablonu testování laboratoře"
DocType: Patient,Risk Factors,Rizikové faktory
DocType: Patient,Occupational Hazards and Environmental Factors,Pracovní nebezpečí a environmentální faktory
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Stock Entries already created for Work Order ,Zápisy již vytvořené pro pracovní objednávku
apps/erpnext/erpnext/templates/pages/cart.html,See past orders,Zobrazit minulé objednávky
apps/erpnext/erpnext/public/js/hub/pages/Selling.vue,{0} conversations,{0} konverzací
DocType: Vital Signs,Respiratory rate,Dechová frekvence
apps/erpnext/erpnext/config/help.py,Managing Subcontracting,Správa Subdodávky
DocType: Vital Signs,Body Temperature,Tělesná teplota
DocType: Project,Project will be accessible on the website to these users,Projekt bude k dispozici na webových stránkách k těmto uživatelům
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},"Nelze zrušit {0} {1}, protože sériové číslo {2} nepatří do skladu {3}"
DocType: Detected Disease,Disease,Choroba
DocType: Company,Default Deferred Expense Account,Výchozí účet odložených výdajů
apps/erpnext/erpnext/config/projects.py,Define Project type.,Definujte typ projektu.
DocType: Supplier Scorecard,Weighting Function,Funkce vážení
DocType: Employee Tax Exemption Proof Submission,Total Actual Amount,Celková skutečná částka
DocType: Healthcare Practitioner,OP Consulting Charge,Konzultační poplatek OP
DocType: Student Report Generation Tool,Show Marks,Zobrazit značky
DocType: Support Settings,Get Latest Query,Získejte nejnovější dotaz
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,"Sazba, za kterou je ceníková měna převedena na základní měnu společnosti"
apps/erpnext/erpnext/setup/doctype/company/company.py,Account {0} does not belong to company: {1},Účet {0} nepatří k firmě: {1}
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation already used for another company,Zkratka již byla použita pro jinou společnost
DocType: Selling Settings,Default Customer Group,Výchozí Customer Group
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Payment Tems,Platební tems
DocType: Employee,IFSC Code,Kód IFSC
DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Je-li zakázat, ""zaokrouhlí celková"" pole nebude viditelný v jakékoli transakce"
DocType: BOM,Operating Cost,Provozní náklady
DocType: Crop,Produced Items,Vyrobené položky
DocType: Bank Statement Transaction Entry,Match Transaction to Invoices,Shoda transakce na faktury
apps/erpnext/erpnext/erpnext_integrations/exotel_integration.py,Error in Exotel incoming call,Chyba při příchozím hovoru Exotel
DocType: Sales Order Item,Gross Profit,Hrubý Zisk
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Unblock Invoice,Odblokovat fakturu
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Increment cannot be 0,Přírůstek nemůže být 0
DocType: Company,Delete Company Transactions,Smazat transakcí Company
DocType: Production Plan Item,Quantity and Description,Množství a popis
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 je povinný pro bankovní transakce
DocType: Purchase Receipt,Add / Edit Taxes and Charges,Přidat / Upravit daní a poplatků
DocType: Payment Entry Reference,Supplier Invoice No,Dodavatelské faktury č
DocType: Territory,For reference,Pro srovnání
DocType: Healthcare Settings,Appointment Confirmation,Potvrzení jmenování
DocType: Inpatient Record,HLC-INP-.YYYY.-,HLC-INP-.RRRR.-
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot delete Serial No {0}, as it is used in stock transactions","Nelze odstranit Pořadové číslo {0}, který se používá na skladě transakcích"
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Closing (Cr),Uzavření (Cr)
DocType: Purchase Invoice,Registered Composition,Registrované složení
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html,Hello,Ahoj
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Move Item,Přemístit položku
DocType: Employee Incentive,Incentive Amount,Část pobídky
,Employee Leave Balance Summary,Shrnutí zůstatku zaměstnanců
DocType: Serial No,Warranty Period (Days),Záruční doba (dny)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Total Credit/ Debit Amount should be same as linked Journal Entry,Celková částka Úvěr / Debit by měla být stejná jako propojený deník
DocType: Installation Note Item,Installation Note Item,Poznámka k instalaci bod
DocType: Production Plan Item,Pending Qty,Čekající Množství
DocType: Budget,Ignore,Ignorovat
apps/erpnext/erpnext/accounts/party.py,{0} {1} is not active,{0} {1} není aktivní
DocType: Woocommerce Settings,Freight and Forwarding Account,Účet přepravy a zasílání
apps/erpnext/erpnext/config/accounts.py,Setup cheque dimensions for printing,Zkontrolujte nastavení rozměry pro tisk
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Create Salary Slips,Vytvoření platebních karet
DocType: Vital Signs,Bloated,Nafouklý
DocType: Salary Slip,Salary Slip Timesheet,Plat Slip časový rozvrh
apps/erpnext/erpnext/controllers/buying_controller.py,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dodavatel Warehouse povinné pro subdodavatelskou doklad o zakoupení
DocType: Item Price,Valid From,Platnost od
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Your rating: ,Vaše hodnocení:
DocType: Sales Invoice,Total Commission,Celkem Komise
DocType: Tax Withholding Account,Tax Withholding Account,Účet pro zadržení daně
DocType: Pricing Rule,Sales Partner,Sales Partner
apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Všechna hodnocení dodavatelů.
DocType: Buying Settings,Purchase Receipt Required,Příjmka je vyžadována
DocType: Sales Invoice,Rail,Železnice
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Aktuální cena
DocType: Item,Website Image,Obrázek webové stránky
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í objednávka
apps/erpnext/erpnext/stock/doctype/item/item.py,Valuation Rate is mandatory if Opening Stock entered,"Cena je povinná, pokud je zadán počáteční stav zásob"
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,No records found in the Invoice table,Nalezené v tabulce faktury Žádné záznamy
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Please select Company and Party Type first,Vyberte první společnost a Party Typ
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,"Already set default in pos profile {0} for user {1}, kindly disabled default",Již nastavený výchozí profil {0} pro uživatele {1} je laskavě vypnut výchozí
apps/erpnext/erpnext/config/accounts.py,Financial / accounting year.,Finanční / Účetní rok.
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js,Accumulated Values,Neuhrazená Hodnoty
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot delete item {1} which has already been delivered,"Řádek # {0}: Nelze odstranit položku {1}, která již byla doručena"
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Sorry, Serial Nos cannot be merged","Je nám líto, sériových čísel nelze sloučit"
DocType: Shopify Settings,Customer Group will set to selected group while syncing customers from Shopify,Zákaznická skupina nastaví vybranou skupinu při synchronizaci zákazníků se službou Shopify
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: Supplier,Prevent RFQs,Zabraňte RFQ
DocType: Hub User,Hub User,Uživatel Hubu
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Salary Slip submitted for period from {0} to {1},Zápis o platu odeslán na období od {0} do {1}
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Passing Score value should be between 0 and 100,Hodnota úspěšného skóre by měla být mezi 0 a 100
DocType: Loyalty Point Entry Redemption,Redeemed Points,Vyčerpané body
,Lead Id,Id leadu
DocType: C-Form Invoice Detail,Grand Total,Celkem
DocType: Assessment Plan,Course,Chod
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Section Code,Kód oddílu
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Valuation Rate required for Item {0} at row {1},Míra ocenění požadovaná pro položku {0} v řádku {1}
DocType: Timesheet,Payslip,výplatní páska
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Pricing Rule {0} is updated,Pravidlo pro stanovení cen {0} je aktualizováno
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Half day date should be in between from date and to date,Denní datum by mělo být mezi dnem a dnem
DocType: POS Closing Voucher,Expense Amount,Výdaje
apps/erpnext/erpnext/public/js/pos/pos.html,Item Cart,Item košík
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Capacity Planning Error, planned start time can not be same as end time","Chyba plánování kapacity, plánovaný čas zahájení nemůže být stejný jako čas ukončení"
DocType: Quality Action,Resolution,Řešení
DocType: Employee,Personal Bio,Osobní bio
DocType: C-Form,IV,IV
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Membership ID,Členství ID
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Receive at Warehouse Entry,Příjem na vstupu do skladu
apps/erpnext/erpnext/templates/pages/material_request_info.html,Delivered: {0},Dodává: {0}
DocType: QuickBooks Migrator,Connected to QuickBooks,Připojeno k QuickBooks
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please identify/create Account (Ledger) for type - {0},Určete / vytvořte účet (účetní kniha) pro typ - {0}
DocType: Bank Statement Transaction Entry,Payable Account,Splatnost účtu
DocType: Payment Entry,Type of Payment,Typ platby
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date is mandatory,Poloviční den je povinný
DocType: Sales Order,Billing and Delivery Status,Fakturace a Delivery Status
DocType: Job Applicant,Resume Attachment,Resume Attachment
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customers,Opakujte zákazníci
DocType: Leave Control Panel,Allocate,Přidělit
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variant,Vytvořte variantu
DocType: Sales Invoice,Shipping Bill Date,Přepravní účet
DocType: Production Plan,Production Plan,Plán produkce
DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Otevření nástroje pro vytváření faktur
DocType: Salary Component,Round to the Nearest Integer,Zaokrouhlí na nejbližší celé číslo
DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,"Povolit přidání zboží, které není na skladě, do košíku"
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Sales Return
DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Nastavte počet transakcí na základě sériového č. Vstupu
,Total Stock Summary,Shrnutí souhrnného stavu
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,"You can only plan for upto {0} vacancies and budget {1} \
				for {2} as per staffing plan {3} for parent company {4}.",Můžete plánovat až {0} volných pracovních míst a rozpočet {1} \ za {2} podle personálního plánu {3} pro mateřskou společnost {4}.
DocType: Announcement,Posted By,Přidal
apps/erpnext/erpnext/controllers/stock_controller.py,Quality Inspection required for Item {0} to submit,Pro odeslání položky {0} je vyžadována kontrola kvality
DocType: Item,Delivered by Supplier (Drop Ship),Dodáváno dodavatelem (Drop Ship)
DocType: Healthcare Settings,Confirmation Message,Potvrzovací zpráva
apps/erpnext/erpnext/config/crm.py,Database of potential customers.,Databáze potenciálních zákazníků.
DocType: Authorization Rule,Customer or Item,Zákazník nebo položka
apps/erpnext/erpnext/config/accounts.py,Customer database.,Databáze zákazníků.
DocType: Quotation,Quotation To,Nabídka k
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Middle Income,Středními příjmy
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Cr),Otvor (Cr)
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í měrná jednotka bodu {0} nemůže být změněna přímo, protože jste už nějaké transakce (y) s jiným nerozpuštěných. Budete muset vytvořit novou položku použít jiný výchozí UOM."
DocType: Purchase Invoice,Overseas,Zámoří
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Please set the Company,Nastavte společnost
DocType: Share Balance,Share Balance,Sázení podílů
DocType: Amazon MWS Settings,AWS Access Key ID,Identifikátor přístupového klíče AWS
DocType: Production Plan,Download Required Materials,Stáhněte si požadované materiály
DocType: Employee Tax Exemption Declaration,Monthly House Rent,Měsíční pronájem domu
apps/erpnext/erpnext/projects/doctype/task/task_list.js,Set as Completed,Nastavit jako dokončeno
DocType: Purchase Order Item,Billed Amt,Účtovaného Amt
DocType: Training Result Employee,Training Result Employee,Vzdělávací Výsledek
DocType: Warehouse,A logical Warehouse against which stock entries are made.,"Logická Warehouse na položky, které mohou být vyrobeny."
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Principal Amount,jistina
DocType: Loan Application,Total Payable Interest,Celkem Splatné úroky
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Outstanding: {0},Celková nevyřízená hodnota: {0}
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Open Contact,Otevřete kontakt
DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Prodejní faktury časový rozvrh
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference No & Reference Date is required for {0},Referenční číslo a referenční datum je nutné pro {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Serial no(s) required for serialized item {0},Sériové číslo požadované pro sériovou položku {0}
DocType: Payroll Entry,Select Payment Account to make Bank Entry,"Vybrat Platební účet, aby Bank Entry"
apps/erpnext/erpnext/config/accounts.py,Opening and Closing,Otevření a zavření
DocType: Hotel Settings,Default Invoice Naming Series,Výchozí série pojmenování faktur
apps/erpnext/erpnext/utilities/activation.py,"Create Employee records to manage leaves, expense claims and payroll","Vytvořit Zaměstnanecké záznamy pro správu listy, prohlášení o výdajích a mezd"
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: Restaurant Reservation,Restaurant Reservation,Rezervace restaurace
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Your Items,Vaše položky
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal Writing,Návrh Psaní
DocType: Payment Entry Deduction,Payment Entry Deduction,Platba Vstup dedukce
DocType: Service Level Priority,Service Level Priority,Priorita úrovně služeb
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Wrapping up,Obalte se
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Notify Customers via Email,Informujte zákazníky e-mailem
DocType: Item,Batch Number Series,Číselná řada šarží
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,Another Sales Person {0} exists with the same Employee id,Další prodeje osoba {0} existuje se stejným id zaměstnance
DocType: Employee Advance,Claimed Amount,Požadovaná částka
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.js,Expire Allocation,Vyprší přidělení
DocType: QuickBooks Migrator,Authorization Settings,Nastavení oprávnění
DocType: Travel Itinerary,Departure Datetime,Čas odletu
apps/erpnext/erpnext/hub_node/api.py,No items to publish,Žádné položky k publikování
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Please select Item Code first,Nejprve vyberte kód položky
DocType: Customer,CUST-.YYYY.-,CUST-.YYYY.-
DocType: Travel Request Costing,Travel Request Costing,Náklady na cestování
apps/erpnext/erpnext/config/healthcare.py,Masters,Masters
DocType: Employee Onboarding,Employee Onboarding Template,Šablona zaměstnanců na palubě
DocType: Assessment Plan,Maximum Assessment Score,Maximální skóre Assessment
apps/erpnext/erpnext/config/accounts.py,Update Bank Transaction Dates,Transakční Data aktualizace Bank
apps/erpnext/erpnext/config/projects.py,Time Tracking,Time Tracking
DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLIKÁT PRO TRANSPORTER
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Row {0}# Paid Amount cannot be greater than requested advance amount,Řádek {0} # Placená částka nesmí být vyšší než požadovaná částka
DocType: Fiscal Year Company,Fiscal Year Company,Fiskální rok Společnosti
DocType: Packing Slip Item,DN Detail,DN Detail
DocType: Training Event,Conference,Konference
DocType: Employee Grade,Default Salary Structure,Výchozí platová struktura
DocType: Stock Entry,Send to Warehouse,Odeslat do skladu
apps/erpnext/erpnext/hr/report/daily_work_summary_replies/daily_work_summary_replies.py,Replies,Odpovědi
DocType: Timesheet,Billed,Fakturováno
DocType: Batch,Batch Description,Popis Šarže
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Creating student groups,Vytváření studentských skupin
apps/erpnext/erpnext/accounts/utils.py,"Payment Gateway Account not created, please create one manually.","Platební brána účet nevytvořili, prosím, vytvořte ručně."
DocType: Supplier Scorecard,Per Year,Za rok
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í do tohoto programu podle DOB
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot delete item {1} which is assigned to customer's purchase order.,"Řádek # {0}: Nelze odstranit položku {1}, která je přiřazena k objednávce zákazníka."
DocType: Sales Invoice,Sales Taxes and Charges,Prodej Daně a poplatky
DocType: Supplier Scorecard Period,PU-SSP-.YYYY.-,PU-SSP-.YYYY.-
DocType: Vital Signs,Height (In Meter),Výška (v metru)
DocType: Student,Sibling Details,sourozenec Podrobnosti
DocType: Vehicle Service,Vehicle Service,servis vozidel
DocType: Employee,Reason for Resignation,Důvod rezignace
DocType: Sales Invoice,Credit Note Issued,Dobropisu vystaveného
DocType: Task,Weight,Hmotnost
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Faktura / Zápis do deníku Podrobnosti
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,{0} bank transaction(s) created,Bylo vytvořeno {0} bankovních transakcí
apps/erpnext/erpnext/accounts/utils.py,{0} '{1}' not in Fiscal Year {2},{0} '{1}' není v fiskálním roce {2}
DocType: Buying Settings,Settings for Buying Module,Nastavení pro nákup modul
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Asset {0} does not belong to company {1},Aktiva {0} nepatří do společnosti {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter Purchase Receipt first,"Prosím, zadejte první doklad o zakoupení"
DocType: Buying Settings,Supplier Naming By,Dodavatel Pojmenování By
DocType: Activity Type,Default Costing Rate,Výchozí kalkulace Rate
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Maintenance Schedule,Plán údržby
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.","Pak se pravidla pro tvorbu cen jsou odfiltrovány založeny na zákazníka, skupiny zákazníků, území, dodavatel, dodavatel typ, kampaň, obchodní partner atd"
DocType: Employee Promotion,Employee Promotion Details,Podrobnosti o podpoře zaměstnanců
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Inventory,Čistá Změna stavu zásob
DocType: Employee,Passport Number,Číslo pasu
DocType: Invoice Discounting,Accounts Receivable Credit Account,Kreditní účet účtů pohledávek
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian2,Souvislost s Guardian2
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Manager,Manažer
DocType: Payment Entry,Payment From / To,Platba z / do
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,From Fiscal Year,Od fiskálního roku
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í dlužné částky za zákazníka. Úvěrový limit musí být aspoň {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please set account in Warehouse {0},Nastavte prosím účet ve skladu {0}
apps/erpnext/erpnext/controllers/trends.py,'Based On' and 'Group By' can not be same,"""Založeno na"" a ""Seskupeno podle"", nemůže být stejné"
DocType: Sales Person,Sales Person Targets,Obchodník cíle
DocType: GSTR 3B Report,December,prosinec
DocType: Work Order Operation,In minutes,V minutách
apps/erpnext/erpnext/templates/pages/cart.html,See past quotations,Zobrazit minulé nabídky
DocType: Issue,Resolution Date,Rozlišení Datum
DocType: Lab Test Template,Compound,Sloučenina
DocType: Opportunity,Probability (%),Pravděpodobnost (%)
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Dispatch Notification,Oznámení o odeslání
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Select Property,Vyberte vlastnost
DocType: Course Activity,Course Activity,Aktivita kurzu
DocType: Student Batch Name,Batch Name,Batch Name
DocType: Fee Validity,Max number of visit,Maximální počet návštěv
DocType: Accounting Dimension Detail,Mandatory For Profit and Loss Account,Povinné pro účet zisků a ztrát
,Hotel Room Occupancy,Hotel Occupancy
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please set default Cash or Bank account in Mode of Payment {0},Prosím nastavte výchozí v hotovosti nebo bankovním účtu v způsob platby {0}
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Enroll,Zapsat
DocType: GST Settings,GST Settings,Nastavení GST
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}
DocType: Selling Settings,Customer Naming By,Zákazník Pojmenování By
DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Ukáže studenta přítomnému v Student měsíční návštěvnost Zpráva
DocType: Depreciation Schedule,Depreciation Amount,odpisy Částka
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to Group,Převést do skupiny
DocType: Activity Cost,Activity Type,Druh činnosti
DocType: Request for Quotation,For individual supplier,Pro jednotlivé dodavatele
DocType: Workstation,Production Capacity,Produkční kapacita
DocType: BOM Operation,Base Hour Rate(Company Currency),Základna hodinová sazba (Company měny)
,Qty To Be Billed,Množství k vyúčtování
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Dodává Částka
DocType: Coupon Code,Gift Card,Dárková poukázka
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Vyhrazeno Množství pro výrobu: Množství surovin pro výrobu výrobních položek.
DocType: Loyalty Point Entry Redemption,Redemption Date,Datum vykoupení
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Tato bankovní transakce je již plně sladěna
DocType: Sales Invoice,Packing List,Balící list
apps/erpnext/erpnext/config/buying.py,Purchase Orders given to Suppliers.,Nákupní Objednávky odeslané Dodavatelům.
DocType: Contract,Contract Template,Šablona smlouvy
DocType: Clinical Procedure Item,Transfer Qty,Množství přenosu
DocType: Purchase Invoice Item,Asset Location,Umístění majetku
apps/erpnext/erpnext/projects/report/billing_summary.py, From Date can not be greater than To Date,Od data nemůže být větší než do dne
DocType: Tax Rule,Shipping Zipcode,Poštovní směrovací číslo
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Publishing,Publikování
DocType: Accounts Settings,Report Settings,Nastavení přehledů
DocType: Activity Cost,Projects User,Projekty uživatele
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Consumed,Spotřeba
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,{0}: {1} not found in Invoice Details table,{0}: {1} nebyla nalezena v tabulce Podrobnosti Faktury
DocType: Asset,Asset Owner Company,Společnost vlastníků aktiv
DocType: Company,Round Off Cost Center,Zaokrouhlovací nákladové středisko
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Údržba Navštivte {0} musí být zrušena před zrušením této prodejní objednávky
apps/erpnext/erpnext/templates/pages/help.html,What do you need help with?,S čím potřebuješ pomoci?
DocType: Employee Checkin,Shift Start,Shift Start
DocType: Appointment Booking Settings,Availability Of Slots,Dostupnost slotů
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Material Transfer,Přesun materiálu
DocType: Cost Center,Cost Center Number,Číslo nákladového střediska
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py,Could not find path for ,Nelze najít cestu pro
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Dr),Opening (Dr)
DocType: Compensatory Leave Request,Work End Date,Datum ukončení práce
DocType: Loan,Applicant,Žadatel
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Posting timestamp must be after {0},Časová značka zadání musí být po {0}
,GST Itemised Purchase Register,GST Itemised Purchase Register
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is a limited liability company,"Platí, pokud je společnost společností s ručením omezeným"
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py,Expected and Discharge dates cannot be less than Admission Schedule date,Očekávané a propuštěné datum nesmí být kratší než datum přijetí
DocType: Course Scheduling Tool,Reschedule,Změna plánu
DocType: Item Tax Template,Item Tax Template,Šablona daně z položky
DocType: Loan,Total Interest Payable,Celkem splatných úroků
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for Hold,Důvod pozastavení
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Přistál nákladů daně a poplatky
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,Řádek {0}: Nastavte prosím na důvod osvobození od daně v daních z prodeje a poplatcích
DocType: Quality Goal Objective,Quality Goal Objective,Cíl kvality
DocType: Work Order Operation,Actual Start Time,Skutečný čas začátku
DocType: Purchase Invoice Item,Deferred Expense Account,Odložený nákladový účet
DocType: BOM Operation,Operation Time,Čas operace
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Finish,Dokončit
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Base,Báze
DocType: Timesheet,Total Billed Hours,Celkem Předepsané Hodiny
DocType: Pricing Rule Item Group,Pricing Rule Item Group,Skupina položek cenových pravidel
DocType: Travel Itinerary,Travel To,Cestovat do
apps/erpnext/erpnext/config/accounts.py,Exchange Rate Revaluation master.,Velitel přehodnocení směnného kurzu.
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Nastavte číslovací řady pro Docházku prostřednictvím Nastavení&gt; Číslovací řady
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Write Off Amount,Odepsat Částka
DocType: Leave Block List Allow,Allow User,Umožňuje uživateli
DocType: Journal Entry,Bill No,Bill No
DocType: Company,Gain/Loss Account on Asset Disposal,Zisk / ztráty na majetku likvidaci
DocType: Vehicle Log,Service Details,Podrobnosti o službě
DocType: Lab Test Template,Grouped,Skupinové
DocType: Selling Settings,Delivery Note Required,Delivery Note Povinné
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Submitting Salary Slips...,Odeslání platebních karet ...
DocType: Bank Guarantee,Bank Guarantee Number,Číslo bankovní záruky
DocType: Assessment Criteria,Assessment Criteria,Kritéria hodnocení
DocType: BOM Item,Basic Rate (Company Currency),Basic Rate (Company měny)
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 nadřazený účet {1} nalezen. Vytvořte prosím nadřazený účet v odpovídající COA
apps/erpnext/erpnext/support/doctype/issue/issue.js,Split Issue,Split Issue
DocType: Student Attendance,Student Attendance,Student Účast
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,No data to export,Žádné údaje k exportu
DocType: Sales Invoice Timesheet,Time Sheet,Rozvrh hodin
DocType: Manufacturing Settings,Backflush Raw Materials Based On,Se zpětným suroviny na základě
DocType: Sales Invoice,Port Code,Port Code
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reserve Warehouse,Rezervní sklad
DocType: Lead,Lead is an Organization,Vedoucí je organizace
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Return amount cannot be greater unclaimed amount,Vrácená částka nemůže být větší nevyžádaná částka
DocType: Guardian Interest,Interest,Zajímat
apps/erpnext/erpnext/accounts/doctype/tax_category/tax_category_dashboard.py,Pre Sales,Předprodej
DocType: Instructor Log,Other Details,Další podrobnosti
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Suplier,suplier
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Actual Delivery Date,Skutečné datum dodání
DocType: Lab Test,Test Template,Testovací šablona
DocType: Restaurant Order Entry Item,Served,Podával
apps/erpnext/erpnext/config/non_profit.py,Chapter information.,Informace o kapitole.
DocType: Account,Accounts,Účty
DocType: Vehicle,Odometer Value (Last),Údaj měřiče ujeté vzdálenosti (Last)
apps/erpnext/erpnext/config/buying.py,Templates of supplier scorecard criteria.,Šablony kritérií kritérií pro dodavatele.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Marketing,Marketing
DocType: Sales Invoice,Redeem Loyalty Points,Uplatnit věrnostní body
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry is already created,Vstup Platba je již vytvořili
DocType: Request for Quotation,Get Suppliers,Získejte dodavatele
DocType: Purchase Receipt Item Supplied,Current Stock,Current skladem
DocType: Pricing Rule,System will notify to increase or decrease quantity or amount ,Systém vás upozorní na zvýšení nebo snížení množství nebo množství
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Preview Salary Slip,Preview výplatní pásce
apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Vytvoření časového rozvrhu
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Účet {0} byl zadán vícekrát
DocType: Account,Expenses Included In Valuation,Náklady ceně oceňování
apps/erpnext/erpnext/hooks.py,Purchase Invoices,Nákup faktur
apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,"Můžete obnovit pouze tehdy, pokud vaše členství vyprší během 30 dnů"
DocType: Shopping Cart Settings,Show Stock Availability,Zobrazit dostupnost skladem
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Nastavte {0} v kategorii aktiv {1} nebo ve firmě {2}
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per section 17(5),Podle oddílu 17 (5)
DocType: Location,Longitude,Zeměpisná délka
,Absent Student Report,Absent Student Report
DocType: Crop,Crop Spacing UOM,Rozdělení výsevních ploch UOM
DocType: Loyalty Program,Single Tier Program,Jednoduchý program
DocType: Woocommerce Settings,Delivery After (Days),Dodávka po (dny)
DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,"Zvolte pouze, pokud máte nastavené dokumenty pro mapování cash flow"
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Address 1,Z adresy 1
DocType: Email Digest,Next email will be sent on:,Další e-mail bude odeslán dne:
DocType: Supplier Scorecard,Per Week,Za týden
apps/erpnext/erpnext/stock/doctype/item/item.py,Item has variants.,Položka má varianty.
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Total Student,Celkový počet studentů
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Item {0} not found,Položka {0} nebyl nalezen
DocType: Bin,Stock Value,Reklamní Value
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Duplicate {0} found in the table,V tabulce byl nalezen duplikát {0}
apps/erpnext/erpnext/accounts/doctype/account/account.py,Company {0} does not exist,Společnost {0} neexistuje
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} has fee validity till {1},{0} má platnost až do {1}
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Tree Type,Tree Type
DocType: Leave Control Panel,Employee Grade (optional),Hodnocení zaměstnanců (volitelné)
DocType: Pricing Rule,Apply Rule On Other,Použít pravidlo na jiné
DocType: BOM Explosion Item,Qty Consumed Per Unit,Množství spotřebované na jednotku
DocType: Shift Type,Late Entry Grace Period,Pozdní doba odkladu
DocType: GST Account,IGST Account,Účet IGST
DocType: Serial No,Warranty Expiry Date,Záruka Datum vypršení platnosti
DocType: Material Request Item,Quantity and Warehouse,Množství a sklad
DocType: Sales Invoice,Commission Rate (%),Výše provize (%)
DocType: Asset,Allow Monthly Depreciation,Povolit měsíční odpisy
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Program,Vyberte prosím Program
DocType: Project,Estimated Cost,Odhadované náklady
DocType: Supplier Quotation,Link to material requests,Odkaz na materiálních požadavků
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Publish,Publikovat
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Aerospace,Aerospace
,Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC]
DocType: Journal Entry,Credit Card Entry,Vstup Kreditní karta
apps/erpnext/erpnext/config/selling.py,Invoices for Costumers.,Faktury pro zákazníky.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,In Value,v Hodnota
DocType: Asset Category,Depreciation Options,Možnosti odpisů
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Either location or employee must be required,Musí být požadováno umístění nebo zaměstnanec
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Create Employee,Vytvořit zaměstnance
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid Posting Time,Neplatný čas přidávání
DocType: Salary Component,Condition and Formula,Stav a vzorec
DocType: Lead,Campaign Name,Název kampaně
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Task Completion,Při dokončení úkolu
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á doba dovolené,"
DocType: Fee Validity,Healthcare Practitioner,Zdravotnický praktik
DocType: Hotel Room,Capacity,Kapacita
DocType: Travel Request Costing,Expense Type,Typ výdajů
DocType: Selling Settings,Close Opportunity After Days,V blízkosti Příležitost po několika dnech
,Reserved,Rezervováno
DocType: Driver,License Details,Podrobnosti licence
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field From Shareholder cannot be blank,Pole Od akcionáře nesmí být prázdné
DocType: Leave Allocation,Allocation,Přidělení
DocType: Purchase Order,Supply Raw Materials,Dodávek surovin
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/config/getting_started.py,Create Opening Sales and Purchase Invoices,Vytvořte otevírací prodejní a nákupní faktury
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Current Assets,Oběžná aktiva
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,{0} is not a stock Item,{0} není skladová položka
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',Podělte se o své připomínky k tréninku kliknutím na &quot;Tréninkové připomínky&quot; a poté na &quot;Nové&quot;
DocType: Call Log,Caller Information,Informace o volajícím
DocType: Mode of Payment Account,Default Account,Výchozí účet
apps/erpnext/erpnext/stock/doctype/item/item.py,Please select Sample Retention Warehouse in Stock Settings first,Zvolte prosím nejprve Sample Retention Warehouse in Stock Stock
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,Please select the Multiple Tier Program type for more than one collection rules.,Zvolte typ víceúrovňového programu pro více než jednu pravidla kolekce.
DocType: Payment Entry,Received Amount (Company Currency),Přijaté Částka (Company měna)
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. Zkontrolujte svůj účet GoCardless pro více informací
DocType: Work Order,Skip Material Transfer to WIP Warehouse,Přeskočit přenos materiálu do skladu WIP
DocType: Contract,N/A,N / A
DocType: Task Type,Task Type,Typ úlohy
DocType: Topic,Topic Content,Obsah tématu
DocType: Delivery Settings,Send with Attachment,Odeslat s přílohou
DocType: Service Level,Priorities,Priority
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py,Please select weekly off day,"Prosím, vyberte týdenní off den"
DocType: Inpatient Record,O Negative,O Negativní
DocType: Work Order Operation,Planned End Time,Plánované End Time
DocType: POS Profile,Only show Items from these Item Groups,Zobrazovat pouze položky z těchto skupin položek
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction cannot be converted to ledger,Účet s transakcemi nelze převést na hlavní účetní knihu
apps/erpnext/erpnext/config/non_profit.py,Memebership Type Details,Podrobnosti o typu člena
DocType: Delivery Note,Customer's Purchase Order No,Zákazníka Objednávka No
DocType: Clinical Procedure,Consume Stock,Spotřeba zásob
DocType: Budget,Budget Against,rozpočet Proti
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Lost Reasons,Ztracené důvody
apps/erpnext/erpnext/stock/reorder_item.py,Auto Material Requests Generated,Žádosti Auto materiál vygenerovaný
DocType: Shift Type,Working hours below which Half Day is marked. (Zero to disable),"Pracovní doba, pod kterou je označen půl dne. (Nulování zakázat)"
DocType: Job Card,Total Completed Qty,Celkem dokončeno Množství
DocType: HR Settings,Auto Leave Encashment,Automatické ponechání inkasa
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js,Lost,Ztracený
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,You can not enter current voucher in 'Against Journal Entry' column,"Nelze zadat aktuální poukaz v ""Proti Zápis do deníku"" sloupci"
DocType: Employee Benefit Application Detail,Max Benefit Amount,Maximální částka prospěchu
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for manufacturing,Vyhrazeno pro výrobu
DocType: Soil Texture,Sand,Písek
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Energy,Energie
DocType: Opportunity,Opportunity From,Příležitost Z
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 vyžadovaná pro položku {2}. Poskytli jste {3}.
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/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please select a table,Vyberte prosím tabulku
DocType: BOM,Website Specifications,Webových stránek Specifikace
apps/erpnext/erpnext/accounts/doctype/account/account.py,Please add the account to root level Company - %s,Přidejte účet do kořenové úrovně Společnost -% s
DocType: Content Activity,Content Activity,Obsahová aktivita
DocType: Special Test Items,Particulars,Podrobnosti
DocType: Employee Checkin,Employee Checkin,Kontrola zaměstnanců
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0}: From {0} of type {1},{0}: Od {0} typu {1}
apps/erpnext/erpnext/config/crm.py,Sends Mails to lead or contact based on a Campaign schedule,Odešle e-maily na vedení nebo kontakt na základě plánu kampaně
apps/erpnext/erpnext/controllers/selling_controller.py,Row {0}: Conversion Factor is mandatory,Row {0}: Konverzní faktor je povinné
DocType: Student,A+,A+
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}","Více Cena pravidla existuje u stejných kritérií, prosím vyřešit konflikt tím, že přiřadí prioritu. Cena Pravidla: {0}"
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation Account,Účet z přecenění směnného kurzu
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Min Amt can not be greater than Max Amt,Min Amt nesmí být větší než Max Amt
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 BOM, jak to souvisí s ostatními kusovníky"
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Please select Company and Posting Date to getting entries,Zvolte prosím datum společnosti a datum odevzdání
DocType: Asset,Maintenance,Údržba
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Get from Patient Encounter,Získejte z setkání pacienta
DocType: Subscriber,Subscriber,Odběratel
DocType: Item Attribute Value,Item Attribute Value,Položka Hodnota atributu
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 pro prodej.
apps/erpnext/erpnext/hr/doctype/leave_ledger_entry/leave_ledger_entry.py,Only expired allocation can be cancelled,"Zrušit lze pouze přidělení, jehož platnost skončila"
DocType: Item,Maximum sample quantity that can be retained,"Maximální množství vzorku, které lze zadržet"
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} nelze převést více než {2} na objednávku {3}
apps/erpnext/erpnext/config/crm.py,Sales campaigns.,Prodej kampaně.
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Unknown Caller,Neznámý volající
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í daň šablona, která může být použita pro všechny prodejních transakcí. Tato šablona může obsahovat seznam daňových hlav a také další náklady / příjmy hlavy jako ""doprava"", ""pojištění"", ""manipulace"" atd. 

 #### Poznámka: 

 daňovou sazbu, vy definovat zde bude základní sazba daně pro všechny ** položky **. Pokud jsou položky ** **, které mají různé ceny, musí být přidány v ** Položka daních ** stůl v ** položky ** mistra.

 #### Popis sloupců 

 1. Výpočet Type: 
 - To může být na ** Čistý Total ** (což je součet základní částky).
 - ** Na předchozí řady Total / Částka ** (pro kumulativní daní a poplatků). Zvolíte-li tuto možnost, bude daň se použije jako procento z předchozí řady (v daňové tabulky) množství nebo celkem.
 - ** Aktuální ** (jak je uvedeno).
 2. Účet Hlava: kniha účtu, pod kterým se bude tato daň rezervovat 
 3. Nákladové středisko: V případě, že daň / poplatek je příjmem (jako poštovné) nebo nákladů je třeba rezervovat na nákladové středisko.
 4. Popis: Popis daně (které budou vytištěny v faktur / uvozovek).
 5. Rate: Sazba daně.
 6. Částka: Částka daně.
 7. Celkem: Kumulativní celková k tomuto bodu.
 8. Zadejte Row: Je-li na základě ""předchozí řady Total"" můžete zvolit číslo řádku, která bude přijata jako základ pro tento výpočet (výchozí je předchozí řádek).
 9. Je to poplatek v ceně do základní sazby ?: Pokud se to ověřit, znamená to, že tato daň nebude zobrazen pod tabulkou položky, ale budou zahrnuty do základní sazby v hlavním položce tabulky. To je užitečné, pokud chcete dát paušální cenu (včetně všech poplatků), ceny pro zákazníky."
DocType: Quality Action,Corrective,Nápravné
DocType: Employee,Bank A/C No.,"Č, bank. účtu"
DocType: Quality Inspection Reading,Reading 7,Čtení 7
DocType: Purchase Invoice,UIN Holders,Držáky UIN
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Ordered,částečně uspořádané
DocType: Lab Test,Lab Test,Laboratorní test
DocType: Student Report Generation Tool,Student Report Generation Tool,Nástroj pro generování zpráv studentů
DocType: Healthcare Schedule Time Slot,Healthcare Schedule Time Slot,Časový plán časového plánu pro zdravotní péči
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Name,Doc Name
DocType: Expense Claim Detail,Expense Claim Type,Náklady na pojistná Type
DocType: Shopping Cart Settings,Default settings for Shopping Cart,Výchozí nastavení Košík
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Save Item,Uložit položku
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Expense,Nové výdaje
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Ignore Existing Ordered Qty,Ignorovat existující objednané množství
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Timeslots,Přidat Timeslots
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 ve výchozím inventářním účtu ve firmě {1}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset scrapped via Journal Entry {0},Asset vyhozen přes položka deníku {0}
DocType: Loan,Interest Income Account,Účet Úrokové výnosy
DocType: Bank Transaction,Unreconciled,Bez smíření
DocType: Shift Type,Allow check-out after shift end time (in minutes),Povolit odhlášení po době ukončení směny (v minutách)
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Max benefits should be greater than zero to dispense benefits,"Maximální přínosy by měly být větší než nula, aby byly dávky vypláceny"
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py,Review Invitation Sent,Prohlížení pozvánky odesláno
DocType: Shift Assignment,Shift Assignment,Shift Assignment
DocType: Employee Transfer Property,Employee Transfer Property,Vlastnictví převodů zaměstnanců
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field Equity/Liability Account cannot be blank,Pole Účet vlastního kapitálu / odpovědnosti nemůže být prázdné
apps/erpnext/erpnext/accounts/doctype/cashier_closing/cashier_closing.py,From Time Should Be Less Than To Time,Od času by mělo být méně než čas
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Biotechnology,Biotechnologie
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, jak je uložena \, aby bylo možné vyplnit objednávku prodeje {2}."
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Maintenance Expenses,Náklady Office údržby
,BOM Explorer,Průzkumník BOM
DocType: Shopify Settings,Update Price from Shopify To ERPNext Price List,Aktualizovat cenu z Shopify do ERPNext Ceník
apps/erpnext/erpnext/config/help.py,Setting up Email Account,Nastavení e-mailový účet
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Please enter Item first,"Prosím, nejdřív zadejte položku"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Needs Analysis,Analýza potřeb
DocType: Asset Repair,Downtime,Nefunkčnost
DocType: Account,Liability,Odpovědnost
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankcionována Částka nemůže být větší než reklamace Částka v řádku {0}.
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Academic Term: ,Akademické označení:
DocType: Salary Detail,Do not include in total,Nezahrnujte celkem
DocType: Quiz Activity,Quiz Activity,Kvízová aktivita
DocType: Company,Default Cost of Goods Sold Account,Výchozí Náklady na prodané zboží účtu
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: Employee,Family Background,Rodinné poměry
DocType: Request for Quotation Supplier,Send Email,Odeslat email
DocType: Quality Goal,Weekday,Všední den
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid Attachment {0},Varování: Neplatná Příloha {0}
DocType: Item,Max Sample Quantity,Max. Množství vzorku
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,No Permission,Nemáte oprávnění
DocType: Contract Fulfilment Checklist,Contract Fulfilment Checklist,Kontrolní seznam plnění smlouvy
DocType: Vital Signs,Heart Rate / Pulse,Srdeční frekvence / puls
DocType: Supplier,Default Bank Account,Výchozí Bankovní účet
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ě Party, vyberte typ Party první"
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,'Update Stock' can not be checked because items are not delivered via {0},"""Aktualizovat sklad' nemůže být zaškrtnuto, protože položky nejsou dodány přes {0}"
DocType: Vehicle,Acquisition Date,akvizice Datum
apps/erpnext/erpnext/regional/italy/utils.py,Nos,Nos
DocType: Item,Items with higher weightage will be shown higher,Položky s vyšším weightage budou zobrazeny vyšší
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/stock/doctype/serial_no/serial_no.py,The following serial numbers were created: <br><br> {0},Byly vytvořeny následující sériová čísla: <br><br> {0}
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Bank Odsouhlasení Detail
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,No employee found,Žádný zaměstnanec nalezeno
DocType: Item,If subcontracted to a vendor,Pokud se subdodávky na dodavatele
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Student Group is already updated.,Studentská skupina je již aktualizována.
DocType: HR Settings,Restrict Backdated Leave Application,Omezte aplikaci Backdated Leave
apps/erpnext/erpnext/config/projects.py,Project Update.,Aktualizace projektu.
DocType: SMS Center,All Customer Contact,Vše Kontakt Zákazník
DocType: Location,Tree Details,Tree Podrobnosti
DocType: Marketplace Settings,Registered,Registrovaný
DocType: Training Event,Event Status,Event Status
DocType: Volunteer,Availability Timeslot,Dostupnost Timeslot
apps/erpnext/erpnext/config/support.py,Support Analytics,Podpora Analytics
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,"If you have any questions, please get back to us.","Pokud máte jakékoliv dotazy, prosím, dostat zpátky k nám."
DocType: Cash Flow Mapper,Cash Flow Mapper,Mapovač hotovostních toků
DocType: Item,Website Warehouse,Sklad pro web
DocType: Payment Reconciliation,Minimum Invoice Amount,Minimální částka faktury
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: náklady Center {2} nepatří do společnosti {3}
apps/erpnext/erpnext/www/lms/program.py,Program {0} does not exist.,Program {0} neexistuje.
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 skupina
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Timesheet {0} is already completed or cancelled,Časového rozvrhu {0} je již dokončena nebo zrušena
DocType: QuickBooks Migrator,QuickBooks Migrator,Migrace QuickBooks
apps/erpnext/erpnext/templates/pages/projects.html,No tasks,žádné úkoly
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Sales Invoice {0} created as paid,Prodejní faktura {0} byla vytvořena jako zaplacená
DocType: Item Variant Settings,Copy Fields to Variant,Kopírování polí na variantu
DocType: Asset,Opening Accumulated Depreciation,Otevření Oprávky
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js,Score must be less than or equal to 5,Skóre musí být menší než nebo rovna 5
DocType: Program Enrollment Tool,Program Enrollment Tool,Program Tool zápis
apps/erpnext/erpnext/config/accounts.py,C-Form records,C-Form záznamy
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shares already exist,Akcie již existují
apps/erpnext/erpnext/config/help.py,Customer and Supplier,Zákazník a Dodavatel
DocType: Email Digest,Email Digest Settings,Nastavení e-mailu Digest
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Thank you for your business!,Děkuji za Váš obchod!
apps/erpnext/erpnext/config/support.py,Support queries from customers.,Podpora dotazy ze strany zákazníků.
DocType: Employee Property History,Employee Property History,Historie majetku zaměstnanců
apps/erpnext/erpnext/stock/doctype/item/item.py,Variant Based On cannot be changed,Variant Based On nelze změnit
DocType: Setup Progress Action,Action Doctype,Akce Doctype
DocType: HR Settings,Retirement Age,Duchodovy vek
DocType: Bin,Moving Average Rate,Klouzavý průměr
DocType: Share Transfer,To Shareholder,Akcionáři
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Bill {1} dated {2},{0} proti účtence {1} ze dne {2}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From State,Z státu
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Allocating leaves...,Přidělení listů ...
DocType: Program Enrollment,Vehicle/Bus Number,Číslo vozidla / autobusu
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Create New Contact,Vytvořit nový kontakt
apps/erpnext/erpnext/education/doctype/course/course.js,Course Schedule,rozvrh
DocType: GSTR 3B Report,GSTR 3B Report,Zpráva GSTR 3B
DocType: Request for Quotation Supplier,Quote Status,Citace Stav
DocType: GoCardless Settings,Webhooks Secret,Webhooks Secret
DocType: Maintenance Visit,Completion Status,Dokončení Status
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Total payments amount can't be greater than {},Celková částka plateb nemůže být vyšší než {}
DocType: Daily Work Summary Group,Select Users,Vyberte možnost Uživatelé
DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,Položka ceny pokoje hotelu
DocType: Loyalty Program Collection,Tier Name,Název úrovně
DocType: HR Settings,Enter retirement age in years,Zadejte věk odchodu do důchodu v letech
DocType: Job Card,PO-JOB.#####,PO-JOB. #####
DocType: Crop,Target Warehouse,Target Warehouse
DocType: Payroll Employee Detail,Payroll Employee Detail,Zaměstnanecký detail zaměstnanců
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select a warehouse,Vyberte prosím sklad
DocType: Cheque Print Template,Starting location from left edge,Počínaje umístění od levého okraje
,Territory Target Variance Based On Item Group,Územní cílová odchylka podle skupiny položek
DocType: Upload Attendance,Import Attendance,Importovat Docházku
apps/erpnext/erpnext/public/js/pos/pos.html,All Item Groups,Všechny skupiny položek
DocType: Work Order,Item To Manufacture,Položka k výrobě
DocType: Leave Control Panel,Employment Type (optional),Typ zaměstnání (volitelné)
DocType: Pricing Rule,Threshold for Suggestion,Prahová hodnota pro návrh
apps/erpnext/erpnext/buying/utils.py,{0} {1} status is {2},{0} {1} je stav {2}
DocType: Water Analysis,Collection Temperature ,Teplota sběru
DocType: Employee,Provide Email Address registered in company,Poskytnout e-mailovou adresu registrovanou ve firmě
DocType: Shopping Cart Settings,Enable Checkout,Aktivovat Checkout
apps/erpnext/erpnext/config/help.py,Purchase Order to Payment,Objednávka na platební
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Projected Qty,Předpokládané množství
DocType: Sales Invoice,Payment Due Date,Splatno dne
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Reserved Qty: Quantity ordered for sale, but not delivered.","Reserved Množství: Množství objednal k prodeji, ale není doručena."
DocType: Drug Prescription,Interval UOM,Interval UOM
DocType: Customer,"Reselect, if the chosen address is edited after save","Znovu vyberte, pokud je zvolená adresa po uložení upravena"
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant {0} already exists with same attributes,Bod Variant {0} již existuje se stejnými vlastnostmi
DocType: Item,Hub Publishing Details,Podrobnosti o publikování Hubu
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,'Opening',"""Otevírací"""
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open To Do,Otevřená dělat
DocType: Pricing Rule,Mixed Conditions,Smíšené podmínky
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Summary Saved,Souhrn hovorů byl uložen
DocType: Issue,Via Customer Portal,Prostřednictvím zákaznického portálu
DocType: Employee Tax Exemption Proof Submission Detail,Actual Amount,Skutečná částka
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,SGST Amount,Částka SGST
DocType: Lab Test Template,Result Format,Formát výsledků
DocType: Expense Claim,Expenses,Výdaje
DocType: Service Level,Support Hours,Hodiny podpory
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Delivery Notes,Dodací listy
DocType: Item Variant Attribute,Item Variant Attribute,Položka Variant Atribut
,Purchase Receipt Trends,Doklad o koupi Trendy
DocType: Payroll Entry,Bimonthly,dvouměsíčník
DocType: Vehicle Service,Brake Pad,Brzdový pedál
DocType: Fertilizer,Fertilizer Contents,Obsah hnojiv
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Research & Development,Výzkum a vývoj
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py,Amount to Bill,Částka k Fakturaci
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Based On Payment Terms,Na základě platebních podmínek
apps/erpnext/erpnext/config/settings.py,ERPNext Settings,ERPDalší nastavení
DocType: Company,Registration Details,Registrace Podrobnosti
apps/erpnext/erpnext/support/doctype/issue/issue.py,Couldn't Set Service Level Agreement {0}.,Smlouvu o úrovni služeb nelze nastavit {0}.
DocType: Timesheet,Total Billed Amount,Celková částka Fakturovaný
DocType: Item Reorder,Re-Order Qty,Objednané množství při znovuobjednání
DocType: Leave Block List Date,Leave Block List Date,Nechte Block List Datum
DocType: Quality Feedback Parameter,Quality Feedback Parameter,Parametr zpětné vazby kvality
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/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ý počet použitelných poplatcích v dokladu o koupi zboží, které tabulky musí být stejná jako celkem daní a poplatků"
DocType: Production Plan Item,"If enabled, system will create the work order for the exploded items against which BOM is available.","Pokud je povoleno, systém vytvoří pracovní objednávku pro rozložené položky, proti nimž je kusovník k dispozici."
DocType: Sales Team,Incentives,Pobídky
apps/erpnext/erpnext/accounts/general_ledger.py,Values Out Of Sync,Hodnoty ze synchronizace
apps/erpnext/erpnext/stock/report/stock_and_account_value_comparison/stock_and_account_value_comparison.py,Difference Value,Hodnota rozdílu
DocType: SMS Log,Requested Numbers,Požadované Čísla
DocType: Volunteer,Evening,Večer
DocType: Quiz,Quiz Configuration,Konfigurace kvízu
DocType: Customer Credit Limit,Bypass credit limit check at Sales Order,Zablokujte kontrolu úvěrového limitu na objednávce
DocType: Vital Signs,Normal,Normální
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í &quot;použití pro nákupního košíku&quot;, jak je povoleno Nákupní košík a tam by měla být alespoň jedna daňová pravidla pro Košík"
DocType: Sales Invoice Item,Stock Details,Sklad Podrobnosti
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Value,Hodnota projektu
apps/erpnext/erpnext/config/help.py,Point-of-Sale,Místě prodeje
DocType: Fee Schedule,Fee Creation Status,Stav tvorby poplatků
apps/erpnext/erpnext/utilities/activation.py,Create Sales Orders to help you plan your work and deliver on-time,"Vytvořte prodejní objednávky, které vám pomohou naplánovat práci a doručit včas"
DocType: Vehicle Log,Odometer Reading,stav tachometru
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 na účtu již v Credit, není dovoleno stanovit ""Balance musí být"" jako ""debet"""
DocType: Account,Balance must be,Zůstatek musí být
,Available Qty,Množství k dispozici
DocType: Shopify Settings,Default Warehouse to to create Sales Order and Delivery Note,Výchozí skladiště pro vytvoření objednávky prodeje a doručení
DocType: Purchase Taxes and Charges,On Previous Row Total,Na předchozí řady Celkem
DocType: Purchase Invoice Item,Rejected Qty,zamítnuta Množství
DocType: Setup Progress Action,Action Field,Pole akce
DocType: Healthcare Settings,Manage Customer,Správa zákazníka
DocType: Amazon MWS Settings,Always synch your products from Amazon MWS before synching the Orders details,Vždy synchronizujte své produkty s Amazon MWS před synchronizací detailů objednávek
DocType: Delivery Trip,Delivery Stops,Doručování se zastaví
DocType: Salary Slip,Working Days,Pracovní dny
apps/erpnext/erpnext/accounts/deferred_revenue.py,Cannot change Service Stop Date for item in row {0},Nelze změnit datum ukončení služby pro položku v řádku {0}
DocType: Serial No,Incoming Rate,Příchozí Rate
DocType: Packing Slip,Gross Weight,Hrubá hmotnost
DocType: Leave Type,Encashment Threshold Days,Dny prahu inkasa
,Final Assessment Grades,Závěrečné hodnocení
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 nastavení tohoto systému."
DocType: HR Settings,Include holidays in Total no. of Working Days,Zahrnout dovolenou v celkovém. pracovních dní
apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py,Setup your Institute in ERPNext,Nastavte svůj institut v ERPNext
DocType: Agriculture Analysis Criteria,Plant Analysis,Analýza rostlin
DocType: Task,Timeline,Časová osa
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Hold,Držet
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Alternate Item,Alternativní položka
DocType: Shopify Log,Request Data,Žádost o údaje
DocType: Employee,Date of Joining,Datum přistoupení
DocType: Naming Series,Update Series,Řada Aktualizace
DocType: Supplier Quotation,Is Subcontracted,Subdodavatelům
DocType: Restaurant Table,Minimum Seating,Minimální počet sedadel
DocType: Item Attribute,Item Attribute Values,Položka Hodnoty atributů
DocType: Examination Result,Examination Result,vyšetření Výsledek
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Purchase Receipt,Příjemka
,Received Items To Be Billed,"Přijaté položek, které mají být účtovány"
apps/erpnext/erpnext/regional/doctype/import_supplier_invoice/import_supplier_invoice.py,Please set default UOM in Stock Settings,"Prosím, nastavte výchozí UOM v nastavení skladu"
DocType: Purchase Invoice,Accounting Dimensions,Účetní dimenze
,Subcontracted Raw Materials To Be Transferred,"Subdodavatelské suroviny, které mají být převedeny"
apps/erpnext/erpnext/config/accounts.py,Currency exchange rate master.,Devizový kurz master.
,Sales Person Target Variance Based On Item Group,Cílová odchylka prodejní osoby na základě skupiny položek
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Reference Doctype must be one of {0},Referenční Doctype musí být jedním z {0}
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 Celkový počet nula
DocType: Work Order,Plan material for sub-assemblies,Plán materiál pro podsestavy
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Please set filter based on Item or Warehouse due to a large amount of entries.,Nastavte filtr na základě položky nebo skladu z důvodu velkého počtu položek.
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} must be active,BOM {0} musí být aktivní
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,No Items available for transfer,K přenosu nejsou k dispozici žádné položky
DocType: Employee Boarding Activity,Activity Name,Název aktivity
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Change Release Date,Změnit datum vydání
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 produktu <b>{0}</b> a Pro množství <b>{1}</b> se nemohou lišit
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Closing (Opening + Total),Uzavření (otevření + celkem)
DocType: Delivery Settings,Dispatch Notification Attachment,Oznámení o odeslání
DocType: Payroll Entry,Number Of Employees,Počet zaměstnanců
DocType: Journal Entry,Depreciation Entry,odpisy Entry
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Please select the document type first,Vyberte první typ dokumentu
apps/erpnext/erpnext/stock/doctype/item/item.py,You have to enable auto re-order in Stock Settings to maintain re-order levels.,"Chcete-li zachovat úrovně opětovného objednání, musíte povolit automatickou změnu pořadí v Nastavení skladu."
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,Cancel Material Visits {0} before cancelling this Maintenance Visit,Zrušit Materiál Návštěvy {0} před zrušením tohoto návštěv údržby
DocType: Pricing Rule,Rate or Discount,Cena nebo sleva
apps/erpnext/erpnext/accounts/doctype/bank/bank_dashboard.py,Bank Details,Bankovní detaily
DocType: Vital Signs,One Sided,Jednostranné
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Item {1},Pořadové číslo {0} nepatří k bodu {1}
DocType: Purchase Order Item Supplied,Required Qty,Požadované množství
DocType: Marketplace Settings,Custom Data,Vlastní data
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to ledger.,Sklady se stávajícími transakce nelze převést na knihy.
DocType: Service Day,Service Day,Servisní den
apps/erpnext/erpnext/projects/doctype/project/project.py,Project Summary for {0},Shrnutí projektu pro {0}
apps/erpnext/erpnext/hub_node/api.py,Unable to update remote activity,Nelze aktualizovat vzdálenou aktivitu
DocType: Bank Reconciliation,Total Amount,Celková částka
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 různých fiskálních letech
apps/erpnext/erpnext/healthcare/utils.py,The Patient {0} do not have customer refrence to invoice,Pacient {0} nemá fakturu zákazníka
DocType: Quality Feedback Template,Quality Feedback Template,Šablona zpětné vazby kvality
apps/erpnext/erpnext/config/education.py,LMS Activity,Aktivita LMS
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Internet Publishing,Internet Publishing
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Creating {0} Invoice,Vytvoření faktury {0}
DocType: Medical Code,Medical Code Standard,Standardní zdravotnický kód
DocType: Soil Texture,Clay Composition (%),Složení jílů (%)
DocType: Item Group,Item Group Defaults,Výchozí nastavení položky položky
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Please save before assigning task.,Uložte prosím před přiřazením úkolu.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Balance Value,Zůstatek Hodnota
DocType: Lab Test,Lab Technician,Laboratorní technik
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,Sales Price List,Prodejní ceník
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, vytvoří se zákazník, mapovaný na pacienta. Faktury pacientů budou vytvořeny proti tomuto zákazníkovi. Při vytváření pacienta můžete také vybrat existujícího zákazníka."
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 loajálního programu
DocType: Bank Reconciliation,Account Currency,Měna účtu
DocType: Lab Test,Sample ID,ID vzorku
apps/erpnext/erpnext/accounts/general_ledger.py,Please mention Round Off Account in Company,"Prosím, uveďte zaokrouhlit účet v společnosti"
DocType: Purchase Receipt,Range,Rozsah
DocType: Supplier,Default Payable Accounts,Výchozí úplatu účty
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} is not active or does not exist,Zaměstnanec {0} není aktivní nebo neexistuje
DocType: Fee Structure,Components,Komponenty
DocType: Support Search Source,Search Term Param Name,Hledaný výraz Param Name
DocType: Item Barcode,Item Barcode,Položka Barcode
DocType: Delivery Trip,In Transit,V tranzitu
DocType: Woocommerce Settings,Endpoints,Koncové body
DocType: Shopping Cart Settings,Show Configure Button,Zobrazit tlačítko Konfigurovat
DocType: Quality Inspection Reading,Reading 6,Čtení 6
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Cannot {0} {1} {2} without any negative outstanding invoice,Nelze {0} {1} {2} bez negativních vynikající faktura
DocType: Share Transfer,From Folio No,Z folia č
DocType: Purchase Invoice Advance,Purchase Invoice Advance,Záloha přijaté faktury
DocType: Shift Type,Every Valid Check-in and Check-out,Každá platná check-in a check-out
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Credit entry can not be linked with a {1},Row {0}: Credit záznam nemůže být spojována s {1}
apps/erpnext/erpnext/config/accounts.py,Define budget for a financial year.,Definovat rozpočet pro finanční rok.
DocType: Shopify Tax Account,ERPNext Account,ERPN další účet
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.py,Provide the academic year and set the starting and ending date.,Uveďte akademický rok a stanovte počáteční a konečné datum.
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} is blocked so this transaction cannot proceed,"{0} je zablokována, aby tato transakce nemohla pokračovat"
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on MR,Akce při překročení akumulovaného měsíčního rozpočtu na MR
DocType: Employee,Permanent Address Is,Trvalé bydliště je
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Enter Supplier,Zadejte dodavatele
DocType: Work Order Operation,Operation completed for how many finished goods?,Provoz dokončeno kolika hotových výrobků?
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Healthcare Practitioner {0} not available on {1},Lékařský lékař {0} není dostupný v {1}
DocType: Payment Terms Template,Payment Terms Template,Šablona platebních podmínek
apps/erpnext/erpnext/public/js/setup_wizard.js,The Brand,Brand
DocType: Employee Tax Exemption Proof Submission,Rented To Date,Pronajato k datu
DocType: Manufacturing Settings,Allow Multiple Material Consumption,Povolte vícenásobnou spotřebu materiálu
DocType: Employee,Exit Interview Details,Exit Rozhovor Podrobnosti
DocType: Item,Is Purchase Item,je Nákupní Položka
DocType: Bank Statement Transaction Invoice Item,Purchase Invoice,Přijatá faktura
DocType: Manufacturing Settings,Allow multiple Material Consumption against a Work Order,Povolit vícenásobnou spotřebu materiálu proti pracovní zakázce
DocType: GL Entry,Voucher Detail No,Voucher Detail No
DocType: Email Digest,New Sales Invoice,Nová prodejní faktura
DocType: Stock Entry,Total Outgoing Value,Celková hodnota Odchozí
DocType: Healthcare Practitioner,Appointments,Setkání
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,Action Initialised,Inicializovaná akce
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date and Closing Date should be within same Fiscal Year,Datum zahájení a datem ukončení by mělo být v rámci stejného fiskální rok
DocType: Lead,Request for Information,Žádost o informace
DocType: Course Activity,Activity Date,Datum aktivity
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,{} of {},{} z {}
DocType: Sales Invoice Item,Rate With Margin (Company Currency),Sazba s marží (měna společnosti)
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Categories,Kategorie
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Offline Invoices,Sync Offline Faktury
DocType: Payment Request,Paid,Placený
DocType: Service Level,Default Priority,Výchozí priorita
DocType: Program Fee,Program Fee,Program Fee
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íku do všech ostatních kusovníků, kde se používá. Nahradí starý odkaz na kusovníku, aktualizuje cenu a obnoví tabulku &quot;BOM Výbušná položka&quot; podle nového kusovníku. Také aktualizuje poslední cenu ve všech kusovnících."
DocType: Employee Skill Map,Employee Skill Map,Mapa dovedností zaměstnanců
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: Salary Slip,Total in words,Celkem slovy
DocType: Inpatient Record,Discharged,Vypnuto
DocType: Material Request Item,Lead Time Date,Datum a čas Leadu
,Employee Advance Summary,Zaměstnanecké předběžné shrnutí
DocType: Asset,Available-for-use Date,Datum k dispozici
DocType: Guardian,Guardian Name,Jméno Guardian
DocType: Cheque Print Template,Has Print Format,Má formát tisku
DocType: Support Settings,Get Started Sections,Začínáme sekce
DocType: Lead,CRM-LEAD-.YYYY.-,CRM-LEAD-.YYYY.-
DocType: Invoice Discounting,Sanctioned,schválený
,Base Amount,Základní částka
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js,Total Contribution Amount: {0},Celková částka příspěvku: {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Zadejte Pořadové číslo k bodu {1}
DocType: Payroll Entry,Salary Slips Submitted,Příspěvky na plat
DocType: Crop Cycle,Crop Cycle,Crop Cycle
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.","Pro &quot;produktem Bundle předměty, sklad, sériové číslo a dávkové No bude považována ze&quot; Balení seznam &#39;tabulky. Pokud Warehouse a Batch No jsou stejné pro všechny balení položky pro jakoukoli &quot;Výrobek balík&quot; položky, tyto hodnoty mohou být zapsány do hlavní tabulky položky, budou hodnoty zkopírovány do &quot;Balení seznam&quot; tabulku."
DocType: Amazon MWS Settings,BR,BR
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Place,Z místa
DocType: Student Admission,Publish on website,Publikovat na webových stránkách
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice Date cannot be greater than Posting Date,Dodavatel Datum faktury nemůže být větší než Datum zveřejnění
DocType: Installation Note,MAT-INS-.YYYY.-,MAT-INS-.YYYY.-
DocType: Subscription,Cancelation Date,Datum zrušení
DocType: Purchase Invoice Item,Purchase Order Item,Položka vydané objednávky
DocType: Agriculture Task,Agriculture Task,Zemědělské úkoly
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Indirect Income,Nepřímé příjmy
DocType: Student Attendance Tool,Student Attendance Tool,Student Účast Tool
DocType: Restaurant Menu,Price List (Auto created),Ceník (vytvořeno automaticky)
DocType: Pick List Item,Picked Qty,Vybráno Množství
DocType: Cheque Print Template,Date Settings,Datum Nastavení
apps/erpnext/erpnext/education/doctype/question/question.py,A question must have more than one options,Otázka musí mít více než jednu možnost
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Variance,Odchylka
DocType: Employee Promotion,Employee Promotion Detail,Podrobnosti o podpoře zaměstnanců
DocType: Delivery Trip,Driver Email,E-mail řidiče
DocType: SMS Center,Total Message(s),Celkem zpráv (y)
DocType: Share Balance,Purchased,Zakoupeno
DocType: Item Variant Settings,Rename Attribute Value in Item Attribute.,Přejmenujte hodnotu atributu v atributu položky.
DocType: Purchase Invoice,Additional Discount Percentage,Další slevy Procento
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,View a list of all the help videos,Zobrazit seznam všech nápovědy videí
DocType: Agriculture Analysis Criteria,Soil Texture,Půdní textury
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,"Vyberte účet šéf banky, kde byla uložena kontrola."
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Povolit uživateli upravovat Ceník Cena při transakcích
DocType: Pricing Rule,Max Qty,Max Množství
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js,Print Report Card,Tiskněte kartu přehledů
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á, to by mohlo být zrušeno / neexistuje. \ Zadejte platnou fakturu"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Row {0}: Platba na prodejní / nákupní objednávce by měly být vždy označeny jako předem
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Chemical,Chemický
DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Výchozí banka / Peněžní účet budou automaticky aktualizovány v plat položka deníku je-li zvolen tento režim.
DocType: Quiz,Latest Attempt,Poslední pokus
DocType: Quiz Result,Quiz Result,Výsledek testu
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/controllers/sales_and_purchase_return.py,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Řádek # {0}: Míra nemůže být větší než rychlost použitá v {1} {2}
DocType: Workstation,Electricity Cost,Cena elektřiny
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab testing datetime cannot be before collection datetime,Laboratoř data testování nemůže být před datem sběru
DocType: Subscription Plan,Cost,Náklady
DocType: HR Settings,Don't send Employee Birthday Reminders,Neposílejte zaměstnance připomenutí narozenin
DocType: Expense Claim,Total Advance Amount,Celková výše zálohy
DocType: Delivery Stop,Estimated Arrival,odhadovaný příjezd
apps/erpnext/erpnext/templates/pages/help.html,See All Articles,Zobrazit všechny články
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Walk In,Vejít
DocType: Item,Inspection Criteria,Inspekční Kritéria
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Transfered,Převedené
DocType: BOM Website Item,BOM Website Item,BOM Website Item
apps/erpnext/erpnext/public/js/setup_wizard.js,Upload your letter head and logo. (you can edit them later).,Nahrajte svůj dopis hlavu a logo. (Můžete je upravit později).
DocType: Timesheet Detail,Bill,Účet
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,White,Bílá
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid Company for Inter Company Transaction.,Neplatná společnost pro mezipodnikovou transakci.
DocType: SMS Center,All Lead (Open),Všechny Lead (Otevřeny)
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íček můžete vybrat pouze jednu možnost.
DocType: Purchase Invoice,Get Advances Paid,Získejte zaplacené zálohy
DocType: Item,Automatically Create New Batch,Automaticky vytvořit novou dávku
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žek a prodejních objednávek. Tento uživatel by měl mít příslušná oprávnění."
DocType: Asset Category,Enable Capital Work in Progress Accounting,Povolit kapitálové práce v účetnictví
DocType: POS Field,POS Field,Pole POS
DocType: Supplier,Represents Company,Zastupuje společnost
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Make ,Dělat
DocType: Student Admission,Admission Start Date,Vstupné Datum zahájení
DocType: Journal Entry,Total Amount in Words,Celková částka slovy
apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js,New Employee,Nový zaměstnanec
DocType: Lead,Next Contact Date,Další Kontakt Datum
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Opening Qty,Otevření POČET
DocType: Healthcare Settings,Appointment Reminder,Připomenutí pro jmenování
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please enter Account for Change Amount,"Prosím, zadejte účet pro změnu Částka"
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,For operation {0}: Quantity ({1}) can not be greter than pending quantity({2}),Pro operaci {0}: Množství ({1}) nemůže být větší než čekající množství ({2})
DocType: Program Enrollment Tool Student,Student Batch Name,Student Batch Name
DocType: Holiday List,Holiday List Name,Název seznamu dovolené
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Import položek a UOM
DocType: Repayment Schedule,Balance Loan Amount,Balance Výše úvěru
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Přidáno do podrobností
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Litujeme, kód kupónu je vyčerpán"
DocType: Communication Medium,Catch All,Chytit vše
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,rozvrh
DocType: Budget,Applicable on Material Request,Použitelné na žádosti o materiál
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Stock Options,Akciové opce
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,No Items added to cart,Do košíku nejsou přidány žádné položky
DocType: Journal Entry Account,Expense Claim,Hrazení nákladů
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Do you really want to restore this scrapped asset?,Opravdu chcete obnovit tento vyřazen aktivum?
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Qty for {0},Množství pro {0}
DocType: Attendance,Leave Application,Požadavek na absenci
DocType: Patient,Patient Relation,Vztah pacienta
DocType: Item,Hub Category to Publish,Kategorie Hubu k publikování
DocType: Leave Block List,Leave Block List Dates,Nechte Block List termíny
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}, můžete pouze rezervovat {1} proti {0}. Sériové číslo {2} nelze dodat"
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Item {0}: {1} qty produced. ,Položka {0}: {1} vyrobeno množství.
DocType: Sales Invoice,Billing Address GSTIN,Fakturační adresa GSTIN
DocType: Homepage,Hero Section Based On,Hero Section Na základě
DocType: Employee Tax Exemption Proof Submission,Total Eligible HRA Exemption,Celkový přípustný výjimek pro HRA
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! A GSTIN must have 15 characters.,Neplatný GSTIN! GSTIN musí mít 15 znaků.
DocType: Assessment Plan,Evaluate,Vyhodnoťte
DocType: Workstation,Net Hour Rate,Net Hour Rate
DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Přistál Náklady doklad o koupi
DocType: Supplier Scorecard Period,Criteria,Kritéria
DocType: Packing Slip Item,Packing Slip Item,Položka balícího listu
DocType: Purchase Invoice,Cash/Bank Account,Hotovostní / Bankovní účet
DocType: Travel Itinerary,Train,Vlak
,Delayed Item Report,Zpráva o zpoždění položky
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Eligible ITC,Způsobilé ITC
DocType: Healthcare Service Unit,Inpatient Occupancy,Lůžková obsazenost
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,Publish Your First Items,Zveřejněte své první položky
DocType: Sample Collection,HLC-SC-.YYYY.-,HLC-SC-.YYYY.-
DocType: Shift Type,Time after the end of shift during which check-out is considered for attendance.,"Čas po skončení směny, během kterého je check-out považován za účast."
apps/erpnext/erpnext/public/js/queries.js,Please specify a {0},Zadejte {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Removed items with no change in quantity or value.,Odstraněné položky bez změny množství nebo hodnoty.
DocType: Delivery Note,Delivery To,Doručení do
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant creation has been queued.,Tvorba variantu byla zařazena do fronty.
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,Work Summary for {0},Souhrn práce pro {0}
DocType: Department,The first Leave Approver in the list will be set as the default Leave Approver.,Prvním schvalovacím přístupem v seznamu bude nastaven výchozí přístup.
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute table is mandatory,Atribut tabulka je povinné
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Delayed Days,Zpožděné dny
DocType: Production Plan,Get Sales Orders,Získat Prodejní objednávky
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} can not be negative,{0} nemůže být negativní
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Connect to Quickbooks,Připojte k Quickbookům
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Clear values,Vymazat hodnoty
DocType: Training Event,Self-Study,Samostudium
DocType: POS Closing Voucher,Period End Date,Datum konce období
apps/erpnext/erpnext/regional/india/utils.py,Transport Receipt No and Date are mandatory for your chosen Mode of Transport,Číslo a datum dopravy jsou pro zvolený druh dopravy povinné
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py,Soil compositions do not add up to 100,Půdní kompozice nedosahují 100
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Discount,Sleva
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í pro vytvoření faktur otevření {2}
DocType: Membership,Membership,Členství
DocType: Asset,Total Number of Depreciations,Celkový počet Odpisy
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Debit A/C Number,Číslo debetní platby
DocType: Sales Invoice Item,Rate With Margin,Míra s marží
DocType: Purchase Invoice,Is Return (Debit Note),Je Return (Debit Note)
DocType: Workstation,Wages,Mzdy
DocType: Asset Maintenance,Maintenance Manager Name,Název správce údržby
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í!
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requesting Site,Žádající web
DocType: Agriculture Task,Urgent,Naléhavý
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Fetching records......,Načítání záznamů ......
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please specify a valid Row ID for row {0} in table {1},Zadejte prosím platný řádek ID řádku tabulky {0} {1}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py,Unable to find variable: ,Nelze najít proměnnou:
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select a field to edit from numpad,"Vyberte pole, které chcete upravit z čísla"
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot be a fixed asset item as Stock Ledger is created.,"Nemůže být položka fixního aktiva, protože je vytvořena účetní kniha akcií."
DocType: Subscription Plan,Fixed rate,Fixní sazba
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.js,Admit,Připustit
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čít používat ERPNext
apps/erpnext/erpnext/templates/pages/order.js,Pay Remaining,Zbývající platba
DocType: Purchase Invoice Item,Manufacturer,Výrobce
DocType: Landed Cost Item,Purchase Receipt Item,Položka příjemky
DocType: Leave Allocation,Total Leaves Encashed,Celkový počet listů zapuštěných
DocType: POS Profile,Sales Invoice Payment,Prodejní faktury Platba
DocType: Quality Inspection Template,Quality Inspection Template Name,Jméno šablony inspekce kvality
DocType: Project,First Email,První e-mail
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Relieving Date must be greater than or equal to Date of Joining,Datum vydání musí být větší nebo rovno Datum připojení
DocType: Company,Exception Budget Approver Role,Role přístupu k výjimce rozpočtu
DocType: Purchase Invoice,"Once set, this invoice will be on hold till the set date","Jakmile bude tato faktura zadána, bude tato faktura podržena až do stanoveného data"
DocType: Cashier Closing,POS-CLO-,POS-CLO-
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Selling Amount,Prodejní Částka
DocType: Repayment Schedule,Interest Amount,Zájem Částka
DocType: Job Card,Time Logs,Čas Záznamy
DocType: Sales Invoice,Loyalty Amount,Loajální částka
DocType: Employee Transfer,Employee Transfer Detail,Detail pracovníka
DocType: Serial No,Creation Document No,Tvorba dokument č
DocType: Manufacturing Settings,Other Settings,další nastavení
DocType: Location,Location Details,Podrobnosti o poloze
DocType: Share Transfer,Issue,Problém
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter_dashboard.py,Records,Evidence
DocType: Asset,Scrapped,sešrotován
DocType: Appointment Booking Settings,Agents,Agenti
DocType: Item,Item Defaults,Položka Výchozí
DocType: Cashier Closing,Returns,výnos
DocType: Job Card,WIP Warehouse,WIP Warehouse
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} is under maintenance contract upto {1},Pořadové číslo {0} je na základě smlouvy o údržbě aľ {1}
apps/erpnext/erpnext/config/hr.py,Recruitment,Nábor
DocType: Lead,Organization Name,Název organizace
DocType: Support Settings,Show Latest Forum Posts,Zobrazit nejnovější příspěvky ve fóru
DocType: Tax Rule,Shipping State,Přepravní State
,Projected Quantity as Source,Množství projekcí as Zdroj
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""položka získaná z dodacího listu"""
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Delivery Trip,Výlet za doručení
DocType: Student,A-,A-
DocType: Share Transfer,Transfer Type,Typ přenosu
DocType: Pricing Rule,Quantity and Amount,Množství a částka
DocType: Appointment Booking Settings,Success Redirect URL,Adresa URL přesměrování úspěchu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Sales Expenses,Prodejní náklady
DocType: Diagnosis,Diagnosis,Diagnóza
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Buying,Standardní Nakupování
DocType: Attendance Request,Explanation,Vysvětlení
DocType: GL Entry,Against,Proti
DocType: Item Default,Sales Defaults,Výchozí hodnoty prodeje
DocType: Sales Order Item,Work Order Qty,Počet pracovních objednávek
DocType: Item Default,Default Selling Cost Center,Výchozí Center Prodejní cena
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Disc,Disk
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Target Location or To Employee is required while receiving Asset {0},Cílová lokalita nebo pro zaměstnance jsou vyžadovány při přijímání aktiv {0}
DocType: Buying Settings,Material Transferred for Subcontract,Materiál převedený na subdodávky
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Date,Datum objednávky
DocType: Email Digest,Purchase Orders Items Overdue,Položky nákupních příkazů po splatnosti
apps/erpnext/erpnext/accounts/page/pos/pos.js,ZIP Code,PSČ
apps/erpnext/erpnext/controllers/selling_controller.py,Sales Order {0} is {1},Prodejní objednávky {0} {1}
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Select interest income account in loan {0},Vyberte účet úrokového výnosu v úvěru {0}
DocType: Opportunity,Contact Info,Kontaktní informace
apps/erpnext/erpnext/config/help.py,Making Stock Entries,Tvorba přírůstků zásob
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Cannot promote Employee with status Left,Zaměstnanec se stavem vlevo nelze podpořit
DocType: Packing Slip,Net Weight UOM,Hmotnost UOM
DocType: Item Default,Default Supplier,Výchozí Dodavatel
DocType: Loan,Repayment Schedule,splátkový kalendář
DocType: Shipping Rule Condition,Shipping Rule Condition,Přepravní Pravidlo Podmínka
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ž data zahájení
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
DocType: Company,Date of Commencement,Datum začátku
DocType: Sales Person,Select company name first.,Vyberte název společnosti jako první.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Email sent to {0},Email odeslán (komu) {0}
apps/erpnext/erpnext/config/buying.py,Quotations received from Suppliers.,Nabídka obdržená od Dodavatelů.
DocType: Quality Goal,January-April-July-October,Leden-duben-červenec-říjen
apps/erpnext/erpnext/config/manufacturing.py,Replace BOM and update latest price in all BOMs,Nahraďte kusovníku a aktualizujte nejnovější cenu ve všech kusovnících
apps/erpnext/erpnext/controllers/selling_controller.py,To {0} | {1} {2},Chcete-li {0} | {1} {2}
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js,This is a root supplier group and cannot be edited.,Toto je kořenová skupina dodavatelů a nemůže být editována.
DocType: Sales Invoice,Driver Name,Jméno řidiče
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Average Age,Průměrný věk
DocType: Education Settings,Attendance Freeze Date,Datum ukončení účasti
DocType: Payment Request,Inward,Vnitřní
DocType: Accounting Dimension,Dimension Defaults,Výchozí hodnoty dimenze
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Minimum Lead Age (Days),Minimální doba plnění (dny)
apps/erpnext/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py,Available For Use Date,K dispozici pro datum použití
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,All BOMs,Všechny kusovníky
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Create Inter Company Journal Entry,Vytvořte položku inter firemního deníku
DocType: Company,Parent Company,Mateřská společnost
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Hotel Rooms of type {0} are unavailable on {1},Hotel Pokoje typu {0} nejsou k dispozici v {1}
apps/erpnext/erpnext/config/manufacturing.py,Compare BOMs for changes in Raw Materials and Operations,Porovnejte kusovníky pro změny surovin a operací
apps/erpnext/erpnext/accounts/doctype/bank_transaction/bank_transaction.js,Document {0} successfully uncleared,Dokument {0} byl úspěšně nejasný
DocType: Healthcare Practitioner,Default Currency,Výchozí měna
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Reconcile this account,Odsouhlaste tento účet
apps/erpnext/erpnext/controllers/selling_controller.py,Maximum discount for Item {0} is {1}%,Maximální sleva pro položku {0} je {1}%
DocType: Chart of Accounts Importer,Attach custom Chart of Accounts file,Připojte vlastní soubor účtových účtů
DocType: Asset Movement Item,From Employee,Od Zaměstnance
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of services,Dovoz služeb
DocType: Driver,Cellphone Number,Mobilní číslo
DocType: Project,Monitor Progress,Monitorování pokroku
DocType: Pricing Rule Item Code,Pricing Rule Item Code,Kód položky pravidla pravidla
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 nebude kontrolovat nadfakturace, protože částka za položku na {1} je nula {0}"
DocType: Journal Entry,Make Difference Entry,Učinit vstup Rozdíl
DocType: Supplier Quotation,Auto Repeat Section,Sekce automatického opakování
DocType: Service Level Priority,Response Time,Doba odezvy
DocType: Upload Attendance,Attendance From Date,Účast Datum od
DocType: Appraisal Template Goal,Key Performance Area,Key Performance Area
DocType: Program Enrollment,Transportation,Doprava
apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Neplatný Atribut
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} musí být odeslaný
apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,E-mailové kampaně
DocType: Sales Partner,To Track inbound purchase,Chcete-li sledovat příchozí nákup
DocType: Buying Settings,Default Supplier Group,Výchozí skupina dodavatelů
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Množství musí být menší než nebo rovno {0}
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 {1}
DocType: Department Approver,Department Approver,Schválení oddělení
DocType: QuickBooks Migrator,Application Settings,Nastavení aplikace
DocType: SMS Center,Total Characters,Celkový počet znaků
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Creating Company and Importing Chart of Accounts,Vytváření firemních a importních účtů
DocType: Employee Advance,Claimed,Reklamace
DocType: Crop,Row Spacing,Rozteč řádků
apps/erpnext/erpnext/controllers/buying_controller.py,Please select BOM in BOM field for Item {0},Vyberte kusovník Bom oblasti k bodu {0}
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,There isn't any item variant for the selected item,Pro zvolenou položku není k dispozici žádná varianta položky
DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Form Faktura Detail
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Platba Odsouhlasení faktury
DocType: Clinical Procedure,Procedure Template,Šablona postupu
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Publish Items,Publikovat položky
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution %,Příspěvek%
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 je objednávka požadována == &#39;ANO&#39;, pak pro vytvoření nákupní faktury musí uživatel nejprve vytvořit nákupní objednávku pro položku {0}"
,HSN-wise-summary of outward supplies,HSN - shrnutí vnějších dodávek
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Registrace firmy čísla pro váš odkaz. Daňové čísla atd
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To State,Do stavu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Distributor,Distributor
DocType: Asset Finance Book,Asset Finance Book,Finanční kniha majetku
DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Nákupní košík Shipping Rule
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.py,Please setup a default bank account for company {0},Nastavte prosím výchozí bankovní účet společnosti {0}
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set 'Apply Additional Discount On',Prosím nastavte na &quot;Použít dodatečnou slevu On&quot;
DocType: Party Tax Withholding Config,Applicable Percent,Použitelné procento
,Ordered Items To Be Billed,Objednané zboží fakturovaných
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,From Range has to be less than To Range,"Z rozsahu, musí být nižší než na Range"
DocType: Global Defaults,Global Defaults,Globální Výchozí
apps/erpnext/erpnext/projects/doctype/project/project.py,Project Collaboration Invitation,Projekt spolupráce Pozvánka
DocType: Salary Slip,Deductions,Odpočty
DocType: Setup Progress Action,Action Name,Název akce
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Start Year,Začátek Rok
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.js,Create Loan,Vytvořit půjčku
DocType: Purchase Invoice,Start date of current invoice's period,Datum období současného faktury je Začátek
DocType: Shift Type,Process Attendance After,Procesní účast po
,IRS 1099,IRS 1099
DocType: Salary Slip,Leave Without Pay,Volno bez nároku na mzdu
DocType: Payment Request,Outward,Vnější
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On {0} Creation,Na {0} stvoření
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,State/UT Tax,Daň státu / UT
,Trial Balance for Party,Trial váhy pro stranu
,Gross and Net Profit Report,Hrubý a čistý zisk
apps/erpnext/erpnext/config/quality_management.py,Tree of Procedures,Strom procedur
DocType: Lead,Consultant,Konzultant
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Parents Teacher Meeting Attendance,Konference účastníků rodičů
DocType: Salary Slip,Earnings,Výdělek
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Finished Item {0} must be entered for Manufacture type entry,Dokončeno Položka {0} musí být zadán pro vstup typu Výroba
apps/erpnext/erpnext/config/help.py,Opening Accounting Balance,Otevření účetnictví Balance
,GST Sales Register,Obchodní registr GST
DocType: Sales Invoice Advance,Sales Invoice Advance,Prodejní faktury Advance
apps/erpnext/erpnext/public/js/setup_wizard.js,Select your Domains,Vyberte své domény
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/sync_product.py,Shopify Supplier,Nakupujte dodavatele
DocType: Bank Statement Transaction Entry,Payment Invoice Items,Položky platební faktury
DocType: Payroll Entry,Employee Details,Podrobnosti o zaměstnanci
apps/erpnext/erpnext/regional/doctype/import_supplier_invoice/import_supplier_invoice.py,Processing XML Files,Zpracování souborů XML
DocType: Amazon MWS Settings,CN,CN
DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Pole budou kopírovány pouze v době vytváření.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Management,Řízení
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.js,Show {0},Zobrazit {0}
DocType: Cheque Print Template,Payer Settings,Nastavení plátce
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,No pending Material Requests found to link for the given items.,Žádná nevyřízená žádost o materiál nebyla nalezena k odkazu na dané položky.
apps/erpnext/erpnext/public/js/utils/party.js,Select company first,Nejprve vyberte společnost
apps/erpnext/erpnext/accounts/general_ledger.py,Account: <b>{0}</b> is capital Work in progress and can not be updated by Journal Entry,Účet: <b>{0}</b> je kapitál Probíhá zpracování a nelze jej aktualizovat zápisem do deníku
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Compare List function takes on list arguments,Funkce Porovnání seznamu přebírá argumenty seznamu
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řipojen na položku zákoníku varianty. Například, pokud vaše zkratka je ""SM"", a položka je kód ""T-SHIRT"", položka kód varianty bude ""T-SHIRT-SM"""
DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,"Čistá Pay (slovy) budou viditelné, jakmile uložíte výplatní pásce."
DocType: Delivery Note,Is Return,Je Return
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Caution,Pozor
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Import Successful,Import byl úspěšný
apps/erpnext/erpnext/config/quality_management.py,Goal and Procedure,Cíl a postup
apps/erpnext/erpnext/agriculture/doctype/disease/disease.py,Start day is greater than end day in task '{0}',Den začátku je větší než koncový den v úloze &#39;{0}&#39;
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Return / Debit Note,Return / vrubopis
DocType: Price List Country,Price List Country,Ceník Země
DocType: Production Plan,"To know more about projected quantity, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">click here</a>.","Chcete-li se dozvědět více o plánovaném množství, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">klikněte sem</a> ."
DocType: Sales Invoice,Set Source Warehouse,Nastavit zdrojový sklad
DocType: Tally Migration,UOMs,UOMs
DocType: Account Subtype,Account Subtype,Podtyp účtu
apps/erpnext/erpnext/stock/utils.py,{0} valid serial nos for Item {1},{0} platí pořadová čísla pro položky {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item Code cannot be changed for Serial No.,Kód položky nemůže být změněn pro Serial No.
DocType: Purchase Invoice Item,UOM Conversion Factor,UOM Conversion Factor
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js,Please enter Item Code to get Batch Number,"Prosím, zadejte kód položky se dostat číslo šarže"
DocType: Loyalty Point Entry,Loyalty Point Entry,Zadání věrnostního bodu
DocType: Employee Checkin,Shift End,Shift End
DocType: Stock Settings,Default Item Group,Výchozí bod Group
DocType: Job Card Time Log,Time In Mins,Čas v min
apps/erpnext/erpnext/config/non_profit.py,Grant information.,Poskytněte informace.
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.js,This action will unlink this account from any external service integrating ERPNext with your bank accounts. It cannot be undone. Are you certain ?,Tato akce odpojí tento účet od jakékoli externí služby integrující ERPNext s vašimi bankovními účty. Nelze jej vrátit zpět. Jsi si jistý ?
apps/erpnext/erpnext/config/accounts.py,Supplier database.,Databáze dodavatelů.
DocType: Contract Template,Contract Terms and Conditions,Smluvní podmínky
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,You cannot restart a Subscription that is not cancelled.,"Nelze znovu spustit odběr, který není zrušen."
DocType: Account,Balance Sheet,Rozvaha
DocType: Leave Type,Is Earned Leave,Získaná dovolená
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount,Částka objednávky
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Cost Center For Item with Item Code ',"Nákladové středisko u položky s Kód položky """
DocType: Fee Validity,Valid Till,Platný do
DocType: Student Report Generation Tool,Total Parents Teacher Meeting,Celkové setkání učitelů rodičů
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 platba není nakonfigurován. Prosím zkontrolujte, zda je účet byl nastaven na režim plateb nebo na POS Profilu."
apps/erpnext/erpnext/buying/utils.py,Same item cannot be entered multiple times.,Stejnou položku nelze zadat vícekrát.
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 vyrobeny v rámci skupiny, ale údaje lze proti non-skupin"
DocType: Call Log,Lead,Lead
DocType: Email Digest,Payables,Závazky
DocType: Amazon MWS Settings,MWS Auth Token,MWS Auth Token
DocType: Email Campaign,Email Campaign For ,E-mailová kampaň pro
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Entry {0} created,Skladovou pohyb {0} vytvořil
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,You don't have enought Loyalty Points to redeem,Nemáte dostatečné věrnostní body k uplatnění
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 přidružený účet v kategorii odmítnutí daní {0} proti společnosti {1}
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Qty can not be entered in Purchase Return,Řádek # {0}: Zamítnutí Množství nemůže být zapsán do kupní Návrat
apps/erpnext/erpnext/stock/doctype/item/item.js,Changing Customer Group for the selected Customer is not allowed.,Změna skupiny zákazníků pro vybraného zákazníka není povolena.
,Purchase Order Items To Be Billed,Položky vydané objednávky k fakturaci
apps/erpnext/erpnext/controllers/buying_controller.py,Row {1}: Asset Naming Series is mandatory for the auto creation for item {0},Řádek {1}: Pojmenování majetku je povinné pro automatické vytváření položky {0}
DocType: Program Enrollment Tool,Enrollment Details,Podrobnosti o zápisu
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot set multiple Item Defaults for a company.,Nelze nastavit více položek Výchozí pro společnost.
DocType: Customer Group,Credit Limits,Úvěrové limity
DocType: Purchase Invoice Item,Net Rate,Čistá míra
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select a customer,Vyberte zákazníka
DocType: Leave Policy,Leave Allocations,Ponechat alokace
DocType: Job Card,Started Time,Čas zahájení
DocType: Purchase Invoice Item,Purchase Invoice Item,Položka přijaté faktury
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,Sériové Ledger Přihlášky a GL položky jsou zveřejňována pro vybrané Nákupní Příjmy
DocType: Student Report Generation Tool,Assessment Terms,Podmínky hodnocení
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 1,Položka 1
DocType: Holiday,Holiday,Dovolená
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Leave Type is madatory,Typ dovolené je špatný
DocType: Support Settings,Close Issue After Days,V blízkosti Issue po několika dnech
,Eway Bill,Eway Bill
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.,Musíte být uživateli s rolí Správce systému a Správce položek pro přidání uživatelů do služby Marketplace.
DocType: Attendance,Early Exit,Předčasný odchod
DocType: Job Opening,Staffing Plan,Zaměstnanecký plán
apps/erpnext/erpnext/accounts/doctype/sales_invoice/regional/india_list.js,e-Way Bill JSON can only be generated from a submitted document,Účet E-Way Bill JSON lze vygenerovat pouze z předloženého dokumentu
apps/erpnext/erpnext/config/hr.py,Employee Tax and Benefits,Daň a dávky zaměstnanců
DocType: Bank Guarantee,Validity in Days,Platnost ve dnech
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,C-form is not applicable for Invoice: {0},C-forma se nevztahuje na faktuře: {0}
DocType: Certified Consultant,Name of Consultant,Jméno konzultanta
DocType: Payment Reconciliation,Unreconciled Payment Details,Smířit platbě
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Member Activity,Členská aktivita
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Count,Pořadí objednávek
DocType: Global Defaults,Current Fiscal Year,Aktuální fiskální rok
DocType: Purchase Invoice,Group same items,Skupina stejné položky
DocType: Purchase Invoice,Disable Rounded Total,Zakázat Zaoblený Celkem
DocType: Marketplace Settings,Sync in Progress,Synchronizace probíhá
DocType: Department,Parent Department,Oddělení rodičů
DocType: Loan Application,Repayment Info,splácení Info
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,'Entries' cannot be empty,"""Záznamy"" nemohou být prázdné"
DocType: Maintenance Team Member,Maintenance Role,Úloha údržby
apps/erpnext/erpnext/utilities/transaction_base.py,Duplicate row {0} with same {1},Duplicitní řádek {0} se stejným {1}
DocType: Marketplace Settings,Disable Marketplace,Zakázat tržiště
DocType: Quality Meeting,Minutes,Minut
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Your Featured Items,Vaše doporučené položky
,Trial Balance,Trial Balance
apps/erpnext/erpnext/templates/pages/projects.js,Show Completed,Zobrazit dokončeno
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Fiscal Year {0} not found,Fiskální rok {0} nebyl nalezen
apps/erpnext/erpnext/config/help.py,Setting up Employees,Nastavení Zaměstnanci
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Proveďte zadávání zásob
DocType: Hotel Room Reservation,Hotel Reservation User,Uživatel rezervace ubytování
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Nastavit stav
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,"Prosím, vyberte první prefix"
DocType: Contract,Fulfilment Deadline,Termín splnění
apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Ve vašem okolí
DocType: Student,O-,Ó-
DocType: Subscription Settings,Subscription Settings,Nastavení předplatného
DocType: Purchase Invoice,Update Auto Repeat Reference,Aktualizovat referenci automatického opakování
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Optional Holiday List not set for leave period {0},Volitelný prázdninový seznam není nastaven na období dovolené {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Research,Výzkum
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 2,Na adresu 2
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0}: From time must be less than to time,Řádek {0}: Čas od času musí být kratší než čas
DocType: Maintenance Visit Purpose,Work Done,Odvedenou práci
apps/erpnext/erpnext/controllers/item_variant.py,Please specify at least one attribute in the Attributes table,Uveďte prosím alespoň jeden atribut v tabulce atributy
DocType: Announcement,All Students,Všichni studenti
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} must be a non-stock item,Item {0} musí být non-skladová položka
apps/erpnext/erpnext/stock/doctype/batch/batch.js,View Ledger,View Ledger
DocType: Cost Center,Lft,LFT
DocType: Grading Scale,Intervals,intervaly
DocType: Bank Statement Transaction Entry,Reconciled Transactions,Zkombinované transakce
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Earliest,Nejstarší
DocType: Crop Cycle,Linked Location,Linked Location
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 již existuje. Prosím, změňte název položky nebo přejmenujte skupinu položek"
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invocies,Získejte faktury
DocType: Designation,Skills,Dovednosti
DocType: Crop Cycle,Less than a year,Méně než rok
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Student Mobile No.,Student Mobile No.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Rest Of The World,Zbytek světa
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
DocType: Crop,Yield UOM,Výnos UOM
,Budget Variance Report,Rozpočet Odchylka Report
DocType: Salary Slip,Gross Pay,Hrubé mzdy
DocType: Item,Is Item from Hub,Je položka z Hubu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Get Items from Healthcare Services,Získejte položky od zdravotnických služeb
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Finished Qty,Dokončeno Množství
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: Activity Type is mandatory.,Řádek {0}: typ činnosti je povinná.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Dividends Paid,Dividendy placené
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Accounting Ledger,Účetní Statistika
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Difference Amount,Rozdíl Částka
DocType: Purchase Invoice,Reverse Charge,Zpětné nabíjení
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Retained Earnings,Nerozdělený zisk
DocType: Job Card,Timing Detail,Časový detail
DocType: Purchase Invoice,05-Change in POS,05 - Změna POS
DocType: Vehicle Log,Service Detail,servis Detail
DocType: BOM,Item Description,Položka Popis
DocType: Student Sibling,Student Sibling,Student Sourozenec
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py,Payment Mode,Způsob platby
DocType: Purchase Invoice,Supplied Items,Dodávané položky
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please set an active menu for Restaurant {0},Nastavte prosím aktivní nabídku Restaurant {0}
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Commission Rate %,Míra Komise%
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Qty To Manufacture,Množství K výrobě
DocType: Email Digest,New Income,New příjmů
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Open Lead,Otevřete vedoucí
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Udržovat stejnou sazbu po celou kupní cyklu
DocType: Opportunity Item,Opportunity Item,Položka Příležitosti
DocType: Quality Action,Quality Review,Kontrola kvality
,Student and Guardian Contact Details,Student a Guardian Kontaktní údaje
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge Account,Sloučit účet
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 dodavatele je zapotřebí {0} E-mailová adresa pro odeslání e-mailu
DocType: Shift Type,Attendance will be marked automatically only after this date.,Účast bude automaticky označena až po tomto datu.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Opening,Dočasné Otevření
,Employee Leave Balance,Zaměstnanec Leave Balance
apps/erpnext/erpnext/quality_management/doctype/quality_procedure/quality_procedure_tree.js,New Quality Procedure,Nový postup kvality
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Balance for Account {0} must always be {1},Zůstatek na účtě {0} musí být vždy {1}
DocType: Patient Appointment,More Info,Více informací
DocType: Supplier Scorecard,Scorecard Actions,Akční body Scorecard
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,Supplier {0} not found in {1},Dodavatel {0} nebyl nalezen v {1}
DocType: Purchase Invoice,Rejected Warehouse,Zamítnuto Warehouse
DocType: GL Entry,Against Voucher,Proti poukazu
DocType: Item Default,Default Buying Cost Center,Výchozí středisko nákupu
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Payment,Nová platba
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ískat to nejlepší z ERPNext, doporučujeme vám nějaký čas trvat, a sledovat tyto nápovědy videa."
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,For Default Supplier (optional),Výchozí dodavatel (volitelné)
DocType: Supplier Quotation Item,Lead Time in days,Čas leadu ve dnech
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/accounts/report/accounts_payable/accounts_payable.js,Accounts Payable Summary,Splatné účty Shrnutí
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Not authorized to edit frozen Account {0},Není povoleno upravovat zmrazený účet {0}
apps/erpnext/erpnext/accounts/general_ledger.py,Stock Value ({0}) and Account Balance ({1}) are out of sync for account {2} and it's linked warehouses.,Hodnota akcií ({0}) a zůstatek na účtu ({1}) nejsou synchronizovány pro účet {2} a je to propojené sklady.
DocType: Journal Entry,Get Outstanding Invoices,Získat neuhrazených faktur
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Sales Order {0} is not valid,Prodejní objednávky {0} není platný
DocType: Supplier Scorecard,Warn for new Request for Quotations,Upozornit na novou žádost o nabídky
apps/erpnext/erpnext/utilities/activation.py,Purchase orders help you plan and follow up on your purchases,Objednávky pomohou při plánování a navázat na vašich nákupech
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Lab Test Prescriptions,Předpisy pro laboratorní testy
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é emise / přenosu množství {0} v hmotné Request {1} \ nemůže být vyšší než požadované množství {2} pro položku {3}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Small,Malý
DocType: Shopify Settings,"If Shopify not contains a customer in Order, then while syncing Orders, the system will consider default customer for order","Pokud služba Shopify neobsahuje zákazníka v objednávce, pak při synchronizaci objednávek systém bude považovat výchozí zákazníka za objednávku"
DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Otevření položky nástroje pro vytváření faktur
DocType: Cashier Closing Payments,Cashier Closing Payments,Pokladní hotovostní platby
DocType: Education Settings,Employee Number,Počet zaměstnanců
DocType: Subscription Settings,Cancel Invoice After Grace Period,Zrušit faktura po období odkladu
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Case No(s) already in use. Try from Case No {0},Případ číslo (čísla) již v provozu. Zkuste se věc č {0}
DocType: Project,% Completed,% Dokončeno
,Invoiced Amount (Exculsive Tax),Fakturovaná částka (bez daně)
DocType: Asset Finance Book,Rate of Depreciation,Míra odpisování
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Serial Numbers,Sériová čísla
apps/erpnext/erpnext/controllers/stock_controller.py,Row {0}: Quality Inspection rejected for item {1},Řádek {0}: Inspekce kvality zamítnuta pro položku {1}
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 2,Položka 2
DocType: Pricing Rule,Validate Applied Rule,Ověřte použité pravidlo
DocType: QuickBooks Migrator,Authorization Endpoint,Autorizační koncový bod
DocType: Employee Onboarding,Notify users by email,Upozornit uživatele e-mailem
DocType: Travel Request,International,Mezinárodní
DocType: Training Event,Training Event,Training Event
DocType: Item,Auto re-order,Automatické znovuobjednání
DocType: Attendance,Late Entry,Pozdní vstup
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Total Achieved,Celkem Dosažená
DocType: Employee,Place of Issue,Místo vydání
DocType: Promotional Scheme,Promotional Scheme Price Discount,Sleva na cenu propagačního schématu
DocType: Contract,Contract,Smlouva
DocType: GSTR 3B Report,May,Květen
DocType: Plant Analysis,Laboratory Testing Datetime,Laboratorní testování Datetime
DocType: Email Digest,Add Quote,Přidat nabídku
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,UOM coversion factor required for UOM: {0} in Item: {1},UOM coversion faktor potřebný k nerozpuštěných: {0} v bodě: {1}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Indirect Expenses,Nepřímé náklady
apps/erpnext/erpnext/controllers/selling_controller.py,Row {0}: Qty is mandatory,Row {0}: Množství je povinný
DocType: Agriculture Analysis Criteria,Agriculture,Zemědělství
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Sales Order,Vytvoření objednávky prodeje
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Accounting Entry for Asset,Účet evidence majetku
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,{0} is not a group node. Please select a group node as parent cost center,{0} není skupinový uzel. Vyberte skupinový uzel jako nadřazené nákladové středisko
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Block Invoice,Blokovat fakturu
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Quantity to Make,"Množství, které chcete vyrobit"
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Master Data,Sync Master Data
DocType: Asset Repair,Repair Cost,náklady na opravu
DocType: Quality Meeting Table,Under Review,Probíhá kontrola
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Přihlášení selhalo
DocType: Coupon Code,Promotional,Propagační
DocType: Special Test Items,Special Test Items,Speciální zkušební položky
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.,"Musíte být uživatelem s rolí Správce systému a Správce položek, který se má zaregistrovat na webu Marketplace."
apps/erpnext/erpnext/config/buying.py,Key Reports,Klíčové zprávy
DocType: Bank Statement Transaction Payment Item,Mode of Payment,Způsob platby
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řiřazené struktury platu nemůžete žádat o výhody
apps/erpnext/erpnext/stock/doctype/item/item.py,Website Image should be a public file or website URL,Webové stránky Image by měla být veřejná souboru nebo webové stránky URL
DocType: Purchase Invoice Item,BOM,BOM
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,This is a root item group and cannot be edited.,Jedná se o skupinu kořen položky a nelze upravovat.
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge,Spojit
DocType: Journal Entry Account,Purchase Order,Vydaná objednávka
DocType: Vehicle,Fuel UOM,palivo UOM
DocType: Warehouse,Warehouse Contact Info,Sklad Kontaktní informace
DocType: Payment Entry,Write Off Difference Amount,Odepsat Difference Částka
DocType: Volunteer,Volunteer Name,Jméno dobrovolníka
apps/erpnext/erpnext/controllers/accounts_controller.py,Rows with duplicate due dates in other rows were found: {0},Řádky s duplicitními daty v jiných řádcích byly nalezeny: {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,"{0}: Employee email not found, hence email not sent","{0}: e-mail zaměstnanec nebyl nalezen, a proto je pošta neposlal"
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,No Salary Structure assigned for Employee {0} on given date {1},Žádná struktura výdělku pro zaměstnance {0} v daný den {1}
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule not applicable for country {0},Pravidlo odeslání se nevztahuje na zemi {0}
DocType: Import Supplier Invoice,Import Invoices,Importovat faktury
DocType: Item,Foreign Trade Details,Zahraniční obchod Podrobnosti
,Assessment Plan Status,Stav plánu hodnocení
DocType: Email Digest,Annual Income,Roční příjem
DocType: Serial No,Serial No Details,Serial No Podrobnosti
DocType: Purchase Invoice Item,Item Tax Rate,Sazba daně položky
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Party Name,Od názvu strany
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Net Salary Amount,Čistá mzda
DocType: Pick List,Delivery against Sales Order,Dodávka na prodejní objednávku
DocType: Student Group Student,Group Roll Number,Číslo role skupiny
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"For {0}, only credit accounts can be linked against another debit entry","Pro {0}, tak úvěrové účty mohou být propojeny na jinou položku debetní"
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Delivery Note {0} is not submitted,Delivery Note {0} není předložena
apps/erpnext/erpnext/stock/get_item_details.py,Item {0} must be a Sub-contracted Item,Položka {0} musí být Subdodavatelské Item
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Capital Equipments,Kapitálové Vybavení
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.","Ceny Pravidlo je nejprve vybrána na základě ""Použít na"" oblasti, které mohou být položky, položky skupiny nebo značky."
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Please set the Item Code first,Nejprve nastavte kód položky
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Type
apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Celkové přidělené procento prodejní tým by měl být 100
DocType: Subscription Plan,Billing Interval Count,Počet fakturačních intervalů
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Setkání a setkání s pacienty
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Hodnota chybí
DocType: Employee,Department and Grade,Oddělení a stupeň
DocType: Antibiotic,Antibiotic,Antibiotikum
,Team Updates,tým Aktualizace
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,For Supplier,Pro Dodavatele
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.
DocType: Purchase Invoice,Grand Total (Company Currency),Celkový součet (Měna společnosti)
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Create Print Format,Vytvořit formát tisku
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Created,Poplatek byl vytvořen
apps/erpnext/erpnext/utilities/bot.py,Did not find any item called {0},Nenalezl žádnou položku s názvem {0}
apps/erpnext/erpnext/stock/report/item_prices/item_prices.js,Items Filter,Položka Filtr
DocType: Supplier Scorecard Criteria,Criteria Formula,Kritéria vzorce
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Total Outgoing,Celkem Odchozí
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""","Tam může být pouze jeden Shipping Rule Podmínka s 0 nebo prázdnou hodnotu pro ""na hodnotu"""
DocType: Bank Statement Transaction Settings Item,Transaction,Transakce
DocType: Call Log,Duration,Doba trvání
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/accounts/doctype/cost_center/cost_center.js,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Poznámka: Tento Nákladové středisko je Group. Nelze vytvořit účetní zápisy proti skupinám.
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Compensatory leave request days not in valid holidays,Kompenzační prázdniny nejsou v platných prázdninách
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Child warehouse exists for this warehouse. You can not delete this warehouse.,Dítě sklad existuje pro tento sklad. Nemůžete odstranit tento sklad.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Please enter <b>Difference Account</b> or set default <b>Stock Adjustment Account</b> for company {0},Zadejte <b>rozdílový účet</b> nebo nastavte výchozí <b>účet</b> pro <b>úpravu zásob</b> společnosti {0}
DocType: Item,Website Item Groups,Webové stránky skupiny položek
DocType: Purchase Invoice,Total (Company Currency),Total (Company měny)
DocType: Daily Work Summary Group,Reminder,Připomínka
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Accessable Value,Přístupná hodnota
apps/erpnext/erpnext/stock/utils.py,Serial number {0} entered more than once,Výrobní číslo {0} přihlášeno více než jednou
DocType: Bank Statement Transaction Invoice Item,Journal Entry,Zápis do deníku
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From GSTIN,Od GSTINu
DocType: Expense Claim Advance,Unclaimed amount,Nevyžádaná částka
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items in progress,{0} položky v probíhající
DocType: Workstation,Workstation Name,Meno pracovnej stanice
DocType: Grading Scale Interval,Grade Code,Grade Code
DocType: POS Item Group,POS Item Group,POS položky Group
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,Email Digest:,E-mail Digest:
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
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} does not belong to Item {1},BOM {0} nepatří k bodu {1}
DocType: Promotional Scheme,Product Discount Slabs,Desky slev produktu
DocType: Target Detail,Target Distribution,Target Distribution
DocType: Purchase Invoice,06-Finalization of Provisional assessment,06 - Dokončení předběžného posouzení
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Parties and Addresses,Dovážející strany a adresy
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM konverzní faktor ({0} -&gt; {1}) nebyl nalezen pro položku: {2}
DocType: Salary Slip,Bank Account No.,Bankovní účet č.
DocType: Naming Series,This is the number of the last created transaction with this prefix,To je číslo poslední vytvořené transakci s tímto prefixem
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)
","Můžete použít proměnné Scorecard, stejně jako: {total_score} (celkové skóre z tohoto období), {period_number} (počet období do současnosti)"
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Purchase Order,Vytvořit objednávku
DocType: Quality Inspection Reading,Reading 8,Čtení 8
DocType: Inpatient Record,Discharge Note,Poznámka k vybíjení
DocType: Appointment Booking Settings,Number of Concurrent Appointments,Počet souběžných schůzek
apps/erpnext/erpnext/config/desktop.py,Getting Started,Začínáme
DocType: Purchase Invoice,Taxes and Charges Calculation,Daně a poplatky výpočet
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Zúčtování odpisu majetku na účet automaticky
DocType: BOM Operation,Workstation,Pracovní stanice
DocType: Request for Quotation Supplier,Request for Quotation Supplier,Žádost o cenovou nabídku dodavatele
DocType: Healthcare Settings,Registration Message,Registrační zpráva
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Hardware,Technické vybavení
DocType: Prescription Dosage,Prescription Dosage,Dávkování na předpis
DocType: Appointment Booking Settings,HR Manager,HR Manager
apps/erpnext/erpnext/accounts/party.py,Please select a Company,Vyberte společnost
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Privilege Leave,Privilege Leave
DocType: Purchase Invoice,Supplier Invoice Date,Dodavatelské faktury Datum
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: Payment Entry,Writeoff,Odepsat
DocType: Maintenance Visit,MAT-MVS-.YYYY.-,MAT-MVS-.YYYY.-
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
DocType: Stock Settings,Naming Series Prefix,Pojmenování předpony řady
DocType: Appraisal Template Goal,Appraisal Template Goal,Posouzení Template Goal
DocType: Salary Component,Earning,Získávání
DocType: Supplier Scorecard,Scoring Criteria,Kritéria hodnocení
DocType: Purchase Invoice,Party Account Currency,Party Měna účtu
DocType: Delivery Trip,Total Estimated Distance,Celková odhadovaná vzdálenost
DocType: Invoice Discounting,Accounts Receivable Unpaid Account,Účet nesplacených účtů
DocType: Tally Migration,Tally Company,Společnost Tally
apps/erpnext/erpnext/config/manufacturing.py,BOM Browser,Prohlížeč kusovníku
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py,Not allowed to create accounting dimension for {0},Není dovoleno vytvářet účetní dimenzi pro {0}
apps/erpnext/erpnext/templates/emails/training_event.html,Please update your status for this training event,Aktualizujte svůj stav pro tuto tréninkovou akci
DocType: Item Barcode,EAN,EAN
DocType: Purchase Taxes and Charges,Add or Deduct,Přidat nebo Odečíst
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Overlapping conditions found between:,Překrývající podmínky nalezeno mezi:
DocType: Bank Transaction Mapping,Field in Bank Transaction,Pole v bankovní transakci
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Against Journal Entry {0} is already adjusted against some other voucher,Proti věstníku Entry {0} je již nastavena proti jiným poukaz
,Inactive Sales Items,Neaktivní prodejní položky
DocType: Quality Review,Additional Information,dodatečné informace
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Total Order Value,Celková hodnota objednávky
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Food,Jídlo
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 3,Stárnutí Rozsah 3
DocType: POS Closing Voucher Details,POS Closing Voucher Details,Podrobnosti závěrečného poukazu POS
DocType: Bank Account,Is the Default Account,Je výchozí účet
DocType: Shopify Log,Shopify Log,Shopify Přihlásit
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,No communication found.,Nebyla nalezena žádná komunikace.
DocType: Inpatient Occupancy,Check In,Check In
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Create Payment Entry,Vytvořit platební záznam
DocType: Maintenance Schedule Item,No of Visits,Počet návštěv
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance Schedule {0} exists against {1},Plán údržby {0} existuje proti {1}
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Enrolling student,učící studenta
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/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.",Schůzka se překrývá s {0}. <br> {1} má schůzku naplánovanou s {2} na {3} s {4} minutami.
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šech cílů by mělo být 100. Je {0}
DocType: Project,Start and End Dates,Datum zahájení a ukončení
DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Podmínky splnění šablony smlouvy
,Delivered Items To Be Billed,Dodávaných výrobků fakturovaných
DocType: Coupon Code,Maximum Use,Maximální využití
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Otevřená BOM {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Warehouse nemůže být změněn pro Serial No.
DocType: Authorization Rule,Average Discount,Průměrná sleva
DocType: Pricing Rule,UOM,UOM
DocType: Employee Tax Exemption Declaration,Annual HRA Exemption,Výroční výjimka pro HRA
DocType: Rename Tool,Utilities,Utilities
DocType: POS Profile,Accounting,Účetnictví
DocType: Asset,Purchase Receipt Amount,Částka k nákupu
DocType: Employee Separation,Exit Interview Summary,Ukončete shrnutí rozhovoru
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select batches for batched item ,Zvolte dávky pro doručenou položku
DocType: Asset,Depreciation Schedules,odpisy Plány
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Sales Invoice,Vytvořit prodejní fakturu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Ineligible ITC,Nezpůsobilé ITC
DocType: Task,Dependent Tasks,Závislé úkoly
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Following accounts might be selected in GST Settings:,V nastavení GST lze vybrat následující účty:
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js,Quantity to Produce,Množství k výrobě
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Application period cannot be outside leave allocation period,Období pro podávání žádostí nemůže být alokační období venku volno
DocType: Activity Cost,Projects,Projekty
DocType: Payment Request,Transaction Currency,Transakční měna
apps/erpnext/erpnext/controllers/buying_controller.py,From {0} | {1} {2},Od {0} | {1} {2}
apps/erpnext/erpnext/public/js/hub/marketplace.js,Some emails are invalid,Některé e-maily jsou neplatné
DocType: Work Order Operation,Operation Description,Operace Popis
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 měnit Fiskální rok Datum zahájení a fiskální rok datum ukončení, jakmile fiskální rok se uloží."
DocType: Quotation,Shopping Cart,Nákupní vozík
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Avg Daily Outgoing,Avg Daily Odchozí
DocType: POS Profile,Campaign,Kampaň
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,"{0} will be cancelled automatically on asset cancellation as it was \
					auto generated for Asset {1}","{0} bude zrušeno automaticky při zrušení aktiv, protože bylo \ autogenerováno pro Aktivum {1}"
DocType: Supplier,Name and Type,Název a typ
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Item Reported,Hlášená položka
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 ""Zamítnuto"""
DocType: Healthcare Practitioner,Contacts and Address,Kontakty a adresa
DocType: Shift Type,Determine Check-in and Check-out,Určete check-in a check-out
DocType: Salary Structure,Max Benefits (Amount),Maximální výhody (částka)
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Add notes,Přidejte poznámky
DocType: Purchase Invoice,Contact Person,Kontaktní osoba
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,No data for this period,Pro toto období nejsou k dispozici žádná data
DocType: Course Scheduling Tool,Course End Date,Konec Samozřejmě Datum
DocType: Holiday List,Holidays,Prázdniny
DocType: Sales Order Item,Planned Quantity,Plánované Množství
DocType: Water Analysis,Water Analysis Criteria,Kritéria analýzy vody
DocType: Item,Maintain Stock,Udržovat stav zásob
DocType: Terms and Conditions,Applicable Modules,Použitelné moduly
DocType: Employee,Prefered Email,preferovaný Email
DocType: Student Admission,Eligibility and Details,Způsobilost a podrobnosti
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Included in Gross Profit,Zahrnuto do hrubého zisku
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Fixed Asset,Čistá změna ve stálých aktiv
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Reqd Qty,Požadovaný počet
apps/erpnext/erpnext/controllers/accounts_controller.py,Charge of type 'Actual' in row {0} cannot be included in Item Rate,"Obvinění z typu ""Aktuální"" v řádku {0} nemůže být zařazena do položky Rate"
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Max: {0},Max: {0}
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py,From Datetime,Od datetime
DocType: Shopify Settings,For Company,Pro Společnost
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.",Žádost o cenovou nabídku je zakázán přístup z portálu pro více Zkontrolujte nastavení portálu.
DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Variabilní skóre skóre dodavatele skóre
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Buying Amount,Nákup Částka
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Company of asset {0} and purchase document {1} doesn't matches.,Společnost s aktivem {0} a nákupní doklad {1} se neshodují.
DocType: POS Closing Voucher,Modes of Payment,Způsoby platby
DocType: Sales Invoice,Shipping Address Name,Název dodací adresy
apps/erpnext/erpnext/accounts/doctype/account/account.js,Chart of Accounts,Diagram účtů
DocType: Material Request,Terms and Conditions Content,Podmínky Content
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 vytváření plánu rozvrhů
DocType: Communication Medium,Timeslots,Timeslots
DocType: Department,The first Expense Approver in the list will be set as the default Expense Approver.,První Průvodce výdajů v seznamu bude nastaven jako výchozí schvalovatel výdajů.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,cannot be greater than 100,nemůže být větší než 100
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.,"Musíte být jiným uživatelem než správcem s rolí Správce systému a Správce položek, který se má zaregistrovat na webu Marketplace."
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is not a stock Item,Položka {0} není skladem
DocType: Packing Slip,MAT-PAC-.YYYY.-,MAT-PAC-.YYYY.-
DocType: Maintenance Visit,Unscheduled,Neplánovaná
DocType: Employee,Owned,Vlastník
DocType: Pricing Rule,"Higher the number, higher the priority","Vyšší číslo, vyšší priorita"
,Purchase Invoice Trends,Trendy přijatách faktur
apps/erpnext/erpnext/www/all-products/not_found.html,No products found,Nebyly nalezeny žádné produkty
DocType: Employee,Better Prospects,Lepší vyhlídky
DocType: Travel Itinerary,Gluten Free,Bezlepkový
DocType: Loyalty Program Collection,Minimum Total Spent,Minimální celková vynaložená částka
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 prosím jinou dávku, která má k dispozici {3} qty nebo rozdělit řádek do více řádků, doručit / vydávat z více dávek"
DocType: Loyalty Program,Expiry Duration (in days),Doba platnosti (v dnech)
DocType: Inpatient Record,Discharge Date,Datum propuštění
DocType: Subscription Plan,Price Determination,Stanovení ceny
DocType: Vehicle,License Plate,poznávací značka
apps/erpnext/erpnext/hr/doctype/department/department_tree.js,New Department,Nové oddělení
DocType: Compensatory Leave Request,Worked On Holiday,Pracoval na dovolené
DocType: Appraisal,Goals,Cíle
DocType: Support Settings,Allow Resetting Service Level Agreement,Povolit obnovení dohody o úrovni služeb
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Select POS Profile,Zvolte Profil POS
DocType: Warranty Claim,Warranty / AMC Status,Záruka / AMC Status
,Accounts Browser,Účty Browser
DocType: Procedure Prescription,Referral,Postoupení
DocType: Payment Entry Reference,Payment Entry Reference,Platba Vstup reference
DocType: GL Entry,GL Entry,Vstup GL
DocType: Support Search Source,Response Options,Možnosti odpovědi
DocType: Pricing Rule,Apply Multiple Pricing Rules,Použijte pravidla pro více cen
DocType: HR Settings,Employee Settings,Nastavení zaměstnanců
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.html,Loading Payment System,Načítání platebního systému
,Batch-Wise Balance History,Batch-Wise Balance History
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 hodnotu, pokud je částka vyšší než částka fakturovaná pro položku {1}."
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Print settings updated in respective print format,Nastavení tisku aktualizovány v příslušném formátu tisku
DocType: Package Code,Package Code,Code Package
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Apprentice,Učeň
DocType: Purchase Invoice,Company GSTIN,Společnost GSTIN
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Negative Quantity is not allowed,Negativní množství není dovoleno
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges","Tax detail tabulka staženy z položky pána jako řetězec a uložené v této oblasti.
 Používá se daní a poplatků"
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Employee cannot report to himself.,Zaměstnanec nemůže odpovídat sám sobě.
apps/erpnext/erpnext/templates/pages/order.html,Rate:,Hodnotit:
DocType: Bank Account,Change this date manually to setup the next synchronization start date,Toto datum změňte ručně a nastavte další datum zahájení synchronizace
DocType: Leave Type,Max Leaves Allowed,Maximální povolené povolenky
DocType: Account,"If the account is frozen, entries are allowed to restricted users.","V případě, že účet je zamrzlý, položky mohou omezeným uživatelům."
DocType: Email Digest,Bank Balance,Bank Balance
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} mohou být prováděny pouze v měně: {2}
DocType: HR Settings,Leave Approver Mandatory In Leave Application,Povolení odchody je povinné v aplikaci Nechat
DocType: Job Opening,"Job profile, qualifications required etc.","Profil Job, požadované kvalifikace atd."
DocType: Journal Entry Account,Account Balance,Zůstatek na účtu
apps/erpnext/erpnext/config/accounts.py,Tax Rule for transactions.,Daňové Pravidlo pro transakce.
DocType: Rename Tool,Type of document to rename.,Typ dokumentu přejmenovat.
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Resolve error and upload again.,Vyřešte chybu a nahrajte znovu.
DocType: Buying Settings,Over Transfer Allowance (%),Příspěvek na převody (%)
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 vyžadován oproti účtu pohledávek {2}
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Celkem Daně a poplatky (Company Měnové)
DocType: Weather,Weather Parameter,Parametr počasí
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Show unclosed fiscal year's P&L balances,Ukázat P &amp; L zůstatky neuzavřený fiskální rok je
DocType: Item,Asset Naming Series,Série pojmenování aktiv
DocType: Appraisal,HR-APR-.YY.-.MM.,HR-APR-.YY.-.MM.
apps/erpnext/erpnext/regional/india/utils.py,House rented dates should be atleast 15 days apart,Domovní pronajaté data by měly být nejméně 15 dnů od sebe
DocType: Clinical Procedure Template,Collection Details,Podrobnosti o kolekci
DocType: POS Profile,Allow Print Before Pay,Povolit tisk před zaplacením
DocType: Linked Soil Texture,Linked Soil Texture,Spojená půdní struktura
DocType: Shipping Rule,Shipping Account,Přepravní účtu
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} is inactive,{0} {1}: Účet {2} je neaktivní
DocType: GSTR 3B Report,March,březen
DocType: Bank Statement Transaction Entry,Bank Transaction Entries,Položky bankovních transakcí
DocType: Quality Inspection,Readings,Čtení
DocType: Stock Entry,Total Additional Costs,Celkem Dodatečné náklady
DocType: Quality Action,Quality Action,Kvalitní akce
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,No of Interactions,Počet interakcí
DocType: BOM,Scrap Material Cost(Company Currency),Šrot materiálové náklady (Company měna)
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,"Set Start Time and End Time for  \
					Support Day {0} at index {1}.",Nastavte počáteční a konečný čas pro \ Support Day {0} na index {1}.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Sub Assemblies,Podsestavy
DocType: Asset,Asset Name,Asset Name
DocType: Employee Boarding Activity,Task Weight,úkol Hmotnost
DocType: Shipping Rule Condition,To Value,Chcete-li hodnota
DocType: Accounts Settings,Automatically Add Taxes and Charges from Item Tax Template,Automaticky přidávat daně a poplatky ze šablony položky daně
DocType: Loyalty Program,Loyalty Program Type,Typ věrnostního programu
DocType: Asset Movement,Stock Manager,Reklamní manažer
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Source warehouse is mandatory for row {0},Source sklad je povinná pro řadu {0}
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,The Payment Term at row {0} is possibly a duplicate.,Platba v řádku {0} je možná duplikát.
apps/erpnext/erpnext/public/js/setup_wizard.js,Agriculture (beta),Zemědělství (beta)
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Packing Slip,Balící list
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Rent,Pronájem kanceláře
apps/erpnext/erpnext/config/settings.py,Setup SMS gateway settings,Nastavení SMS brány
DocType: Disease,Common Name,Běžné jméno
DocType: Customer Feedback Template Table,Customer Feedback Template Table,Tabulka šablon zpětné vazby od zákazníka
DocType: Employee Boarding Activity,Employee Boarding Activity,Aktivita nástupu zaměstnanců
apps/erpnext/erpnext/public/js/templates/address_list.html,No address added yet.,Žádná adresa přidán dosud.
DocType: Workstation Working Hour,Workstation Working Hour,Pracovní stanice Pracovní Hour
DocType: Vital Signs,Blood Pressure,Krevní tlak
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Analyst,Analytik
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 mzdovém období
DocType: Employee Benefit Application,Max Benefits (Yearly),Maximální přínosy (ročně)
DocType: Item,Inventory,Inventář
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Stáhnout jako Json
DocType: Item,Sales Details,Prodejní Podrobnosti
DocType: Coupon Code,Used,Použitý
DocType: Opportunity,With Items,S položkami
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampaň &#39;{0}&#39; již existuje pro {1} &#39;{2}&#39;
DocType: Asset Maintenance,Maintenance Team,Tým údržby
DocType: Homepage Section,"Order in which sections should appear. 0 is first, 1 is second and so on.","Pořadí, ve kterém se mají sekce zobrazit. 0 je první, 1 je druhý a tak dále."
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,In Qty,V Množství
DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Ověřte zapsaný kurz pro studenty ve skupině studentů
DocType: Item,Item Attribute,Položka Atribut
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Government,Vláda
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Expense Claim {0} already exists for the Vehicle Log,Náklady na pojistná {0} již existuje pro jízd
DocType: Asset Movement Item,Source Location,Umístění zdroje
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Name,Jméno Institute
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter repayment Amount,"Prosím, zadejte splácení Částka"
DocType: Shift Type,Working Hours Threshold for Absent,Prahová hodnota pracovní doby pro nepřítomnost
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 množství může být více stupňů sběru. Přepočítací koeficient pro vykoupení bude vždy stejný pro všechny úrovně.
apps/erpnext/erpnext/config/help.py,Item Variants,Položka Varianty
apps/erpnext/erpnext/public/js/setup_wizard.js,Services,Služby
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,BOM 2,Kus 2
DocType: Payment Order,PMO-,PMO-
DocType: HR Settings,Email Salary Slip to Employee,Email výplatní pásce pro zaměstnance
DocType: Cost Center,Parent Cost Center,Nadřazené Nákladové středisko
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Create Invoices,Vytvářejte faktury
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Select Possible Supplier,Vyberte Možné dodavatele
DocType: Communication Medium,Communication Medium Type,Typ komunikačního média
DocType: Customer,"Select, to make the customer searchable with these fields","Zvolte, chcete-li, aby se zákazník prohledal s těmito poli"
DocType: Shopify Settings,Import Delivery Notes from Shopify on Shipment,Importovat doručovací poznámky z Shopify při odeslání
apps/erpnext/erpnext/templates/pages/projects.html,Show closed,Show uzavřen
DocType: Issue Priority,Issue Priority,Priorita vydání
DocType: Leave Ledger Entry,Is Leave Without Pay,Je odejít bez Pay
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,GSTIN,GSTIN
apps/erpnext/erpnext/stock/doctype/item/item.py,Asset Category is mandatory for Fixed Asset item,Asset kategorie je povinný pro položku dlouhodobých aktiv
DocType: Fee Validity,Fee Validity,Platnost poplatku
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,No records found in the Payment table,Nalezené v tabulce platby Žádné záznamy
apps/erpnext/erpnext/education/utils.py,This {0} conflicts with {1} for {2} {3},Tato {0} je v rozporu s {1} o {2} {3}
DocType: Student Attendance Tool,Students HTML,studenti HTML
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,{0}: {1} must be less than {2},{0}: {1} musí být menší než {2}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,"Select BOM, Qty and For Warehouse","Vyberte kusovník, množství a pro sklad"
DocType: GST HSN Code,GST HSN Code,GST HSN kód
DocType: Employee External Work History,Total Experience,Celková zkušenost
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Projects,otevřené projekty
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Packing Slip(s) cancelled,Balící list(y) stornován(y)
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Investing,Peněžní tok z investičních
DocType: Program Course,Program Course,Program kurzu
DocType: Healthcare Service Unit,Allow Appointments,Povolit schůzky
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Freight and Forwarding Charges,Nákladní a Spediční Poplatky
DocType: Homepage,Company Tagline for website homepage,Firma fb na titulní stránce webu
DocType: Item Group,Item Group Name,Položka Název skupiny
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,Taken,Zaujatý
DocType: Invoice Discounting,Short Term Loan Account,Krátkodobý úvěrový účet
DocType: Student,Date of Leaving,Datem odchodu
DocType: Pricing Rule,For Price List,Pro Ceník
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Executive Search,Executive Search
DocType: Employee Advance,HR-EAD-.YYYY.-,HR-EAD-.YYYY.-
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Setting defaults,Nastavení výchozích hodnot
DocType: Loyalty Program,Auto Opt In (For all customers),Automatická registrace (pro všechny zákazníky)
apps/erpnext/erpnext/utilities/activation.py,Create Leads,vytvoření vede
DocType: Maintenance Schedule,Schedules,Plány
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žití prodejního místa
DocType: Cashier Closing,Net Amount,Čistá čá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} nebyla odeslána, takže akce nemůže být dokončena"
DocType: Purchase Order Item Supplied,BOM Detail No,BOM Detail No
DocType: Support Search Source,Result Route Field,Výsledek pole trasy
DocType: Supplier,PAN,PÁNEV
DocType: Employee Checkin,Log Type,Typ protokolu
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Dodatečná sleva Částka (Měna Company)
DocType: Supplier Scorecard,Supplier Scorecard,Hodnotící karta dodavatele
DocType: Plant Analysis,Result Datetime,Výsledek Datetime
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,From employee is required while receiving Asset {0} to a target location,Od zaměstnance je vyžadováno při přijímání díla {0} na cílové místo
,Support Hour Distribution,Distribuce hodinové podpory
DocType: Maintenance Visit,Maintenance Visit,Maintenance Visit
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Close Loan,Zavřít půjčku
DocType: Student,Leaving Certificate Number,Vysvědčení číslo
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,"Appointment cancelled, Please review and cancel the invoice {0}","Schůzka zrušena, zkontrolujte a zrušte fakturu {0}"
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,K dispozici šarže Množství ve skladu
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Update Print Format,Aktualizace Print Format
DocType: Bank Account,Is Company Account,Je účet společnosti
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,Leave Type {0} is not encashable,Opustit typ {0} není vyměnitelný
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Credit limit is already defined for the Company {0},Úvěrový limit je již pro společnost definován {0}
DocType: Landed Cost Voucher,Landed Cost Help,Přistálo Náklady Help
DocType: Vehicle Log,HR-VLOG-.YYYY.-,HR-VLOG-.YYYY.-
DocType: Purchase Invoice,Select Shipping Address,Zvolit adresu pro dodání
DocType: Timesheet Detail,Expected Hrs,Očekávané hodiny
apps/erpnext/erpnext/config/non_profit.py,Memebership Details,Podrobnosti o členství
DocType: Leave Block List,Block Holidays on important days.,Blokové Dovolená na významných dnů.
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Please input all required Result Value(s),Zadejte prosím všechny požadované hodnoty výsledků
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Accounts Receivable Summary,Pohledávky Shrnutí
DocType: POS Closing Voucher,Linked Invoices,Linkované faktury
DocType: Loan,Monthly Repayment Amount,Výše měsíční splátky
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices,Otevření faktur
DocType: Contract,Contract Details,Detaily smlouvy
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please set User ID field in an Employee record to set Employee Role,Prosím nastavte uživatelské ID pole v záznamu zaměstnanců nastavit role zaměstnance
DocType: UOM,UOM Name,UOM Name
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 1,Adresa 1
DocType: GST HSN Code,HSN Code,Kód HSN
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution Amount,Výše příspěvku
DocType: Homepage Section,Section Order,Řád sekce
DocType: Inpatient Record,Patient Encounter,Setkání pacienta
DocType: Accounts Settings,Shipping Address,Dodací adresa
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. To se obvykle používá k synchronizaci hodnot systému a to, co ve skutečnosti existuje ve vašich skladech."
DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,"Ve slovech budou viditelné, jakmile uložíte doručení poznámku."
apps/erpnext/erpnext/erpnext_integrations/utils.py,Unverified Webhook Data,Neověřené data Webhook
DocType: Water Analysis,Container,Kontejner
apps/erpnext/erpnext/education/utils.py,Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} objeví vícekrát za sebou {2} {3}
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Following fields are mandatory to create address:,K vytvoření adresy jsou povinná následující pole:
DocType: Item Alternative,Two-way,Obousměrné
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}
,Employee Billing Summary,Přehled fakturace zaměstnanců
DocType: Project,Day to Send,Den odeslání
DocType: Healthcare Settings,Manage Sample Collection,Správa kolekce vzorků
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set the series to be used.,"Nastavte prosím řadu, kterou chcete použít."
DocType: Patient,Tobacco Past Use,Použití tabáku v minulosti
DocType: Travel Itinerary,Mode of Travel,Způsob cestování
DocType: Sales Invoice Item,Brand Name,Jméno značky
DocType: Purchase Receipt,Transporter Details,Transporter Podrobnosti
DocType: Issue,Service Level Agreement Creation,Vytvoření dohody o úrovni služeb
apps/erpnext/erpnext/accounts/page/pos/pos.js,Default warehouse is required for selected item,Výchozí sklad je vyžadováno pro vybraná položka
DocType: Quiz,Passing Score,Úspěšné skóre
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Possible Supplier,možné Dodavatel
DocType: Budget,Monthly Distribution,Měsíční Distribution
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Receiver List is empty. Please create Receiver List,Přijímač Seznam je prázdný. Prosím vytvořte přijímače Seznam
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 nerezidentní poskytovatele služeb OIDAR
apps/erpnext/erpnext/public/js/setup_wizard.js,Healthcare (beta),Zdravotnictví (beta)
DocType: Production Plan Sales Order,Production Plan Sales Order,Výrobní program prodejní objednávky
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} nebyl nalezen žádný aktivní kusovníček. Dodání pomocí \ sériového čísla nemůže být zajištěno
DocType: Sales Partner,Sales Partner Target,Sales Partner Target
DocType: Loan Type,Maximum Loan Amount,Maximální výše úvěru
DocType: Coupon Code,Pricing Rule,Ceny Pravidlo
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplicitní číslo role pro studenty {0}
apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Materiál Žádost o příkazu k nákupu
DocType: Company,Default Selling Terms,Výchozí prodejní podmínky
DocType: Shopping Cart Settings,Payment Success URL,Platba Úspěch URL
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žky {1} neexistuje v {2} {3}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Bank Accounts,Bankovní účty
,Bank Reconciliation Statement,Bank Odsouhlasení prohlášení
DocType: Patient Encounter,Medical Coding,Lékařské kódování
DocType: Healthcare Settings,Reminder Message,Připomenutí zprávy
DocType: Call Log,Lead Name,Jméno leadu
,POS,POS
DocType: C-Form,III,III
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Prospecting,Prospektování
apps/erpnext/erpnext/config/help.py,Opening Stock Balance,Počáteční cena zásob
DocType: Asset Category Account,Capital Work In Progress Account,Pokročilý účet kapitálové práce
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Value Adjustment,Úprava hodnoty aktiv
DocType: Additional Salary,Payroll Date,Den mzdy
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,{0} must appear only once,{0} musí být uvedeny pouze jednou
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,Leaves Allocated Successfully for {0},Dovolená úspěšně přidělena {0}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,No Items to pack,Žádné položky k balení
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Only .csv and .xlsx files are supported currently,Aktuálně jsou podporovány pouze soubory CSV a XLSX
DocType: Shipping Rule Condition,From Value,Od hodnoty
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Manufacturing Quantity is mandatory,Výrobní množství je povinné
DocType: Loan,Repayment Method,splácení Metoda
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í bod skupina pro webové stránky"
DocType: Quality Inspection Reading,Reading 4,Čtení 4
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Pending Quantity,Čekající množství
apps/erpnext/erpnext/utilities/activation.py,"Students are at the heart of the system, add all your students","Studenti jsou jádrem systému, přidejte všechny své studenty"
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Member ID,Členské ID
DocType: Employee Tax Exemption Proof Submission,Monthly Eligible Amount,Měsíční způsobilá částka
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Řádek # {0}: datum Světlá {1} nemůže být před Cheque Datum {2}
DocType: Asset Maintenance Task,Certificate Required,Potřebný certifikát
DocType: Company,Default Holiday List,Výchozí Holiday Seznam
DocType: Pricing Rule,Supplier Group,Skupina dodavatelů
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,{0} Digest,{0} Digest
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}: čas od času i na čas z {1} se překrývá s {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Liabilities,Stock Závazky
DocType: Purchase Invoice,Supplier Warehouse,Dodavatel Warehouse
DocType: Opportunity,Contact Mobile No,Kontakt Mobil
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Select Company,Vyberte společnost
,Material Requests for which Supplier Quotations are not created,Materiál Žádosti o které Dodavatel citace nejsou vytvořeny
apps/erpnext/erpnext/config/crm.py,"Helps you keep tracks of Contracts based on Supplier, Customer and Employee","Pomáhá vám sledovat smlouvy na základě dodavatele, zákazníka a zaměstnance"
DocType: Company,Discount Received Account,Sleva přijatý účet
DocType: Appointment Booking Settings,Enable Appointment Scheduling,Povolit plánování schůzek
DocType: Student Report Generation Tool,Print Section,Sekce tisku
DocType: Staffing Plan Detail,Estimated Cost Per Position,Odhadovaná cena za pozici
DocType: Employee,HR-EMP-,HR-EMP-
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: Quality Meeting Minutes,Quality Meeting Minutes,Kvalitní zápisnice z jednání
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Employee Referral,Doporučení zaměstnance
DocType: Student Group,Set 0 for no limit,Nastavte 0 pro žádný limit
DocType: Cost Center,rgt,Rgt
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.,"V den, kdy (y), na které žádáte o povolení jsou prázdniny. Nemusíte požádat o volno."
DocType: Customer,Primary Address and Contact Detail,Primární adresa a podrobnosti kontaktu
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Resend Payment Email,Znovu poslat e-mail Payment
apps/erpnext/erpnext/templates/pages/projects.html,New task,Nová úloha
DocType: Appointment,Appointment,Jmenování
apps/erpnext/erpnext/config/buying.py,Other Reports,Ostatní zprávy
apps/erpnext/erpnext/public/js/setup_wizard.js,Please select at least one domain.,Vyberte alespoň jednu doménu.
DocType: Dependent Task,Dependent Task,Závislý Task
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to UIN holders,Spotřební materiál pro držitele UIN
DocType: Shopify Settings,Shopify Tax Account,Nakupujte daňový účet
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}"
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave of type {0} cannot be longer than {1},Absence typu {0} nemůže být delší než {1}
DocType: Delivery Trip,Optimize Route,Optimalizujte trasu
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Zkuste plánování operací pro X dní předem.
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,"{0} vacancies and {1} budget for {2} already planned for subsidiary companies of {3}. \
				You can only plan for upto {4} vacancies and and budget {5} as per staffing plan {6} for parent company {3}.",{0} volných pracovních míst a {1} rozpočtu pro {2} již plánované pro dceřiné společnosti {3}. \ Plánujete pouze {4} volných míst a rozpočet {5} podle personálního plánu {6} pro mateřské společnosti {3}.
DocType: HR Settings,Stop Birthday Reminders,Zastavit připomenutí narozenin
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set Default Payroll Payable Account in Company {0},"Prosím nastavit výchozí mzdy, splatnou účet ve firmě {0}"
DocType: Pricing Rule Brand,Pricing Rule Brand,Značka pravidla cen
DocType: Amazon MWS Settings,Get financial breakup of Taxes and charges data by Amazon ,Získejte finanční rozdělení údajů o daních a poplatcích od společnosti Amazon
DocType: SMS Center,Receiver List,Přijímač Seznam
DocType: Pricing Rule,Rule Description,Popis pravidla
apps/erpnext/erpnext/accounts/page/pos/pos.js,Search Item,Hledání položky
DocType: Program,Allow Self Enroll,Povolit vlastní registraci
DocType: Payment Schedule,Payment Amount,Částka platby
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,Den poločasu by měl být mezi dnem práce a datem ukončení práce
DocType: Healthcare Settings,Healthcare Service Items,Položky zdravotnické služby
apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Neplatný čárový kód. K tomuto čárovému kódu není připojena žádná položka.
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Spotřebovaném množství
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Čistá změna v hotovosti
DocType: Assessment Plan,Grading Scale,Klasifikační stupnice
apps/erpnext/erpnext/stock/doctype/item/item.py,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Měrná jednotka {0} byl zadán více než jednou v konverzním faktorem tabulce
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock In Hand,Skladem v ruce
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 zbývající výhody {0} do aplikace jako \ pro-rata
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the public administration '%s',Nastavte prosím fiskální kód pro veřejnou správu &#39;% s&#39;
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Issued Items,Náklady na vydaných položek
DocType: Healthcare Practitioner,Hospital,NEMOCNICE
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}
DocType: Travel Request Costing,Funded Amount,Financovaná částka
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: Practitioner Schedule,Practitioner Schedule,Pracovní plán
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Age (Days),Stáří (dny)
DocType: Instructor,EDU-INS-.YYYY.-,EDU-INS-.YYYY.-
DocType: Additional Salary,Additional Salary,Další plat
DocType: Quotation Item,Quotation Item,Položka Nabídky
DocType: Customer,Customer POS Id,Identifikační číslo zákazníka
apps/erpnext/erpnext/education/utils.py,Student with email {0} does not exist,Student s e-mailem {0} neexistuje
DocType: Account,Account Name,Název účtu
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.py,From Date cannot be greater than To Date,Datum OD nemůže být vetší než datum DO
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} quantity {1} cannot be a fraction,Pořadové číslo {0} {1} množství nemůže být zlomek
DocType: Pricing Rule,Apply Discount on Rate,Použijte slevu na sazbu
DocType: Tally Migration,Tally Debtors Account,Účet Tally dlužníků
DocType: Pricing Rule,Promotional Scheme,Propagační program
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter Woocommerce Server URL,Zadejte adresu URL serveru Woocommerce
DocType: GSTR 3B Report,September,září
DocType: Purchase Order Item,Supplier Part Number,Dodavatel Číslo dílu
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
apps/erpnext/erpnext/accounts/page/bank_reconciliation/linked_payment_header.html,Payment Name,Název platby
DocType: Share Balance,To No,Ne
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Atleast one asset has to be selected.,Musí být vybráno alespoň jedno dílo.
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,All the mandatory Task for employee creation hasn't been done yet.,Veškerá povinná úloha pro tvorbu zaměstnanců dosud nebyla dokončena.
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled or stopped,{0} {1} je zrušena nebo zastavena
DocType: Accounts Settings,Credit Controller,Credit Controller
DocType: Loan,Applicant Type,Typ žadatele
DocType: Purchase Invoice,03-Deficiency in services,03 - Nedostatek služeb
DocType: Healthcare Settings,Default Medical Code Standard,Výchozí standard zdravotnického kódu
DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
DocType: Project Template Task,Project Template Task,Úloha šablony projektu
DocType: Accounts Settings,Over Billing Allowance (%),Příplatek za fakturaci (%)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Purchase Receipt {0} is not submitted,Doklad o koupi {0} není předložena
DocType: Company,Default Payable Account,Výchozí Splatnost účtu
apps/erpnext/erpnext/config/website.py,"Settings for online shopping cart such as shipping rules, price list etc.","Nastavení pro on-line nákupního košíku, jako jsou pravidla dopravu, ceník atd"
DocType: Purchase Receipt,MAT-PRE-.YYYY.-,MAT-PRE-.RRRR.-
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Billed,{0}% účtovano
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Reserved Qty,Reserved Množství
DocType: Party Account,Party Account,Party účtu
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,Please select Company and Designation,Vyberte prosím společnost a označení
apps/erpnext/erpnext/config/settings.py,Human Resources,Lidské zdroje
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Upper Income,Horní příjmů
DocType: Item Manufacturer,Item Manufacturer,položka Výrobce
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Create New Lead,Vytvořit nového potenciálního zákazníka
DocType: BOM Operation,Batch Size,Objem várky
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Reject,Odmítnout
DocType: Journal Entry Account,Debit in Company Currency,Debetní ve společnosti Měna
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Import Successfull,Import byl úspěšný
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Material Request not created, as quantity for Raw Materials already available.","Žádost o materiál nebyla vytvořena, protože množství již dostupných surovin."
DocType: BOM Item,BOM Item,Položka kusovníku
DocType: Appraisal,For Employee,Pro zaměstnance
DocType: Leave Control Panel,Designation (optional),Označení (volitelné)
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.","Míra ocenění nebyla pro položku {0} nalezena, což je nutné pro účetní záznamy pro {1} {2}. Pokud položka obchoduje jako položka s nulovou hodnotou ocenění v {1}, uveďte to v tabulce {1} Položka. V opačném případě vytvořte příchozí transakci s akciemi pro položku nebo uveďte záznamovou hodnotu v záznamu o položce a zkuste tento záznam odeslat nebo zrušit."
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Supplier must be debit,Řádek {0}: Advance proti dodavatelem musí být odepsat
DocType: Company,Default Values,Výchozí hodnoty
DocType: Certification Application,INR,INR
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Party Addresses,Adresy zpracovatelských stran
DocType: Woocommerce Settings,Creation User,Uživatel stvoření
DocType: Quality Procedure,Quality Procedure,Postup kvality
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Please check the error log for details about the import errors,Podrobnosti o chybách importu naleznete v protokolu chyb
DocType: Bank Transaction,Reconciled,Smířeno
DocType: Expense Claim,Total Amount Reimbursed,Celkové částky proplacené
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. Viz časovou osu níže podrobnosti
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Payroll date can not be less than employee's joining date,"Den výplaty nesmí být menší, než je datum přihlášení zaměstnance"
DocType: Pick List,Item Locations,Umístění položky
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.py,{0} {1} created,{0} {1} vytvořil
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}",Otevírání úloh pro označení {0} již otevřeno nebo dokončení pronájmu podle Personálního plánu {1}
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,You can publish upto 200 items.,Můžete publikovat až 200 položek.
DocType: Vital Signs,Constipated,Zácpa
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Against Supplier Invoice {0} dated {1},Proti faktuře dodavatele {0} ze dne {1}
DocType: Customer,Default Price List,Výchozí Ceník
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Asset Movement record {0} created,Záznam Asset Pohyb {0} vytvořil
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,Nelze odstranit fiskální rok {0}. Fiskální rok {0} je nastaven jako výchozí v globálním nastavení
DocType: Share Transfer,Equity/Liability Account,Účet vlastního kapitálu / odpovědnosti
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py,A customer with the same name already exists,Zákazník se stejným jménem již existuje
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 bude předkládán výplatní pásky a vytvářet záznamy časového rozvrhu. Chcete pokračovat?
DocType: Purchase Invoice,Total Net Weight,Celková čistá hmotnost
DocType: Purchase Order,Order Confirmation No,Potvrzení objednávky č
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Net Profit,Čistý zisk
DocType: Purchase Invoice,Eligibility For ITC,Způsobilost pro ITC
DocType: Student Applicant,EDU-APP-.YYYY.-,EDU-APP-.YYYY.-
DocType: Journal Entry,Entry Type,Entry Type
,Customer Credit Balance,Zákazník Credit Balance
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Accounts Payable,Čistá Změna účty závazků
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/setup/doctype/authorization_rule/authorization_rule.py,Customer required for 'Customerwise Discount',"Zákazník požadoval pro 'Customerwise sleva """
apps/erpnext/erpnext/config/accounts.py,Update bank payment dates with journals.,"Aktualizujte bankovní platební termín, časopisů."
,Billed Qty,Účtované množství
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Pricing,Stanovení ceny
DocType: Employee,Attendance Device ID (Biometric/RF tag ID),ID docházkového zařízení (Biometric / RF tag ID)
DocType: Quotation,Term Details,Termín Podrobnosti
DocType: Item,Over Delivery/Receipt Allowance (%),Příplatek za doručení / příjem (%)
DocType: Employee Incentive,Employee Incentive,Zaměstnanecká pobídka
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Cannot enroll more than {0} students for this student group.,Nemůže přihlásit více než {0} studentů na této studentské skupiny.
apps/erpnext/erpnext/templates/print_formats/includes/total.html,Total (Without Tax),Celkem (bez daně)
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Lead Count,Počet vedoucích
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Stock Available,Skladem k dispozici
DocType: Manufacturing Settings,Capacity Planning For (Days),Plánování kapacit Pro (dny)
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py,Procurement,Procurement
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,None of the items have any change in quantity or value.,Žádný z těchto položek má žádnou změnu v množství nebo hodnotě.
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Program,Povinná oblast - Program
DocType: Special Test Template,Result Component,Komponent výsledků
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js,Warranty Claim,Záruční reklamace
,Lead Details,Detaily leadu
DocType: Volunteer,Availability and Skills,Dostupnost a dovednosti
DocType: Salary Slip,Loan repayment,splácení úvěru
DocType: Share Transfer,Asset Account,Účet aktiv
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Nové datum vydání by mělo být v budoucnosti
DocType: Purchase Invoice,End date of current invoice's period,Datum ukončení doby aktuální faktury je
DocType: Lab Test,Technician Name,Jméno technika
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 dodávku podle sériového čísla, protože je přidána položka {0} se službou Zajistit dodání podle \ sériového čísla"
DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Odpojit Platba o zrušení faktury
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Aktuální stavu km vstoupil by měla být větší než počáteční měřiče ujeté vzdálenosti {0}
,Purchase Order Items To Be Received or Billed,Položky objednávek k přijetí nebo vyúčtování
DocType: Restaurant Reservation,No Show,Žádné vystoupení
apps/erpnext/erpnext/regional/india/utils.py,You must be a registered supplier to generate e-Way Bill,"Chcete-li vygenerovat e-Way Bill, musíte být registrovaným dodavatelem"
DocType: Shipping Rule Country,Shipping Rule Country,Přepravní Pravidlo Země
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Leave and Attendance,Nechat docházky
DocType: Asset,Comprehensive Insurance,Komplexní pojištění
DocType: Maintenance Visit,Partially Completed,Částečně Dokončeno
apps/erpnext/erpnext/public/js/event.js,Add Leads,Přidat předlohy
apps/erpnext/erpnext/healthcare/setup.py,Moderate Sensitivity,Mírná citlivost
DocType: Leave Type,Include holidays within leaves as leaves,Zahrnout dovolenou v listech jsou listy
DocType: Loyalty Program,Redemption,Vykoupení
DocType: Sales Invoice,Packed Items,Zabalené položky
DocType: Tally Migration,Vouchers,Poukazy
DocType: Tax Withholding Category,Tax Withholding Rates,Srážkové daně
DocType: Contract,Contract Period,Období smlouvy
apps/erpnext/erpnext/config/support.py,Warranty Claim against Serial No.,Reklamační proti sériového čísla
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,'Total',&#39;Celkový&#39;
DocType: Shopping Cart Settings,Enable Shopping Cart,Povolit Nákupní košík
DocType: Employee,Permanent Address,Trvalé bydliště
DocType: Loyalty Program,Collection Tier,Kolekce Tier
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ž je datum spojení"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}",Vyplacena záloha proti {0} {1} nemůže být větší \ než Grand Celkem {2}
DocType: Patient,Medication,Léky
DocType: Production Plan,Include Non Stock Items,"Zahrnout položky, které nejsou skladem"
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select item code,"Prosím, vyberte položku kód"
DocType: Student Sibling,Studying in Same Institute,Studium se ve stejném ústavu
DocType: Leave Type,Earned Leave,Získaná dovolená
apps/erpnext/erpnext/erpnext_integrations/connectors/shopify_connection.py,Tax Account not specified for Shopify Tax {0},Daňový účet není určen pro službu Shopify Tax {0}
DocType: Employee,Salary Details,Podrobnosti platu
DocType: Territory,Territory Manager,Oblastní manažer
DocType: Packed Item,To Warehouse (Optional),Warehouse (volitelné)
DocType: GST Settings,GST Accounts,Účty GST
DocType: Payment Entry,Paid Amount (Company Currency),Uhrazená částka (firemní měna)
DocType: Purchase Invoice,Additional Discount,Další slevy
DocType: Selling Settings,Selling Settings,Prodejní Nastavení
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Online Auctions,Aukce online
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please specify either Quantity or Valuation Rate or both,"Uveďte prosím buď Množství nebo ocenění Cena, nebo obojí"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py,Fulfillment,Splnění
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,View in Cart,Zobrazit Košík
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Purchase Invoice cannot be made against an existing asset {0},Nákupní fakturu nelze provést proti existujícímu dílu {0}
DocType: Employee Checkin,Shift Actual Start,Shift Skutečný start
DocType: Tally Migration,Is Day Book Data Imported,Jsou importována data denní knihy
,Purchase Order Items To Be Received or Billed1,Položky objednávek k přijetí nebo vyúčtování1
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/stock/doctype/pick_list/pick_list.py,{0} units of {1} is not available.,{0} jednotek {1} není k dispozici.
,Item Shortage Report,Položka Nedostatek Report
DocType: Bank Transaction Payments,Bank Transaction Payments,Platby bankovními transakcemi
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. Kritéria přejmenujte
apps/erpnext/erpnext/stock/doctype/item/item.js,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Hmotnost je uvedeno, \n uveďte prosím ""váha UOM"" příliš"
apps/erpnext/erpnext/hr/doctype/attendance/attendance_list.js,For Month,Za měsíc
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Zadaný požadavek materiálu k výrobě této skladové karty
DocType: Hub User,Hub Password,Heslo Hubu
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Samostatná skupina založená na kurzu pro každou dávku
,Sales Partner Target Variance based on Item Group,Cílová odchylka prodejního partnera na základě skupiny položek
apps/erpnext/erpnext/config/support.py,Single unit of an Item.,Single jednotka položky.
DocType: Fee Category,Fee Category,poplatek Kategorie
DocType: Agriculture Task,Next Business Day,Následující pracovní den
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Allocated Leaves,Přidělené listy
DocType: Drug Prescription,Dosage by time interval,Dávkování podle časového intervalu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Total Taxable Value,Celková zdanitelná hodnota
DocType: Cash Flow Mapper,Section Header,Záhlaví sekce
,Student Fee Collection,Student Fee Collection
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Appointment Duration (mins),Délka schůzky (min)
DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Ujistěte se účetní položka pro každý pohyb zásob
DocType: Leave Allocation,Total Leaves Allocated,Celkem Leaves Přidělené
apps/erpnext/erpnext/public/js/setup_wizard.js,Please enter valid Financial Year Start and End Dates,Zadejte prosím platnou finanční rok datum zahájení a ukončení
DocType: Employee,Date Of Retirement,Datum odchodu do důchodu
apps/erpnext/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py,Asset Value,Hodnota aktiva
DocType: Upload Attendance,Get Template,Získat šablonu
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Pick List,Vyberte seznam
,Sales Person Commission Summary,Souhrnné informace Komise pro prodejce
DocType: Material Request,Transferred,Přestoupil
DocType: Vehicle,Doors,dveře
DocType: Healthcare Settings,Collect Fee for Patient Registration,Vybírat poplatek za registraci pacienta
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,Atributy nelze změnit po transakci akcií. Vytvořte novou položku a přeneste materiál do nové položky
DocType: Course Assessment Criteria,Weightage,Weightage
DocType: Purchase Invoice,Tax Breakup,Rozdělení daní
DocType: Employee,Joining Details,Podrobnosti spojení
DocType: Member,Non Profit Member,Neziskový člen
DocType: Email Digest,Bank Credit Balance,Bankovní zůstatek
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}: Je vyžadováno nákladové středisko pro 'zisk a ztráta ""účtu {2}. Prosím nastavte výchozí nákladové středisko pro společnost."
DocType: Payment Schedule,Payment Term,Platební termín
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,"Zákaznická Skupina existuje se stejným názvem, prosím změňte název zákazníka nebo přejmenujte skupinu zákazníků"
DocType: Location,Area,Plocha
apps/erpnext/erpnext/public/js/templates/contact_list.html,New Contact,Nový kontakt
DocType: Company,Company Description,Popis společnosti
DocType: Territory,Parent Territory,Parent Territory
DocType: Purchase Invoice,Place of Supply,Místo dodávky
DocType: Quality Inspection Reading,Reading 2,Čtení 2
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 žádost o platbu {2} {1}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Material Receipt,Příjem materiálu
DocType: Bank Statement Transaction Entry,Submit/Reconcile Payments,Odeslání / odsouhlasení plateb
DocType: Campaign,SAL-CAM-.YYYY.-,SAL-CAM-.YYYY.-
DocType: Homepage,Products,Výrobky
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invoices based on Filters,Získejte faktury na základě filtrů
DocType: Announcement,Instructor,Instruktor
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Quantity to Manufacture can not be zero for the operation {0},Množství na výrobu nemůže být pro operaci nulové {0}
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Select Item (optional),Vyberte položku (volitelné)
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,The Loyalty Program isn't valid for the selected company,Věrnostní program není platný pro vybranou firmu
DocType: Fee Schedule Student Group,Fee Schedule Student Group,Poplatek za studentskou skupinu
DocType: Student,AB+,AB+
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Pokud je tato položka má varianty, pak to nemůže být vybrána v prodejních objednávek atd"
apps/erpnext/erpnext/config/selling.py,Define coupon codes.,Definujte kódy kupónů.
DocType: Products Settings,Hide Variants,Skrýt varianty
DocType: Lead,Next Contact By,Další Kontakt By
DocType: Compensatory Leave Request,Compensatory Leave Request,Žádost o kompenzační dovolenou
apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Nelze přeplatit za položku {0} v řádku {1} více než {2}. Chcete-li povolit nadměrnou fakturaci, nastavte v Nastavení účtu povolenky"
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Množství požadované pro bodě {0} v řadě {1}
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í k položce {1}"
DocType: Blanket Order,Order Type,Typ objednávky
,Item-wise Sales Register,Item-moudrý Sales Register
DocType: Asset,Gross Purchase Amount,Gross Částka nákupu
DocType: Asset,Depreciation Method,odpisy Metoda
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Je to poplatek v ceně základní sazbě?
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Total Target,Celkem Target
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Perception Analysis,Analýza vnímání
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Integrated Tax,Integrovaná daň
DocType: Soil Texture,Sand Composition (%),Složení písku (%)
DocType: Job Applicant,Applicant for a Job,Žadatel o zaměstnání
DocType: Production Plan Material Request,Production Plan Material Request,Výroba Poptávka Plán Materiál
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Automatic Reconciliation,Automatické smíření
DocType: Purchase Invoice,Release Date,Datum vydání
DocType: Stock Reconciliation,Reconciliation JSON,Odsouhlasení JSON
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ů. Export zprávu a vytiskněte jej pomocí aplikace tabulky.
DocType: Purchase Invoice Item,Batch No,Č. šarže
DocType: Marketplace Settings,Hub Seller Name,Jméno prodejce hubu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Employee Advances,Zaměstnanecké zálohy
DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Povolit více Prodejní objednávky proti Zákazníka Objednávky
DocType: Student Group Instructor,Student Group Instructor,Instruktor skupiny studentů
DocType: Grant Application,Assessment  Mark (Out of 10),Známka hodnocení (z 10)
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Mobile No,Guardian2 Mobile Žádné
apps/erpnext/erpnext/setup/doctype/company/company.py,Main,Hlavní
DocType: GSTR 3B Report,July,červenec
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 {1} položka. Můžete je povolit jako {1} položku z jeho položky Master
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant,Varianta
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: Naming Series,Set prefix for numbering series on your transactions,Nastavit prefix pro číslování série na vašich transakcí
DocType: Employee Attendance Tool,Employees HTML,zaměstnanci HTML
apps/erpnext/erpnext/stock/doctype/item/item.py,Default BOM ({0}) must be active for this item or its template,Výchozí BOM ({0}) musí být aktivní pro tuto položku nebo jeho šablony
DocType: Employee,Leave Encashed?,Dovolená proplacena?
apps/erpnext/erpnext/regional/report/datev/datev.py,<b>From Date</b> is a mandatory filter.,<b>Od data</b> je povinný filtr.
DocType: Email Digest,Annual Expenses,roční náklady
DocType: Item,Variants,Varianty
DocType: SMS Center,Send To,Odeslat
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,There is not enough leave balance for Leave Type {0},Není dost bilance dovolenou na vstup typ {0}
DocType: Payment Reconciliation Payment,Allocated amount,Přidělené sumy
DocType: Sales Team,Contribution to Net Total,Příspěvek na celkových čistých
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Manufactured,Vyrobeno
DocType: Sales Invoice Item,Customer's Item Code,Zákazníka Kód položky
DocType: Stock Reconciliation,Stock Reconciliation,Reklamní Odsouhlasení
DocType: Territory,Territory Name,Území Name
DocType: Email Digest,Purchase Orders to Receive,Objednávky k nákupu
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work-in-Progress Warehouse is required before Submit,Work-in-Progress sklad je zapotřebí před Odeslat
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: Bank Statement Transaction Settings Item,Mapped Data,Mapované údaje
DocType: Purchase Order Item,Warehouse and Reference,Sklad a reference
DocType: Payroll Period Date,Payroll Period Date,Den mzdy
DocType: Supplier,Statutory info and other general information about your Supplier,Statutární info a další obecné informace o váš dodavatel
DocType: Item,Serial Nos and Batches,Sériové čísla a dávky
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Student Group Strength,Síla skupiny studentů
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Against Journal Entry {0} does not have any unmatched {1} entry,Proti věstníku Vstup {0} nemá bezkonkurenční {1} vstupu
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ánovaly {1} volná místa s rozpočtem {2}. \ Personální plán {0} by měl přidělit více volných pracovních míst a rozpočet na {3}, než bylo plánováno pro své dceřiné společnosti"
apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py,Training Events,Školení
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Duplicate Serial No entered for Item {0},Duplicitní Pořadové číslo vstoupil k bodu {0}
DocType: Quality Review Objective,Quality Review Objective,Cíl kontroly kvality
apps/erpnext/erpnext/config/crm.py,Track Leads by Lead Source.,Track Leads by Lead Source.
DocType: Shipping Rule Condition,A condition for a Shipping Rule,Podmínka pro pravidla dopravy
DocType: Sales Invoice,e-Way Bill No.,e-Way Bill No.
DocType: GSTR 3B Report,JSON Output,Výstup JSON
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please enter ,Prosím Vstupte
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Maintenance Log,Protokol údržby
apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.py,Please set filter based on Item or Warehouse,Prosím nastavit filtr na základě výtisku nebo ve skladu
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Čistá hmotnost tohoto balíčku. (Automaticky vypočítá jako součet čisté váhy položek)
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Discount amount cannot be greater than 100%,Výše slevy nesmí být vyšší než 100%
DocType: Opportunity,CRM-OPP-.YYYY.-,CRM-OPP-.YYYY.-
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","Počet nových nákladových center, bude zahrnuto do názvu nákladového střediska jako předpona"
DocType: Sales Order,To Deliver and Bill,Dodat a Bill
DocType: Student Group,Instructors,instruktoři
DocType: GL Entry,Credit Amount in Account Currency,Kreditní Částka v měně účtu
DocType: Stock Entry,Receive at Warehouse,Přijmout ve skladu
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Accounting Dimension <b>{0}</b> is required for 'Profit and Loss' account {1}.,Účetní dimenze <b>{0}</b> je vyžadována pro účet &#39;Zisk a ztráta&#39; {1}.
DocType: Communication Medium,Voice,Hlas
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} must be submitted,BOM {0} musí být předloženy
apps/erpnext/erpnext/config/accounts.py,Share Management,Správa sdílených položek
DocType: Authorization Control,Authorization Control,Autorizace Control
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Řádek # {0}: Zamítnutí Warehouse je povinná proti zamítnuté bodu {1}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Received Stock Entries,Přijaté položky zásob
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Payment,Platba
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}.","Warehouse {0} není propojen s žádným účtem, uveďte prosím účet v záznamu skladu nebo nastavte výchozí inventární účet ve firmě {1}."
apps/erpnext/erpnext/utilities/activation.py,Manage your orders,Správa objednávek
DocType: Work Order Operation,Actual Time and Cost,Skutečný Čas a Náklady
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},Materiál Žádost maximálně {0} lze k bodu {1} na odběratele {2}
DocType: Amazon MWS Settings,DE,DE
DocType: Crop,Crop Spacing,Rozdělení oříznutí
DocType: Budget,Action if Annual Budget Exceeded on PO,Opatření v případě překročení ročního rozpočtu na OP
DocType: Issue,Service Level,Úroveň služby
DocType: Student Leave Application,Student Leave Application,Student nechat aplikaci
DocType: Item,Will also apply for variants,Bude platit i pro varianty
apps/erpnext/erpnext/assets/doctype/asset/asset.py,"Asset cannot be cancelled, as it is already {0}","Asset nelze zrušit, protože je již {0}"
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} on Half day on {1},Zaměstnanec {0} na půl dne na {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Total working hours should not be greater than max working hours {0},Celkem pracovní doba by neměla být větší než maximální pracovní doby {0}
apps/erpnext/erpnext/templates/pages/task_info.html,On,Kdy
apps/erpnext/erpnext/config/buying.py,Bundle items at time of sale.,Bundle položky v okamžiku prodeje.
DocType: Products Settings,Product Page,Stránka produktu
DocType: Delivery Settings,Dispatch Settings,Nastavení odesílání
DocType: Material Request Plan Item,Actual Qty,Skutečné Množství
DocType: Sales Invoice Item,References,Reference
DocType: Quality Inspection Reading,Reading 10,Čtení 10
DocType: Item,Barcodes,Čárové kódy
DocType: Hub Tracked Item,Hub Node,Hub Node
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. Prosím, opravu a zkuste to znovu."
DocType: Tally Migration,Is Master Data Imported,Jsou importována kmenová data
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Associate,Spolupracovník
DocType: Asset Movement,Asset Movement,Asset Movement
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0} must be submitted,Objednávka práce {0} musí být odeslána
apps/erpnext/erpnext/accounts/page/pos/pos.js,New Cart,New košík
DocType: Taxable Salary Slab,From Amount,Z částky
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Item {0} is not a serialized Item,Položka {0} není serializovat položky
DocType: Leave Type,Encashment,Zapouzdření
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.js,Select a company,Vyberte společnost
DocType: Delivery Settings,Delivery Settings,Nastavení doručení
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Fetch Data,Načíst data
apps/erpnext/erpnext/hr/doctype/leave_policy/leave_policy.py,Maximum leave allowed in the leave type {0} is {1},Maximální povolená dovolená v typu dovolené {0} je {1}
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Publish 1 Item,Publikovat 1 položku
DocType: SMS Center,Create Receiver List,Vytvořit přijímače seznam
DocType: Student Applicant,LMS Only,Pouze LMS
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available-for-use Date should be after purchase date,Data k dispozici k použití by měla být po datu nákupu
DocType: Vehicle,Wheels,kola
DocType: Packing Slip,To Package No.,Balit No.
DocType: Patient Relation,Family,Rodina
DocType: Invoice Discounting,Invoice Discounting,Diskontování faktur
DocType: Sales Invoice Item,Deferred Revenue Account,Účet odloženého výnosu
DocType: Production Plan,Material Requests,materiál Žádosti
DocType: Warranty Claim,Issue Date,Datum vydání
DocType: Activity Cost,Activity Cost,Náklady Aktivita
apps/erpnext/erpnext/hr/doctype/attendance/attendance_list.js,Unmarked Attendance for days,Neoznačená účast na několik dní
DocType: Sales Invoice Timesheet,Timesheet Detail,časového rozvrhu Detail
DocType: Purchase Receipt Item Supplied,Consumed Qty,Spotřeba Množství
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Telecommunications,Telekomunikace
apps/erpnext/erpnext/setup/doctype/company/test_company.py,No Account matched these filters: {},Žádný účet neodpovídal těmto filtrům: {}
apps/erpnext/erpnext/accounts/party.py,Billing currency must be equal to either default company's currency or party account currency,Měna fakturace se musí rovnat buď měně výchozí měny nebo měně stran účtu
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 návrhu)"
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,Closing Balance,Konečný zůstatek
DocType: Soil Texture,Loam,Hlína
apps/erpnext/erpnext/controllers/accounts_controller.py,Row {0}: Due Date cannot be before posting date,Řádek {0}: K datu splatnosti nemůže být datum odeslání
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Quantity for Item {0} must be less than {1},Množství k bodu {0} musí být menší než {1}
,Sales Invoice Trends,Prodejní faktury Trendy
DocType: Leave Application,Apply / Approve Leaves,Použít / Schválit listy
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,For,Pro
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',"Se může vztahovat řádku, pouze pokud typ poplatku je ""On předchozí řady Částka"" nebo ""předchozí řady Total"""
DocType: Sales Order Item,Delivery Warehouse,Sklad pro příjem
DocType: Leave Type,Earned Leave Frequency,Dosažená frekvence dovolené
apps/erpnext/erpnext/config/accounts.py,Tree of financial Cost Centers.,Strom Nákl.střediska finančních.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Sub Type,Sub Type
DocType: Serial No,Delivery Document No,Dodávka dokument č
DocType: Sales Order Item,Ensure Delivery Based on Produced Serial No,Zajistěte dodávku na základě vyrobeného sériového čísla
DocType: Vital Signs,Furry,Srstnatý
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Prosím nastavte &quot;/ ZTRÁTY zisk z aktiv odstraňováním&quot; ve firmě {0}
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Add to Featured Item,Přidat k vybrané položce
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Položka získaná z dodacího listu
DocType: Serial No,Creation Date,Datum vytvoření
DocType: GSTR 3B Report,November,listopad
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,"Selling must be checked, if Applicable For is selected as {0}","Prodej musí být zkontrolováno, v případě potřeby pro vybrán jako {0}"
DocType: Production Plan Material Request,Material Request Date,Materiál Request Date
DocType: Purchase Order Item,Supplier Quotation Item,Dodavatel Nabídka Položka
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Material Consumption is not set in Manufacturing Settings.,Spotřeba materiálu není nastavena v nastavení výroby.
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,View all issues from {0},Zobrazit všechna čísla od {0}
DocType: Quality Inspection,MAT-QA-.YYYY.-,MAT-QA-.YYYY.-
DocType: Quality Meeting Table,Quality Meeting Table,Tabulka setkání kvality
apps/erpnext/erpnext/templates/pages/help.html,Visit the forums,Navštivte fóra
DocType: Student,Student Mobile Number,Student Číslo mobilního telefonu
DocType: Item,Has Variants,Má varianty
DocType: Employee Benefit Claim,Claim Benefit For,Nárok na dávku pro
apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Aktualizace odpovědi
apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Již jste vybrané položky z {0} {1}
DocType: Monthly Distribution,Name of the Monthly Distribution,Název měsíční výplatou
DocType: Quality Procedure Process,Quality Procedure Process,Proces řízení kvality
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Batch ID is mandatory,Číslo šarže je povinné
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.js,Please select Customer first,Nejprve prosím vyberte Zákazníka
DocType: Sales Person,Parent Sales Person,Parent obchodník
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, nejsou opožděné"
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í
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,No views yet,Zatím žádné pohledy
DocType: Project,Collect Progress,Sbírat Progress
DocType: Delivery Note,MAT-DN-.YYYY.-,MAT-DN-.RRRR.-
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Select the program first,Nejprve vyberte program
DocType: Patient Appointment,Patient Age,Věk pacienta
apps/erpnext/erpnext/config/help.py,Managing Projects,Správa projektů
DocType: Quiz,Latest Highest Score,Nejnovější nejvyšší skóre
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: Supplier,Supplier of Goods or Services.,Dodavatel zboží nebo služeb.
DocType: Budget,Fiscal Year,Fiskální rok
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Only users with the {0} role can create backdated leave applications,Pouze uživatelé s rolí {0} mohou vytvářet zastaralé dovolenky
DocType: Asset Maintenance Log,Planned,Plánováno
apps/erpnext/erpnext/hr/utils.py,A {0} exists between {1} and {2} (,A {0} existuje mezi {1} a {2} (
DocType: Vehicle Log,Fuel Price,palivo Cena
DocType: BOM Explosion Item,Include Item In Manufacturing,Zahrnout položku do výroby
DocType: Item,Auto Create Assets on Purchase,Automatické vytváření aktiv při nákupu
DocType: Bank Guarantee,Margin Money,Margin Money
DocType: Budget,Budget,Rozpočet
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Set Open,Nastavit Otevřít
apps/erpnext/erpnext/stock/doctype/item/item.py,Fixed Asset Item must be a non-stock item.,Fixed Asset položky musí být non-skladová položka.
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 proti {0}, protože to není výnos nebo náklad účet"
DocType: Quality Review Table,Achieved,Dosažená
DocType: Student Admission,Application Form Route,Přihláška Trasa
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,End Date of Agreement can't be less than today.,Datum ukončení dohody nemůže být kratší než dnes.
apps/erpnext/erpnext/public/js/hub/components/CommentInput.vue,Ctrl + Enter to submit,Ctrl + Enter k odeslání
DocType: Healthcare Settings,Patient Encounters in valid days,Setkání pacientů v platných dnech
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leave Type {0} cannot be allocated since it is leave without pay,"Nechat Typ {0} nemůže být přidělena, neboť se odejít bez zaplacení"
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},Row {0}: Přidělená částka {1} musí být menší než nebo se rovná fakturovat dlužné částky {2}
DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,"Ve slovech budou viditelné, jakmile uložíte prodejní faktury."
DocType: Lead,Follow Up,Následovat
apps/erpnext/erpnext/accounts/report/financial_statements.py,Cost Center: {0} does not exist,Nákladové středisko: {0} neexistuje
DocType: Item,Is Sales Item,Je Sales Item
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,Item Group Tree,Strom skupin položek
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í nastavení pro Serial č. Zkontrolujte, zda master položku"
DocType: Maintenance Visit,Maintenance Time,Údržba Time
,Amount to Deliver,"Částka, která má dodávat"
DocType: Asset,Insurance Start Date,Datum zahájení pojištění
DocType: Salary Component,Flexible Benefits,Flexibilní výhody
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ínovaný Datum zahájení nemůže být dříve než v roce datum zahájení akademického roku, ke kterému termín je spojena (akademický rok {}). Opravte data a zkuste to znovu."
apps/erpnext/erpnext/setup/doctype/company/company.js,There were errors.,Byly tam chyby.
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Pin Code,PIN kód
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup defaults,Výchozí nastavení se nezdařilo
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 {1} mezi {2} a {3}:
DocType: Guardian,Guardian Interests,Guardian Zájmy
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Name / Number,Aktualizovat název účtu / číslo
DocType: Naming Series,Current Value,Current Value
apps/erpnext/erpnext/controllers/accounts_controller.py,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Několik fiskálních let existují pro data {0}. Prosím nastavte společnost ve fiskálním roce
DocType: Education Settings,Instructor Records to be created by,"Záznamy instruktorů, které mají být vytvořeny"
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,{0} created,{0} vytvořil
DocType: GST Account,GST Account,Účet GST
DocType: Delivery Note Item,Against Sales Order,Proti přijaté objednávce
,Serial No Status,Serial No Status
DocType: Payment Entry Reference,Outstanding,Vynikající
DocType: Supplier,Warn POs,Varujte PO
,Daily Timesheet Summary,Denní časový rozvrh Souhrn
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,"Row {0}: To set {1} periodicity, difference between from and to date \
						must be greater than or equal to {2}","Řádek {0}: Pro nastavení {1} periodicita, rozdíl mezi z a aktuální \
 musí být větší než nebo rovno {2}"
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,This is based on stock movement. See {0} for details,To je založeno na akciovém pohybu. Viz {0} Podrobnosti
DocType: Pricing Rule,Selling,Prodej
DocType: Payment Entry,Payment Order Status,Stav platebního příkazu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} deducted against {2},Množství {0} {1} odečíst proti {2}
DocType: Sales Person,Name and Employee ID,Jméno a ID zaměstnance
DocType: Promotional Scheme,Promotional Scheme Product Discount,Sleva produktu na propagační schéma
DocType: Website Item Group,Website Item Group,Website Item Group
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,Žádný výplatní list nebyl předložen za výše uvedené kritéria NEBO platový výpis již předložen
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Duties and Taxes,Odvody a daně
DocType: Projects Settings,Projects Settings,Nastavení projektů
DocType: Purchase Receipt Item,Batch No!,Dávka č.!
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please enter Reference date,"Prosím, zadejte Referenční den"
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} platební položky nelze filtrovat přes {1}
DocType: Item Website Specification,Table for Item that will be shown in Web Site,"Tabulka k bodu, který se zobrazí na webových stránkách"
DocType: Purchase Order Item Supplied,Supplied Qty,Dodávané Množství
DocType: Clinical Procedure,HLC-CPR-.YYYY.-,HLC-CPR-.YYYY.-
DocType: Purchase Order Item,Material Request Item,Materiál Žádost o bod
apps/erpnext/erpnext/config/buying.py,Tree of Item Groups.,Strom skupiny položek.
DocType: Production Plan,Total Produced Qty,Celkový vyrobený počet
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,No reviews yet,Zatím žádné recenze
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 číslo řádku větší nebo rovnou aktuální číslo řádku pro tento typ Charge
DocType: Asset,Sold,Prodáno
,Item-wise Purchase History,Item-moudrý Historie nákupů
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Prosím, klikněte na ""Generovat Schedule"", aby přinesla Pořadové číslo přidán k bodu {0}"
DocType: Account,Frozen,Zmražený
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Vehicle Type,Typ vozidla
DocType: Sales Invoice Payment,Base Amount (Company Currency),Základna Částka (Company měna)
DocType: Purchase Invoice,Registered Regular,Registrováno pravidelně
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Raw Materials,Suroviny
DocType: Payment Reconciliation Payment,Reference Row,referenční Row
DocType: Installation Note,Installation Time,Instalace Time
DocType: Sales Invoice,Accounting Details,Účetní detaily
DocType: Shopify Settings,status html,status html
apps/erpnext/erpnext/setup/doctype/company/company.js,Delete all the Transactions for this Company,Odstraňte všechny transakce pro tuto společnost
DocType: Designation,Required Skills,Požadované dovednosti
DocType: Inpatient Record,O Positive,O pozitivní
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Investments,Investice
DocType: Issue,Resolution Details,Rozlišení Podrobnosti
DocType: Leave Ledger Entry,Transaction Type,typ transakce
DocType: Item Quality Inspection Parameter,Acceptance Criteria,Kritéria přijetí
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Material Requests in the above table,"Prosím, zadejte Žádosti materiál ve výše uvedené tabulce"
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments available for Journal Entry,K dispozici nejsou žádné splátky pro zápis do deníku
DocType: Hub Tracked Item,Image List,Seznam obrázků
DocType: Item Attribute,Attribute Name,Název atributu
DocType: Subscription,Generate Invoice At Beginning Of Period,Generovat fakturu na začátku období
DocType: BOM,Show In Website,Show pro webové stránky
DocType: Loan Application,Total Payable Amount,Celková částka Splatné
DocType: Task,Expected Time (in hours),Předpokládaná doba (v hodinách)
DocType: Item Reorder,Check in (group),Check in (skupina)
DocType: Soil Texture,Silt,Silt
,Qty to Order,Množství k objednávce
DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Účet hlavu pod závazkem nebo vlastním kapitálem, ve kterém budou Zisk / ztráta rezervovat"
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ší rozpočtový záznam &#39;{0}&#39; již existuje proti {1} &#39;{2}&#39; a účet &#39;{3}&#39; za fiskální rok {4}
apps/erpnext/erpnext/config/projects.py,Gantt chart of all tasks.,Ganttův diagram všech zadaných úkolů.
DocType: Opportunity,Mins to First Response,Min First Response
DocType: Pricing Rule,Margin Type,Typ Marže
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,{0} hours,{0} hodin
DocType: Course,Default Grading Scale,Výchozí Klasifikační stupnice
DocType: Appraisal,For Employee Name,Pro jméno zaměstnance
DocType: Holiday List,Clear Table,Clear Table
DocType: Woocommerce Settings,Tax Account,Daňový účet
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Available slots,Dostupné sloty
DocType: C-Form Invoice Detail,Invoice No,Faktura č
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Make Payment,Zaplatit
DocType: Room,Room Name,Room Jméno
DocType: Prescription Duration,Prescription Duration,Doba trvání předpisu
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}","Nechte nelze aplikovat / zrušena před {0}, protože rovnováha dovolené již bylo carry-předávány v budoucí přidělení dovolenou záznamu {1}"
DocType: Activity Cost,Costing Rate,Kalkulace Rate
apps/erpnext/erpnext/config/selling.py,Customer Addresses And Contacts,Adresy zákazníků a kontakty
DocType: Homepage Section,Section Cards,Karty sekce
,Campaign Efficiency,Efektivita kampaně
DocType: Discussion,Discussion,Diskuse
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Sales Order Submission,Při zadávání prodejní objednávky
DocType: Bank Transaction,Transaction ID,ID transakce
DocType: Payroll Entry,Deduct Tax For Unsubmitted Tax Exemption Proof,Odpočet daně za nezdařené osvobození od daně
DocType: Volunteer,Anytime,Kdykoliv
DocType: Bank Account,Bank Account No,Bankovní účet č
DocType: Employee Tax Exemption Proof Submission,Employee Tax Exemption Proof Submission,Osvobození od daně z osvobození zaměstnanců
DocType: Patient,Surgical History,Chirurgická historie
DocType: Bank Statement Settings Item,Mapped Header,Mapované záhlaví
DocType: Employee,Resignation Letter Date,Rezignace Letter Datum
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Pricing Rules are further filtered based on quantity.,Pravidla pro stanovení sazeb jsou dále filtrována na základě množství.
DocType: Woocommerce Settings,"This warehouse will be used to create Sales Orders. The fallback warehouse is ""Stores"".",Tento sklad bude použit k vytvoření prodejních objednávek. Rezervní sklad je „Obchody“.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Please set the Date Of Joining for employee {0},Nastavte prosím datum zapojení pro zaměstnance {0}
DocType: Inpatient Record,Discharge,Vybít
DocType: Task,Total Billing Amount (via Time Sheet),Celková částka Billing (přes Time Sheet)
apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js,Create Fee Schedule,Vytvořte plán poplatků
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customer Revenue,Repeat Customer Příjmy
DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Nastavte prosím Pojmenovací systém instruktorů v sekci Vzdělávání&gt; Nastavení vzdělávání
DocType: Quiz,Enter 0 to waive limit,"Chcete-li se vzdát limitu, zadejte 0"
DocType: Bank Statement Settings,Mapped Items,Mapované položky
DocType: Amazon MWS Settings,IT,TO
DocType: Chapter,Chapter,Kapitola
DocType: Appointment Booking Settings,"Leave blank for home.
This is relative to site URL, for example ""about"" will redirect to ""https://yoursitename.com/about""","Nechte prázdné pro domov. Toto je relativní k adrese URL webu, například „about“ přesměruje na „https://yoursitename.com/about“"
,Fixed Asset Register,Registr dlouhodobých aktiv
DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,Výchozí účet bude automaticky aktualizován v POS faktuře při výběru tohoto režimu.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select BOM and Qty for Production,Vyberte BOM a Množství pro výrobu
DocType: Asset,Depreciation Schedule,Plán odpisy
DocType: Bank Reconciliation Detail,Against Account,Proti účet
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Half Day Date should be between From Date and To Date,Half Day Date by měla být v rozmezí Datum od a do dnešního dne
DocType: Maintenance Schedule Detail,Actual Date,Skutečné datum
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please set the Default Cost Center in {0} company.,Nastavte výchozí cenové centrum ve společnosti {0}.
apps/erpnext/erpnext/projects/doctype/project/project.py,Daily Project Summary for {0},Souhrn denního projektu za {0}
DocType: Item,Has Batch No,Má číslo šarže
apps/erpnext/erpnext/public/js/utils.js,Annual Billing: {0},Roční Zúčtování: {0}
DocType: Shopify Webhook Detail,Shopify Webhook Detail,Nakupujte podrobnosti o Webhooku
apps/erpnext/erpnext/config/accounts.py,Goods and Services Tax (GST India),Daň z zboží a služeb (GST India)
DocType: Delivery Note,Excise Page Number,Spotřební Číslo stránky
DocType: Asset,Purchase Date,Datum nákupu
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Could not generate Secret,Nelze generovat tajemství
DocType: Volunteer,Volunteer Type,Typ dobrovolníka
DocType: Payment Request,ACC-PRQ-.YYYY.-,ACC-PRQ-.YYYY.-
DocType: Shift Assignment,Shift Type,Typ posunu
DocType: Student,Personal Details,Osobní data
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,Export E-Invoices,Export elektronických faktur
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set 'Asset Depreciation Cost Center' in Company {0},Prosím nastavte &quot;odpisy majetku nákladové středisko&quot; ve firmě {0}
,Maintenance Schedules,Plány údržby
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,"There are not enough asset created or linked to {0}. \
						Please create or link {1} Assets with respective document.",Není vytvořeno dostatečné množství aktiv nebo propojeno s {0}. \ Prosím vytvořte nebo propojte {1} Aktiva s příslušným dokumentem.
DocType: Pricing Rule,Apply Rule On Brand,Použít pravidlo na značku
DocType: Task,Actual End Date (via Time Sheet),Skutečné datum ukončení (přes Time Sheet)
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 její závislá úloha {1} není uzavřena."
DocType: Soil Texture,Soil Type,Typ půdy
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} against {2} {3},Množství {0} {1} na {2} {3}
,Quotation Trends,Uvozovky Trendy
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Item Group not mentioned in item master for item {0},Položka Group není uvedeno v položce mistra na položku {0}
DocType: GoCardless Mandate,GoCardless Mandate,GoCardless Mandate
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To account must be a Receivable account,"Debetní Chcete-li v úvahu, musí být pohledávka účet"
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Select finance book for the item {0} at row {1},Vyberte finanční knihu pro položku {0} v řádku {1}
DocType: Shipping Rule,Shipping Amount,Částka - doprava
DocType: Supplier Scorecard Period,Period Score,Skóre období
apps/erpnext/erpnext/public/js/event.js,Add Customers,Přidat zákazníky
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Pending Amount,Čeká Částka
DocType: Lab Test Template,Special,Speciální
DocType: Loyalty Program,Conversion Factor,Konverzní faktor
DocType: Purchase Order,Delivered,Dodává
,Vehicle Expenses,Náklady pro auta
DocType: Healthcare Settings,Create Lab Test(s) on Sales Invoice Submit,Vytvořte laboratorní test (y) na faktuře Odeslání faktury
DocType: Serial No,Invoice Details,Podrobnosti faktury
apps/erpnext/erpnext/regional/india/utils.py,Salary Structure must be submitted before submission of Tax Ememption Declaration,Struktura mezd musí být předložena před podáním daňového přiznání
DocType: Grant Application,Show on Website,Zobrazit na webu
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Start on,Začněte dál
DocType: Hub Tracked Item,Hub Category,Kategorie Hubu
DocType: Purchase Invoice,SEZ,SEZ
DocType: Purchase Receipt,Vehicle Number,Číslo vozidla
DocType: Loan,Loan Amount,Částka půjčky
DocType: Student Report Generation Tool,Add Letterhead,Přidat hlavičkový papír
DocType: Program Enrollment,Self-Driving Vehicle,Samohybné vozidlo
DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Dodávka tabulky dodavatelů
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Row {0}: Bill of Materials not found for the Item {1},Řádek {0}: Kusovník nebyl nalezen pro výtisku {1}
DocType: Contract Fulfilment Checklist,Requirement,Požadavek
DocType: Journal Entry,Accounts Receivable,Pohledávky
DocType: Quality Goal,Objectives,Cíle
DocType: HR Settings,Role Allowed to Create Backdated Leave Application,Role povolená k vytvoření aplikace s okamžitou platností
DocType: Travel Itinerary,Meal Preference,Předvolba jídla
,Supplier-Wise Sales Analytics,Dodavatel-Wise Prodej Analytics
apps/erpnext/erpnext/accounts/doctype/subscription_plan/subscription_plan.py,Billing Interval Count cannot be less than 1,Fakturační interval nesmí být menší než 1
DocType: Purchase Invoice,Availed ITC Central Tax,Využil centrální daň ITC
DocType: Sales Invoice,Company Address Name,Název adresy společnosti
DocType: Work Order,Use Multi-Level BOM,Použijte Multi-Level BOM
DocType: Bank Reconciliation,Include Reconciled Entries,Zahrnout odsouhlasené zápisy
apps/erpnext/erpnext/accounts/doctype/bank_transaction/bank_transaction.py,The total allocated amount ({0}) is greated than the paid amount ({1}).,Celková přidělená částka ({0}) je převedena na zaplacenou částku ({1}).
DocType: Landed Cost Voucher,Distribute Charges Based On,Distribuovat poplatků na základě
DocType: Projects Settings,Timesheets,Timesheets
DocType: HR Settings,HR Settings,Nastavení HR
apps/erpnext/erpnext/config/accounts.py,Accounting Masters,Účetnictví Masters
DocType: Salary Slip,net pay info,Čistý plat info
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CESS Amount,Částka CESS
DocType: Woocommerce Settings,Enable Sync,Povolit synchronizaci
DocType: Tax Withholding Rate,Single Transaction Threshold,Jednoduchá transakční prahová hodnota
DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Tato hodnota je aktualizována v seznamu výchozích prodejních cen.
apps/erpnext/erpnext/templates/pages/cart.html,Your cart is Empty,Tvůj vozík je prázdný
DocType: Email Digest,New Expenses,Nové výdaje
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Cannot Optimize Route as Driver Address is Missing.,"Nelze optimalizovat trasu, protože chybí adresa ovladače."
DocType: Shareholder,Shareholder,Akcionář
DocType: Purchase Invoice,Additional Discount Amount,Dodatečná sleva Částka
DocType: Cash Flow Mapper,Position,Pozice
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Get Items from Prescriptions,Získejte položky z předpisu
DocType: Patient,Patient Details,Podrobnosti pacienta
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Nature Of Supplies,Povaha spotřebního materiálu
DocType: Inpatient Record,B Positive,B Pozitivní
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í přínos zaměstnance {0} přesahuje {1} součtem {2} předchozí požadované částky
apps/erpnext/erpnext/buying/report/subcontracted_raw_materials_to_be_transferred/subcontracted_raw_materials_to_be_transferred.py,Transferred Quantity,Převedené množství
DocType: Leave Block List Allow,Leave Block List Allow,Nechte Block List Povolit
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbr can not be blank or space,Zkratka nemůže být prázdný znak nebo mezera
DocType: Patient Medical Record,Patient Medical Record,Záznam pacienta
DocType: Quality Meeting Agenda,Quality Meeting Agenda,Program jednání o kvalitě
apps/erpnext/erpnext/accounts/doctype/account/account.js,Group to Non-Group,Skupina na Non-Group
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Sports,Sportovní
DocType: Leave Control Panel,Employee (optional),Zaměstnanec (volitelné)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Material Request {0} submitted.,Žádost o materiál {0} byla odeslána.
DocType: Loan Type,Loan Name,půjčka Name
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Actual,Celkem Aktuální
DocType: Chart of Accounts Importer,Chart Preview,Náhled grafu
DocType: Attendance,Shift,Posun
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,Enter API key in Google Settings.,Zadejte klíč API v Nastavení Google.
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Create Journal Entry,Vytvořit zápis do deníku
DocType: Student Siblings,Student Siblings,Studentské Sourozenci
DocType: Subscription Plan Detail,Subscription Plan Detail,Detail plánu předplatného
DocType: Quality Objective,Unit,Jednotka
apps/erpnext/erpnext/stock/get_item_details.py,Please specify Company,"Uveďte prosím, firmu"
,Customer Acquisition and Loyalty,Zákazník Akvizice a loajality
DocType: Issue,Response By Variance,Reakce podle variace
DocType: Asset Maintenance Task,Maintenance Task,Úloha údrž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: Marketplace Settings,Marketplace Settings,Nastavení tržiště
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,"Sklad, kde se udržují zásoby odmítnutých položek"
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Publish {0} Items,Publikovat {0} položek
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 kurz {0} až {1} pro klíčový den {2}. Ručně vytvořte záznam o směnném kurzu
DocType: POS Profile,Price List,Ceník
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. Prosím aktualizujte svůj prohlížeč aby se změny projevily.
apps/erpnext/erpnext/projects/doctype/task/task.js,Expense Claims,Nákladové Pohledávky
DocType: Issue,Support,Podpora
DocType: Appointment,Scheduled Time,Naplánovaný čas
DocType: Employee Tax Exemption Declaration,Total Exemption Amount,Celková částka osvobození
DocType: Content Question,Question Link,Odkaz na dotaz
,BOM Search,Vyhledání kusovníku
DocType: Accounting Dimension Detail,Mandatory For Balance Sheet,Povinná pro rozvahu
DocType: Project,Total Consumed Material Cost  (via Stock Entry),Celkové náklady na spotřebu materiálu (přes vstup zboží)
DocType: Subscription,Subscription Period,Období předplatného
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js,To Date cannot be less than From Date,Datum k datu nemůže být menší než od data
,Delayed Order Report,Zpoždění objednávky
DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Publikujte &quot;na skladě&quot; nebo &quot;není na skladě&quot; na Hubu na základě skladových zásob dostupných v tomto skladu.
DocType: Vehicle,Fuel Type,Druh paliva
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,"Uveďte prosím měnu, ve společnosti"
DocType: Workstation,Wages per hour,Mzda za hodinu
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfigurovat {0}
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},Sklad bilance v dávce {0} se zhorší {1} k bodu {2} ve skladu {3}
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í materiál žádosti byly automaticky zvýšena na základě úrovni re-pořadí položky
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}
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í zaměstnance Datum {1}
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Create Payment Entries,Vytvořit platební záznamy
DocType: Supplier,Is Internal Supplier,Je interní dodavatel
DocType: Employee,Create User Permission,Vytvořit oprávnění uživatele
apps/erpnext/erpnext/projects/doctype/task/task.py,Task's {0} Start Date cannot be after Project's End Date.,Datum zahájení {0} úkolu nemůže být po datu ukončení projektu.
DocType: Employee Benefit Claim,Employee Benefit Claim,Požadavek na zaměstnanecké požitky
DocType: Healthcare Settings,Remind Before,Připomenout dříve
apps/erpnext/erpnext/buying/utils.py,UOM Conversion factor is required in row {0},UOM Konverzní faktor je nutné v řadě {0}
DocType: Production Plan Item,material_request_item,material_request_item
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}: Reference Document Type musí být jedním ze zakázky odběratele, prodejní faktury nebo Journal Entry"
DocType: Loyalty Program,1 Loyalty Points = How much base currency?,1 Věrnostní body = Kolik základní měny?
DocType: Salary Component,Deduction,Dedukce
DocType: Item,Retain Sample,Zachovat vzorek
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: From Time and To Time is mandatory.,Řádek {0}: From Time a na čas je povinná.
DocType: Stock Reconciliation Item,Amount Difference,výše Rozdíl
apps/erpnext/erpnext/public/js/hub/pages/Buying.vue,This page keeps track of items you want to buy from sellers.,"Tato stránka sleduje položky, které chcete koupit od prodejců."
apps/erpnext/erpnext/stock/get_item_details.py,Item Price added for {0} in Price List {1},Položka Cena přidán pro {0} v Ceníku {1}
DocType: Delivery Stop,Order Information,Informace o objednávce
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js,Please enter Employee Id of this sales person,"Prosím, zadejte ID zaměstnance z tohoto prodeje osoby"
DocType: Territory,Classification of Customers by region,Rozdělení zákazníků podle krajů
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,In Production,Ve výrobě
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Difference Amount must be zero,Rozdíl Částka musí být nula
DocType: Project,Gross Margin,Hrubá marže
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} applicable after {1} working days,{0} platí po {1} pracovních dnech
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Please enter Production Item first,"Prosím, zadejte první výrobní položku"
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Calculated Bank Statement balance,Vypočtená výpis z bankovního účtu zůstatek
DocType: Normal Test Template,Normal Test Template,Normální šablona testu
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,disabled user,zakázané uživatelské
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Quotation,Nabídka
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Cannot set a received RFQ to No Quote,Nelze nastavit přijatou RFQ na Žádnou nabídku
apps/erpnext/erpnext/regional/report/datev/datev.py,Please create <b>DATEV Settings</b> for Company <b>{}</b>.,Vytvořte prosím <b>nastavení DATEV</b> pro společnost <b>{}</b> .
DocType: Salary Slip,Total Deduction,Celkem Odpočet
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"
DocType: BOM,Transfer Material Against,Přeneste materiál proti
,Production Analytics,výrobní Analytics
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 proti tomuto pacientovi. Podrobnosti viz časová osa níže
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ýpůjčky a období výpůjčky jsou povinné pro uložení diskontování faktury
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Cost Updated,Náklady Aktualizováno
apps/erpnext/erpnext/regional/india/utils.py,Vehicle Type is required if Mode of Transport is Road,"Typ vozidla je vyžadován, pokud je způsob dopravy silniční"
DocType: Inpatient Record,Date of Birth,Datum narození
DocType: Quality Action,Resolutions,Usnesení
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Item {0} has already been returned,Bod {0} již byla vrácena
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. Veškeré účetní záznamy a další významné transakce jsou sledovány proti ** fiskální rok **.
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Dimension Filter,Filtr rozměrů
DocType: Opportunity,Customer / Lead Address,Zákazník / Lead Address
DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Nastavení tabulky dodavatelů
DocType: Customer Credit Limit,Customer Credit Limit,Úvěrový limit zákazníka
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Assessment Plan Name,Název plánu hodnocení
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Target Details,Podrobnosti o cíli
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"
DocType: Work Order Operation,Work Order Operation,Obsluha zakázky
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid SSL certificate on attachment {0},Varování: Neplatný certifikát SSL na přílohu {0}
apps/erpnext/erpnext/regional/italy/setup.py,Set this if the customer is a Public Administration company.,"Nastavte, pokud je zákazníkem společnost veřejné správy."
apps/erpnext/erpnext/utilities/activation.py,"Leads help you get business, add all your contacts and more as your leads","Vede vám pomohou podnikání, přidejte všechny své kontakty a více jak svých potenciálních zákazníků"
DocType: Work Order Operation,Actual Operation Time,Aktuální Provozní doba
DocType: Authorization Rule,Applicable To (User),Vztahující se na (Uživatel)
DocType: Purchase Taxes and Charges,Deduct,Odečíst
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Job Description,Popis Práce
DocType: Student Applicant,Applied,Aplikovaný
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 vnějších dodávkách a vnitřních dodávkách podléhajících zpětnému poplatku
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Re-open,Znovu otevřít
DocType: Sales Invoice Item,Qty as per Stock UOM,Množství podle Stock nerozpuštěných
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Name,Jméno Guardian2
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Root Company,Root Company
DocType: Attendance,Attendance Request,Žádost o účast
DocType: Purchase Invoice,02-Post Sale Discount,02 Sleva po prodeji
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Mějte přehled o prodejních kampaní. Mějte přehled o Leads, citace, prodejní objednávky atd z kampaně, aby zjistily, návratnost investic."
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,You can't redeem Loyalty Points having more value than the Grand Total.,"Nemůžete vykoupit věrnostní body, které mají větší hodnotu než celkový součet."
DocType: Department Approver,Approver,Schvalovatel
apps/erpnext/erpnext/selling/report/pending_so_items_for_purchase_request/pending_so_items_for_purchase_request.py,SO Qty,SO Množství
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field To Shareholder cannot be blank,Pole Akcionář nemůže být prázdné
DocType: Guardian,Work Address,pracovní adresa
DocType: Appraisal,Calculate Total Score,Vypočítat Celková skóre
DocType: Employee,Health Insurance,Zdravotní pojištění
DocType: Asset Repair,Manufacturing Manager,Výrobní ředitel
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} is under warranty upto {1},Pořadové číslo {0} je v záruce aľ {1}
DocType: Plant Analysis Criteria,Minimum Permissible Value,Minimální přípustná hodnota
apps/erpnext/erpnext/education/doctype/guardian/guardian.py,User {0} already exists,Uživatel {0} již existuje
apps/erpnext/erpnext/hooks.py,Shipments,Zásilky
DocType: Payment Entry,Total Allocated Amount (Company Currency),Celková alokovaná částka (Company měna)
DocType: Purchase Order Item,To be delivered to customer,Chcete-li být doručeno zákazníkovi
DocType: BOM,Scrap Material Cost,Šrot Material Cost
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to any Warehouse,"Pořadové číslo {0} nepatří do skladu,"
DocType: Grant Application,Email Notification Sent,Zasláno oznámení o e-mailu
DocType: Purchase Invoice,In Words (Company Currency),Slovy (měna společnosti)
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py,Company is manadatory for company account,Společnost je řídící na účet společnosti
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,"Item Code, warehouse, quantity are required on row","Kód položky, sklad, množství je nutné v řádku"
DocType: Bank Guarantee,Supplier,Dodavatel
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Get From,Získat Z
apps/erpnext/erpnext/hr/doctype/department/department.js,This is a root department and cannot be edited.,Toto je kořenové oddělení a nemůže být editováno.
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show Payment Details,Zobrazit údaje o platbě
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Duration in Days,Trvání ve dnech
DocType: C-Form,Quarter,Čtvrtletí
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Miscellaneous Expenses,Různé výdaje
DocType: Global Defaults,Default Company,Výchozí Company
DocType: Company,Transactions Annual History,Výroční historie transakcí
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Bank account '{0}' has been synchronized,Bankovní účet &#39;{0}&#39; byl synchronizován
apps/erpnext/erpnext/controllers/stock_controller.py,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Náklady nebo Rozdíl účet je povinné k bodu {0} jako budou mít dopad na celkovou hodnotu zásob
DocType: Bank,Bank Name,Název banky
DocType: DATEV Settings,Consultant ID,ID konzultanta
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Leave the field empty to make purchase orders for all suppliers,"Ponechte prázdné pole, abyste mohli objednávat všechny dodavatele"
DocType: Healthcare Practitioner,Inpatient Visit Charge Item,Poplatek za návštěvu pacienta
DocType: Vital Signs,Fluid,Tekutina
DocType: Leave Application,Total Leave Days,Celkový počet dnů dovolené
DocType: Email Digest,Note: Email will not be sent to disabled users,Poznámka: E-mail se nepodařilo odeslat pro zdravotně postižené uživatele
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Number of Interaction,Počet interakcí
DocType: GSTR 3B Report,February,Únor
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant Settings,Nastavení varianty položky
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Company...,Vyberte společnost ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} is mandatory for Item {1},{0} je povinná k položce {1}
DocType: Payroll Entry,Fortnightly,Čtrnáctidenní
DocType: Currency Exchange,From Currency,Od Měny
DocType: Vital Signs,Weight (In Kilogram),Hmotnost (v kilogramech)
DocType: Chapter,"chapters/chapter_name
leave blank automatically set after saving chapter.",kapitoly / název_kapitoly nechte prázdné pole automaticky po uložení kapitoly.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Please set GST Accounts in GST Settings,Nastavte prosím účet GST v Nastavení GST
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Type of Business,Typ podnikání
DocType: Sales Invoice,Consumer,Spotřebitel
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Prosím, vyberte alokovaná částka, typ faktury a číslo faktury v aspoň jedné řadě"
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of New Purchase,Náklady na nový nákup
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Sales Order required for Item {0},Prodejní objednávky potřebný k bodu {0}
DocType: Grant Application,Grant Description,Grant Popis
DocType: Purchase Invoice Item,Rate (Company Currency),Cena (Měna Společnosti)
DocType: Student Guardian,Others,Ostatní
DocType: Subscription,Discounts,Slevy
DocType: Bank Transaction,Unallocated Amount,nepřidělené Částka
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,Uveďte prosím platné objednávky a platí pro skutečné výdaje za rezervaci
apps/erpnext/erpnext/templates/includes/product_page.js,Cannot find a matching Item. Please select some other value for {0}.,Nelze najít odpovídající položku. Vyberte nějakou jinou hodnotu pro {0}.
DocType: POS Profile,Taxes and Charges,Daně a poplatky
DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Produkt nebo služba, která se Nakupuje, Prodává nebo Skladuje."
apps/erpnext/erpnext/hr/page/team_updates/team_updates.js,No more updates,Žádné další aktualizace
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 druh náboje jako ""On předchozí řady Částka"" nebo ""On předchozí řady Celkem"" pro první řadu"
DocType: Purchase Order,PUR-ORD-.YYYY.-,PUR-ORD-.YYYY.-
DocType: Appointment,Phone Number,Telefonní číslo
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py,This covers all scorecards tied to this Setup,"Toto pokrývá všechny body, které jsou spojeny s tímto nastavením"
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ítě Položka by neměla být produkt Bundle. Odeberte položku `{0}` a uložit
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Banking,Bankovnictví
apps/erpnext/erpnext/utilities/activation.py,Add Timesheets,Přidat Timesheets
DocType: Vehicle Service,Service Item,servis Položka
DocType: Bank Guarantee,Bank Guarantee,Bankovní záruka
DocType: Payment Request,Transaction Details,Detaily transakce
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule' to get schedule,"Prosím, klikněte na ""Generovat Schedule"", aby se plán"
DocType: Item,"Purchase, Replenishment Details","Podrobnosti o nákupu, doplnění"
DocType: Products Settings,Enable Field Filters,Povolit filtry pole
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
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot be Purchase Item also",„Položka poskytovaná zákazníkem“ nemůže být rovněž nákupem
DocType: Blanket Order Item,Ordered Quantity,Objednané množství
apps/erpnext/erpnext/public/js/setup_wizard.js,"e.g. ""Build tools for builders""","např ""Stavět nástroje pro stavitele """
DocType: Grading Scale,Grading Scale Intervals,Třídění dílků
DocType: Item Default,Purchase Defaults,Předvolby nákupu
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Automaticky se nepodařilo vytvořit kreditní poznámku, zrušte zaškrtnutí políčka Vyměnit kreditní poznámku a odešlete ji znovu"
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Added to Featured Items,Přidáno k doporučeným položkám
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py,Profit for the year,Zisk za rok
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í Vstup pro {2} mohou být prováděny pouze v měně: {3}
DocType: Fee Schedule,In Process,V procesu
DocType: Authorization Rule,Itemwise Discount,Itemwise Sleva
apps/erpnext/erpnext/config/accounts.py,Tree of financial accounts.,Strom finančních účtů.
DocType: Cash Flow Mapping,Cash Flow Mapping,Mapování peněžních toků
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Order {1},{0} proti Prodejní objednávce {1}
DocType: Account,Fixed Asset,Základní Jmění
DocType: Amazon MWS Settings,After Date,Po datu
apps/erpnext/erpnext/config/help.py,Serialized Inventory,Serialized Zásoby
,Department Analytics,Oddělení Analytics
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
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Generate Secret,Generovat tajemství
DocType: Question,Question,Otázka
DocType: Loan,Account Info,Informace o účtu
DocType: Activity Type,Default Billing Rate,Výchozí fakturace Rate
DocType: Fees,Include Payment,Zahrnout platbu
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,{0} Student Groups created.,{0} Studentské skupiny byly vytvořeny.
DocType: Sales Invoice,Total Billing Amount,Celková částka fakturace
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} jsou různé.
DocType: Bank Statement Transaction Entry,Receivable Account,Účet pohledávky
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é do data.
DocType: Employee Skill,Evaluation Date,Datum vyhodnocení
DocType: Quotation Item,Stock Balance,Reklamní Balance
apps/erpnext/erpnext/config/help.py,Sales Order to Payment,Prodejní objednávky na platby
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,CEO,výkonný ředitel
DocType: Purchase Invoice,With Payment of Tax,S platbou daně
DocType: Expense Claim Detail,Expense Claim Detail,Detail úhrady výdajů
apps/erpnext/erpnext/education/utils.py,You are not allowed to enroll for this course,Do tohoto kurzu se nemůžete přihlásit
DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,TRIPLICATE PRO DODAVATELE
DocType: Exchange Rate Revaluation Account,New Balance In Base Currency,Nový zůstatek v základní měně
DocType: Location,Is Container,Je kontejner
DocType: Crop Cycle,This will be day 1 of the crop cycle,Bude to první den cyklu plodin
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please select correct account,"Prosím, vyberte správný účet"
DocType: Salary Structure Assignment,Salary Structure Assignment,Přiřazení struktury platu
DocType: Purchase Invoice Item,Weight UOM,Hmotnostní jedn.
apps/erpnext/erpnext/config/accounts.py,List of available Shareholders with folio numbers,Seznam dostupných akcionářů s čísly folií
DocType: Salary Structure Employee,Salary Structure Employee,Plat struktura zaměstnanců
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Show Variant Attributes,Zobrazit atributy variantu
DocType: Student,Blood Group,Krevní Skupina
DocType: Purchase Invoice Item,Page Break,Zalomení stránky
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 této žádosti o platbu
DocType: Course,Course Name,Název kurzu
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py,No Tax Withholding data found for the current Fiscal Year.,Pro daný fiskální rok nebyly zjištěny žádné údaje o zadržení daně.
DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,"Uživatelé, kteří si vyhoví žádosti konkrétního zaměstnance volno"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Equipments,Kancelářské Vybavení
DocType: Pricing Rule,Qty,Množství
DocType: Fiscal Year,Companies,Společnosti
DocType: Supplier Scorecard,Scoring Setup,Nastavení bodování
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Electronics,Elektronika
DocType: Manufacturing Settings,Raw Materials Consumption,Spotřeba surovin
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Debit ({0}),Debet ({0})
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Zvýšit Materiál vyžádání při stock dosáhne úrovně re-order
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Full-time,Na plný úvazek
DocType: Payroll Entry,Employees,zaměstnanci
DocType: Question,Single Correct Answer,Jedna správná odpověď
DocType: C-Form,Received Date,Datum přijetí
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 prodeji daní a poplatků šablony, vyberte jednu a klikněte na tlačítko níže."
DocType: BOM Scrap Item,Basic Amount (Company Currency),Základní částka (Company měna)
DocType: Student,Guardians,Guardians
apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html,Payment Confirmation,Potvrzení platby
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Service Start and End Date is required for deferred accounting,Řádek # {0}: Pro odložené účtování je vyžadováno datum zahájení a ukončení služby
apps/erpnext/erpnext/regional/india/utils.py,Unsupported GST Category for e-Way Bill JSON generation,Nepodporovaná kategorie GST pro generaci e-Way Bill JSON
DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,"Ceny nebude zobrazeno, pokud Ceník není nastaven"
DocType: Material Request Item,Received Quantity,Přijaté množství
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: Stock Entry,Total Incoming Value,Celková hodnota Příchozí
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To is required,Debetní K je vyžadováno
DocType: Clinical Procedure,Inpatient Record,Ústavní záznam
apps/erpnext/erpnext/utilities/activation.py,"Timesheets help keep track of time, cost and billing for activites done by your team","Timesheets pomůže udržet přehled o času, nákladů a účtování pro aktivit hotový svého týmu"
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,Purchase Price List,Nákupní Ceník
DocType: Communication Medium Timeslot,Employee Group,Skupina zaměstnanců
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Date of Transaction,Datum transakce
apps/erpnext/erpnext/config/buying.py,Templates of supplier scorecard variables.,Šablony proměnných tabulky dodavatelů dodavatelů.
DocType: Job Offer Term,Offer Term,Nabídka Term
DocType: Asset,Quality Manager,Manažer kvality
DocType: Job Applicant,Job Opening,Job Zahájení
DocType: Employee,Default Shift,Výchozí posun
DocType: Payment Reconciliation,Payment Reconciliation,Platba Odsouhlasení
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Technology,Technologie
apps/erpnext/erpnext/public/js/utils.js,Total Unpaid: {0},Celkem nezaplaceno: {0}
DocType: BOM Website Operation,BOM Website Operation,BOM Webové stránky Provoz
DocType: Bank Statement Transaction Payment Item,outstanding_amount,nesplacená částka
DocType: Supplier Scorecard,Supplier Score,Skóre dodavatele
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Admission,Naplánovat přijetí
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Total Payment Request amount cannot be greater than {0} amount,Celková částka žádosti o platbu nesmí být vyšší než {0} částka
DocType: Tax Withholding Rate,Cumulative Transaction Threshold,Limit kumulativní transakce
DocType: Promotional Scheme Price Discount,Discount Type,Typ slevy
DocType: Purchase Invoice Item,Is Free Item,Je položka zdarma
DocType: Buying Settings,Percentage you are allowed to transfer more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to transfer 110 units.,"Procento, které můžete převést více oproti objednanému množství. Například: Pokud jste si objednali 100 kusů. a vaše povolenka je 10%, pak můžete převést 110 jednotek."
DocType: Supplier,Warn RFQs,Upozornění na RFQ
apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Explore,Prozkoumat
DocType: BOM,Conversion Rate,Míra konverze
apps/erpnext/erpnext/www/all-products/index.html,Product Search,Hledat výrobek
,Bank Remittance,Bankovní převody
DocType: Cashier Closing,To Time,Chcete-li čas
DocType: Invoice Discounting,Loan End Date,Datum ukončení úvěru
apps/erpnext/erpnext/hr/utils.py,) for {0},) pro {0}
DocType: Authorization Rule,Approving Role (above authorized value),Schválení role (nad oprávněné hodnoty)
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Employee is required while issuing Asset {0},Při vydávání aktiv {0} je vyžadován zaměstnanec
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Payable account,Připsat na účet musí být Splatnost účet
DocType: Loan,Total Amount Paid,Celková částka zaplacena
DocType: Asset,Insurance End Date,Datum ukončení pojištění
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Please select Student Admission which is mandatory for the paid student applicant,"Vyberte studentský vstup, který je povinný pro žáka placeného studenta"
DocType: Pick List,STO-PICK-.YYYY.-,STO-PICK-.RRRR.-
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,Budget List,Rozpočtový seznam
DocType: Campaign,Campaign Schedules,Rozvrhy kampaní
DocType: Job Card Time Log,Completed Qty,Dokončené Množství
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"For {0}, only debit accounts can be linked against another credit entry","Pro {0}, tak debetní účty mohou být spojeny proti jinému připsání"
DocType: Manufacturing Settings,Allow Overtime,Povolit Přesčasy
DocType: Training Event Employee,Training Event Employee,Vzdělávání zaměstnanců Event
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 zadat pro dávky {1} a položku {2}.
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Time Slots,Přidat časové úseky
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 požadované pro položky {1}. Poskytli jste {2}.
DocType: Stock Reconciliation Item,Current Valuation Rate,Aktuální ocenění
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: Training Event,Advance,Záloha
apps/erpnext/erpnext/config/integrations.py,GoCardless payment gateway settings,Nastavení platební brány GoCardless
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Exchange Gain/Loss,Exchange zisk / ztráta
DocType: Opportunity,Lost Reason,Důvod ztráty
DocType: Amazon MWS Settings,Enable Amazon,Povolit službu Amazon
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}
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Unable to find DocType {0},Nelze najít DocType {0}
apps/erpnext/erpnext/public/js/templates/address_list.html,New Address,Nová adresa
DocType: Quality Inspection,Sample Size,Velikost vzorku
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Please enter Receipt Document,"Prosím, zadejte převzetí dokumentu"
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/hr/report/employee_leave_balance_summary/employee_leave_balance_summary.py,Leaves Taken,Listy odebrány
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Please specify a valid 'From Case No.',"Uveďte prosím platný ""Od věci č '"
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 vyrobeny v rámci skupiny, ale položky mohou být provedeny proti non-skupin"
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é přidělené listy jsou dny více než maximální přidělení {0} typu dovolené pro zaměstnance {1} v daném období
DocType: Branch,Branch,Větev
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Other outward supplies(Nil rated,Exempted)","Ostatní pasivní dodávky (bez hodnocení, osvobozeno)"
DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
DocType: Delivery Trip,Fulfillment User,Uživatel splnění požadavků
apps/erpnext/erpnext/config/settings.py,Printing and Branding,Tisk a identita
DocType: Company,Total Monthly Sales,Celkový měsíční prodej
DocType: Course Activity,Enrollment,Zápis
DocType: Payment Request,Subscription Plans,Předplatné
DocType: Agriculture Analysis Criteria,Weather,Počasí
DocType: Bin,Actual Quantity,Skutečné Množství
DocType: Shipping Rule,example: Next Day Shipping,Příklad: Next Day Shipping
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} not found,Pořadové číslo {0} nebyl nalezen
DocType: Fee Schedule Program,Fee Schedule Program,Program rozpisu poplatků
DocType: Fee Schedule Program,Student Batch,Student Batch
DocType: Pricing Rule,Advanced Settings,Pokročilé nastavení
DocType: Supplier Scorecard Scoring Standing,Min Grade,Min Grade
DocType: Healthcare Service Unit Type,Healthcare Service Unit Type,Typ jednotky zdravotnické služby
DocType: Training Event Employee,Feedback Submitted,Zpětná vazba Vložené
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: Supplier Group,Parent Supplier Group,Nadřízená skupina dodavatelů
DocType: Email Digest,Purchase Orders to Bill,Objednávky k účtu
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Accumulated Values in Group Company,Akumulované hodnoty ve skupině společnosti
DocType: Leave Block List Date,Block Date,Block Datum
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 libovolnou platnou značku Bootstrap 4. Zobrazí se na vaší stránce s položkami.
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Outward taxable supplies(other than zero rated, nil rated and exempted","Dodávky zdanitelné v zahraničí (jiné než nulové, nulové a osvobozené od daně"
DocType: Crop,Crop,Oříznutí
DocType: Purchase Receipt,Supplier Delivery Note,Dodávka Dodavatelská poznámka
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Apply Now,Použít teď
DocType: Employee Tax Exemption Proof Submission Detail,Type of Proof,Typ důkazu
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html,Actual Qty {0} / Waiting Qty {1},Aktuální počet {0} / Čekací počet {1}
DocType: Purchase Invoice,E-commerce GSTIN,E-commerce GSTIN
DocType: Sales Order,Not Delivered,Ne vyhlášeno
,Bank Clearance Summary,Souhrn bankovního zúčtování
apps/erpnext/erpnext/config/settings.py,"Create and manage daily, weekly and monthly email digests.","Vytvářet a spravovat denní, týdenní a měsíční e-mailové digest."
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,Toto je založeno na transakcích proti této prodejní osobě. Podrobnosti viz časová osa níže
DocType: Appraisal Goal,Appraisal Goal,Posouzení Goal
DocType: Stock Reconciliation Item,Current Amount,Aktuální výše
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Buildings,budovy
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Leaves has been granted sucessfully,List byl úspěšně udělen
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Invoice,Nová faktura
DocType: Products Settings,Enable Attribute Filters,Povolit filtry atributů
DocType: Fee Schedule,Fee Structure,Struktura poplatků
DocType: Timesheet Detail,Costing Amount,Kalkulace Částka
DocType: Student Admission Program,Application Fee,poplatek za podání žádosti
DocType: Purchase Order Item,Against Blanket Order,Proti paušální objednávce
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Odeslat výplatní pásce
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Pozastaveno
apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Spalování musí mít alespoň jednu správnou možnost
apps/erpnext/erpnext/hooks.py,Purchase Orders,Objednávky
DocType: Account,Inter Company Account,Inter podnikový účet
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Dovoz hromadnou
DocType: Sales Partner,Address & Contacts,Adresa a kontakty
DocType: SMS Log,Sender Name,Jméno odesílatele
DocType: Vital Signs,Very Hyper,Velmi Hyper
DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Kritéria analýzy zemědělství
DocType: HR Settings,Leave Approval Notification Template,Ponechat šablonu oznámení o schválení
DocType: POS Profile,[Select],[Vybrat]
DocType: Staffing Plan Detail,Number Of Positions,Počet pozic
DocType: Vital Signs,Blood Pressure (diastolic),Krevní tlak (diastolický)
apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Vyberte prosím zákazníka.
DocType: SMS Log,Sent To,Odeslána
DocType: Agriculture Task,Holiday Management,Správa prázdnin
DocType: Payment Request,Make Sales Invoice,Proveďte prodejní faktuře
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Softwares,Programy
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Next Contact Date cannot be in the past,Následující Kontakt datum nemůže být v minulosti
DocType: Company,For Reference Only.,Pouze orientační.
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select Batch No,Vyberte číslo šarže
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Invalid {0}: {1},Neplatný {0}: {1}
,GSTR-1,GSTR-1
DocType: Fee Validity,Reference Inv,Odkaz Inv
DocType: Sales Invoice Advance,Advance Amount,Záloha ve výši
DocType: Manufacturing Settings,Capacity Planning,Plánování kapacit
DocType: Supplier Quotation,Rounding Adjustment (Company Currency,Úprava zaokrouhlení (měna společnosti
DocType: Asset,Policy number,Číslo politiky
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,'From Date' is required,"""Datum od"" je povinné"
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign to Employees,Přiřadit zaměstnancům
DocType: Bank Transaction,Reference Number,Referenční číslo
DocType: Employee,New Workplace,Nové pracoviště
DocType: Retention Bonus,Retention Bonus,Retenční bonus
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Material Consumption,Spotřeba materiálu
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Closed,Nastavit jako Zavřeno
apps/erpnext/erpnext/stock/get_item_details.py,No Item with Barcode {0},No Položka s čárovým kódem {0}
apps/erpnext/erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py,Asset Value Adjustment cannot be posted before Asset's purchase date <b>{0}</b>.,Úprava hodnoty aktiv nemůže být zaúčtována před datem nákupu aktiv <b>{0}</b> .
DocType: Normal Test Items,Require Result Value,Požadovat hodnotu výsledku
DocType: Purchase Invoice,Pricing Rules,Pravidla tvorby cen
DocType: Item,Show a slideshow at the top of the page,Ukazují prezentaci v horní části stránky
DocType: Tax Withholding Rate,Tax Withholding Rate,Úroková sazba
DocType: Pricing Rule,Max Amt,Max Amt
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Boms,kusovníky
apps/erpnext/erpnext/stock/doctype/item/item.py,Stores,Zásoba
DocType: Project Type,Projects Manager,Správce projektů
DocType: Serial No,Delivery Time,Dodací lhůta
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Based On,Stárnutí dle
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Appointment cancelled,Jmenování zrušeno
DocType: Item,End of Life,Konec životnosti
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,"Transferring cannot be done to an Employee. \
						Please enter location where Asset {0} has to be transferred","Převod nelze provést na zaměstnance. \ Zadejte místo, kam má být aktivum {0} převedeno"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Travel,Cestování
DocType: Student Report Generation Tool,Include All Assessment Group,Zahrnout celou skupinu hodnocení
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,No active or default Salary Structure found for employee {0} for the given dates,Žádný aktivní nebo implicitní Plat Struktura nalezených pro zaměstnance {0} pro dané termíny
DocType: Leave Block List,Allow Users,Povolit uživatele
DocType: Purchase Order,Customer Mobile No,Zákazník Mobile Žádné
DocType: Leave Type,Calculated in days,Vypočítáno ve dnech
DocType: Call Log,Received By,Přijato
DocType: Appointment Booking Settings,Appointment Duration (In Minutes),Trvání schůzky (v minutách)
DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Podrobné informace o šabloně mapování peněžních toků
apps/erpnext/erpnext/config/non_profit.py,Loan Management,Správa úvěrů
DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Sledovat samostatné výnosy a náklady pro vertikál produktu nebo divizí.
DocType: Rename Tool,Rename Tool,Přejmenování
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Update Cost,Aktualizace nákladů
DocType: Item Reorder,Item Reorder,Položka Reorder
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,GSTR3B-Form,GSTR3B-Form
DocType: Sales Invoice,Mode of Transport,Způsob dopravy
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Show Salary Slip,Show výplatní pásce
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Transfer Material,Přenos materiálu
DocType: Fees,Send Payment Request,Odeslat žádost o platbu
DocType: Travel Request,Any other details,Další podrobnosti
DocType: Water Analysis,Origin,Původ
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 je nad hranicí {0} {1} pro položku {4}. Děláte si jiný {3} proti stejné {2}?
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set recurring after saving,Prosím nastavte opakující se po uložení
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Select change amount account,Vybrat změna výše účet
DocType: Purchase Invoice,Price List Currency,Ceník Měna
DocType: Naming Series,User must always select,Uživatel musí vždy vybrat
DocType: Stock Settings,Allow Negative Stock,Povolit Negativní Sklad
DocType: Installation Note,Installation Note,Poznámka k instalaci
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.js,Show Warehouse-wise Stock,Zobrazit skladové zásoby
DocType: Soil Texture,Clay,Jíl
DocType: Course Topic,Topic,Téma
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Financing,Peněžní tok z finanční
DocType: Budget Account,Budget Account,rozpočet účtu
DocType: Quality Inspection,Verified By,Verified By
DocType: Travel Request,Name of Organizer,Název pořadatele
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ěně společnosti, protože tam jsou stávající transakce. Transakce musí být zrušena, aby změnit výchozí měnu."
DocType: Cash Flow Mapping,Is Income Tax Liability,Je odpovědnost za dani z příjmu
DocType: Grading Scale Interval,Grade Description,Grade Popis
DocType: Clinical Procedure,Is Invoiced,Je fakturována
apps/erpnext/erpnext/setup/doctype/company/company.js,Create Tax Template,Vytvořte šablonu daně
DocType: Stock Entry,Purchase Receipt No,Číslo příjmky
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Earnest Money,Earnest Money
DocType: Sales Invoice, Shipping Bill Number,Přepravní číslo účtu
apps/erpnext/erpnext/assets/doctype/asset/asset.py,"Asset has multiple Asset Movement Entries which has to be \
				cancelled manually to cancel this asset.","Aktivum má více položek pohybu aktiv, které je třeba zrušit ručně, abyste toto dílo zrušili."
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Salary Slip,Vytvořit výplatní pásce
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Traceability,sledovatelnost
DocType: Asset Maintenance Log,Actions performed,Akce byly provedeny
DocType: Cash Flow Mapper,Section Leader,Vedoucí sekce
DocType: Sales Invoice,Transport Receipt No,Doklad o přepravě č
DocType: Quiz Activity,Pass,Složit
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Please add the account to root level Company - ,Přidejte účet do kořenové úrovně společnosti -
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Source of Funds (Liabilities),Zdrojem finančních prostředků (závazků)
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Source and Target Location cannot be same,Umístění zdroje a cíle nemohou být stejné
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 řadě {0} ({1}), musí být stejné jako množství vyrobené {2}"
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","Rozdílový účet musí být účtem typu Asset / Liability, protože tato položka je počáteční položka"
DocType: Supplier Scorecard Scoring Standing,Employee,Zaměstnanec
DocType: Bank Guarantee,Fixed Deposit Number,Číslo pevného vkladu
DocType: Asset Repair,Failure Date,Datum selhání
DocType: Support Search Source,Result Title Field,Výsledek Název pole
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Summary,Přehled hovorů
DocType: Sample Collection,Collected Time,Shromážděný čas
DocType: Employee Skill Map,Employee Skills,Zaměstnanecké dovednosti
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,Fuel Expense,Náklady na palivo
DocType: Company,Sales Monthly History,Měsíční historie prodeje
apps/erpnext/erpnext/regional/italy/utils.py,Please set at least one row in the Taxes and Charges Table,Nastavte prosím alespoň jeden řádek v tabulce daní a poplatků
DocType: Asset Maintenance Task,Next Due Date,Další datum splatnosti
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch,Vyberte možnost Dávka
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is fully billed,{0} {1} je plně fakturováno
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Vital Signs,Známky života
DocType: Payment Entry,Payment Deductions or Loss,Platební srážky nebo ztráta
DocType: Soil Analysis,Soil Analysis Criterias,Kritéria analýzy půdy
apps/erpnext/erpnext/config/settings.py,Standard contract terms for Sales or Purchase.,Standardní smluvní podmínky pro prodej nebo koupi.
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Rows Removed in {0},Řádky odebrány za {0}
DocType: Shift Type,Begin check-in before shift start time (in minutes),Zahájení kontroly před začátkem směny (v minutách)
DocType: BOM Item,Item operation,Položka položky
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Voucher,Seskupit podle Poukazu
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Are you sure you want to cancel this appointment?,Opravdu chcete tuto schůzku zrušit?
DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Balíček ceny pokojů hotelu
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Sales Pipeline,prodejní Pipeline
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set default account in Salary Component {0},Prosím nastavit výchozí účet platu Component {0}
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html,Required On,Povinné On
DocType: HR Settings,"If checked, hides and disables Rounded Total field in Salary Slips","Pokud je zaškrtnuto, skryje a zakáže pole Zaokrouhlený celkový počet v Salary Slips"
DocType: Woocommerce Settings,This is the default offset (days) for the Delivery Date in Sales Orders. The fallback offset is 7 days from the order placement date.,Toto je výchozí offset (dny) pro datum dodání v prodejních objednávkách. Náhradní kompenzace je 7 dní od data zadání objednávky.
DocType: Rename Tool,File to Rename,Soubor k přejmenování
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please select BOM for Item in Row {0},"Prosím, vyberte BOM pro položku v řádku {0}"
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Fetch Subscription Updates,Načíst aktualizace předplatného
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} neodpovídá společnosti {1} v účtu účtu: {2}
apps/erpnext/erpnext/controllers/buying_controller.py,Specified BOM {0} does not exist for Item {1},Stanovená BOM {0} neexistuje k bodu {1}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Course: ,Chod:
DocType: Soil Texture,Sandy Loam,Sandy Loam
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šena před zrušením této prodejní objednávky
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py,Student LMS Activity,Aktivita studentského LMS
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Numbers Created,Sériová čísla byla vytvořena
DocType: POS Profile,Applicable for Users,Platí pro uživatele
DocType: Supplier Quotation,PUR-SQTN-.YYYY.-,PUR-SQTN-.YYYY.-
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Project and all Tasks to status {0}?,Nastavit projekt a všechny úkoly do stavu {0}?
DocType: Purchase Invoice,Set Advances and Allocate (FIFO),Nastavit zálohy a přidělit (FIFO)
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No Work Orders created,Nebyly vytvořeny žádné pracovní příkazy
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Slip of employee {0} already created for this period,Výplatní pásce zaměstnance {0} již vytvořili pro toto období
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Pharmaceutical,Farmaceutické
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,You can only submit Leave Encashment for a valid encashment amount,"Chcete-li platnou částku inkasa, můžete odeslat příkaz Opustit zapsání"
apps/erpnext/erpnext/public/js/hub/pages/SellerItems.vue,Items by ,Položky od
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Purchased Items,Náklady na zakoupené zboží
DocType: Employee Separation,Employee Separation Template,Šablona oddělení zaměstnanců
DocType: Selling Settings,Sales Order Required,Prodejní objednávky Povinné
apps/erpnext/erpnext/public/js/hub/marketplace.js,Become a Seller,Staňte se prodejcem
,Procurement Tracker,Sledování nákupu
DocType: Purchase Invoice,Credit To,Kredit:
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Reversed,ITC obrácené
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid authentication error,Chyba plaid autentizace
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Active Leads / Customers,Aktivní LEADS / Zákazníci
DocType: Delivery Settings,Leave blank to use the standard Delivery Note format,"Chcete-li použít standardní formát doručení, nechte prázdné"
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ělo být jeden rok po datu zahájení fiskálního roku
DocType: Employee Education,Post Graduate,Postgraduální
DocType: Quality Meeting,Agenda,Denní program
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Plán údržby Detail
DocType: Supplier Scorecard,Warn for new Purchase Orders,Upozornit na nové nákupní objednávky
DocType: Quality Inspection Reading,Reading 9,Čtení 9
apps/erpnext/erpnext/config/integrations.py,Connect your Exotel Account to ERPNext and track call logs,Připojte svůj účet Exotel k ERPDext a sledujte protokoly hovorů
DocType: Supplier,Is Frozen,Je Frozen
DocType: Tally Migration,Processed Files,Zpracované soubory
apps/erpnext/erpnext/stock/utils.py,Group node warehouse is not allowed to select for transactions,Uzel skupina sklad není dovoleno vybrat pro transakce
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Accounting Dimension <b>{0}</b> is required for 'Balance Sheet' account {1}.,Účetní dimenze <b>{0}</b> je vyžadována pro účet &#39;Rozvaha&#39; {1}.
DocType: Buying Settings,Buying Settings,Nákup Nastavení
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM Ne pro hotový dobré položce
DocType: Upload Attendance,Attendance To Date,Účast na data
DocType: Request for Quotation Supplier,No Quote,Žádná citace
DocType: Support Search Source,Post Title Key,Klíč příspěvku
DocType: Issue,Issue Split From,Vydání Rozdělit od
DocType: Warranty Claim,Raised By,Vznesené
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Prescriptions,Předpisy
DocType: Payment Gateway Account,Payment Account,Platební účet
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Please specify Company to proceed,Uveďte prosím společnost pokračovat
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Accounts Receivable,Čistá změna objemu pohledávek
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Compensatory Off,Vyrovnávací Off
DocType: Job Applicant,Accepted,Přijato
DocType: POS Closing Voucher,Sales Invoices Summary,Souhrn prodejních faktur
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Party Name,Název strany
DocType: Grant Application,Organization,Organizace
DocType: BOM Update Tool,BOM Update Tool,Nástroj pro aktualizaci kusovníku
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Party,Seskupit podle strany
DocType: SG Creation Tool Course,Student Group Name,Jméno Student Group
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Show exploded view,Zobrazit rozložený pohled
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Creating Fees,Vytváření poplatků
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 vymazat všechny transakce pro tuto společnost. Vaše kmenová data zůstanou, jak to je. Tuto akci nelze vrátit zpět."
apps/erpnext/erpnext/templates/pages/product_search.html,Search Results,Výsledky vyhledávání
DocType: Homepage Section,Number of Columns,Počet sloupců
DocType: Room,Room Number,Číslo pokoje
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}
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requestor,Žadatel
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid reference {0} {1},Neplatná reference {0} {1}
apps/erpnext/erpnext/config/buying.py,Rules for applying different promotional schemes.,Pravidla pro uplatňování různých propagačních programů.
DocType: Shipping Rule,Shipping Rule Label,Přepravní Pravidlo Label
DocType: Journal Entry Account,Payroll Entry,Příspěvek mzdy
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,View Fees Records,Zobrazení záznamů o poplatcích
apps/erpnext/erpnext/public/js/conf.js,User Forum,User Forum
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Raw Materials cannot be blank.,Suroviny nemůže být prázdný.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0} (Payment Table): Amount must be negative,Řádek # {0} (platební tabulka): Částka musí být záporná
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,"Could not update stock, invoice contains drop shipping item.","Nelze aktualizovat zásob, faktura obsahuje pokles lodní dopravy zboží."
DocType: Contract,Fulfilment Status,Stav plnění
DocType: Lab Test Sample,Lab Test Sample,Laboratorní testovací vzorek
DocType: Item Variant Settings,Allow Rename Attribute Value,Povolit přejmenování hodnoty atributu
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Quick Journal Entry,Rychlý vstup Journal
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Amount,Částka budoucí platby
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,You can not change rate if BOM mentioned agianst any item,"Nemůžete změnit sazbu, kdyby BOM zmínil agianst libovolné položky"
DocType: Restaurant,Invoice Series Prefix,Předvolba série faktur
DocType: Employee,Previous Work Experience,Předchozí pracovní zkušenosti
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Number / Name,Aktualizovat číslo účtu / název
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign Salary Structure,Přiřaďte strukturu platu
DocType: Support Settings,Response Key List,Seznam odpovědí
DocType: Stock Entry,For Quantity,Pro Množství
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Planned Qty for Item {0} at row {1},"Prosím, zadejte Plánované Množství k bodu {0} na řádku {1}"
DocType: Support Search Source,Result Preview Field,Pole pro náhled výsledků
apps/erpnext/erpnext/templates/generators/item/item_configure.js,{0} items found.,Bylo nalezeno {0} položek.
DocType: Item Price,Packing Unit,Balení
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} není odesláno
DocType: Subscription,Trialling,Testování
DocType: Sales Invoice Item,Deferred Revenue,Odložené výnosy
DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Hotovostní účet bude použit pro vytvoření faktury
DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Osvobození podkategorie
DocType: Member,Membership Expiry Date,Datum ukončení členství
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,{0} must be negative in return document,{0} musí být negativní ve vratném dokumentu
DocType: Employee Tax Exemption Proof Submission,Submission Date,Datum podání
,Minutes to First Response for Issues,Zápisy do první reakce na otázky
DocType: Purchase Invoice,Terms and Conditions1,Podmínky a podmínek1
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ý nastavujete tento systém.
DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Účetní záznam zmrazeny až do tohoto data, nikdo nemůže dělat / upravit položku kromě role uvedeno níže."
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js,Latest price updated in all BOMs,Poslední cena byla aktualizována ve všech kusovnících
DocType: Project User,Project Status,Stav projektu
DocType: UOM,Check this to disallow fractions. (for Nos),"Zkontrolujte, zda to zakázat frakce. (U č)"
DocType: Student Admission Program,Naming Series (for Student Applicant),Pojmenování Series (pro studentské přihlašovatel)
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py,Bonus Payment Date cannot be a past date,Datum splatnosti bonusu nemůže být poslední datum
DocType: Travel Request,Copy of Invitation/Announcement,Kopie pozvánky / oznámení
DocType: Practitioner Service Unit Schedule,Practitioner Service Unit Schedule,Pracovní služba Servisní plán
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot delete item {1} which has already been billed.,"Řádek # {0}: Nelze odstranit položku {1}, která již byla fakturována."
DocType: Sales Invoice,Transporter Name,Přepravce Název
DocType: Authorization Rule,Authorized Value,Autorizovaný Hodnota
DocType: BOM,Show Operations,Zobrazit Operations
,Minutes to First Response for Opportunity,Zápisy do první reakce na příležitost
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Absent,Celkem Absent
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item or Warehouse for row {0} does not match Material Request,Položka nebo Warehouse na řádku {0} neodpovídá Materiál Poptávka
apps/erpnext/erpnext/hr/report/loan_repayment/loan_repayment.py,Payable Amount,Splatná částka
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Unit of Measure,Měrná jednotka
DocType: Fiscal Year,Year End Date,Datum Konce Roku
DocType: Task Depends On,Task Depends On,Úkol je závislá na
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Opportunity,Příležitost
DocType: Options,Option,Volba
apps/erpnext/erpnext/accounts/general_ledger.py,You can't create accounting entries in the closed accounting period {0},V uzavřeném účetním období nelze vytvářet účetní záznamy {0}
DocType: Operation,Default Workstation,Výchozí Workstation
DocType: Payment Entry,Deductions or Loss,Odpočty nebo ztráta
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is closed,{0} {1} je uzavřen
DocType: Email Digest,How frequently?,Jak často?
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Collected: {0},Celkové shromáždění: {0}
DocType: Purchase Receipt,Get Current Stock,Získejte aktuální stav
DocType: Purchase Invoice,ineligible,neoprávněné
apps/erpnext/erpnext/config/manufacturing.py,Tree of Bill of Materials,Strom Bill materiálů
DocType: BOM,Exploded Items,Rozložené položky
DocType: Student,Joining Date,Datum připojení
,Employees working on a holiday,Zaměstnanci pracující na dovolenou
,TDS Computation Summary,Shrnutí výpočtu TDS
DocType: Share Balance,Current State,Aktuální stav
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Present,Mark Současnost
DocType: Share Transfer,From Shareholder,Od akcionáře
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Greater Than Amount,Větší než částka
DocType: Project,% Complete Method,Dokončeno% Method
apps/erpnext/erpnext/healthcare/setup.py,Drug,Lék
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 pořadové číslo {0}
DocType: Work Order,Actual End Date,Skutečné datum ukončení
DocType: Cash Flow Mapping,Is Finance Cost Adjustment,Je úprava nákladů na finance
DocType: BOM,Operating Cost (Company Currency),Provozní náklady (Company měna)
DocType: Authorization Rule,Applicable To (Role),Vztahující se na (Role)
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Pending Leaves,Nevyřízené listy
DocType: BOM Update Tool,Replace BOM,Nahraďte kusovníku
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Code {0} already exist,Kód {0} již existuje
DocType: Patient Encounter,Procedures,Postupy
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Sales orders are not available for production,Prodejní objednávky nejsou k dispozici pro výrobu
DocType: Asset Movement,Purpose,Účel
DocType: Company,Fixed Asset Depreciation Settings,Nastavení odpisování dlouhodobého majetku
DocType: Item,Will also apply for variants unless overrridden,"Bude platit i pro varianty, pokud nebude přepsáno"
DocType: Purchase Invoice,Advances,Zálohy
DocType: HR Settings,Hiring Settings,Nastavení najímání
DocType: Work Order,Manufacture against Material Request,Výroba proti Materiál Request
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Group: ,Skupina hodnocení:
DocType: Item Reorder,Request for,Žádost o
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 pravidlo se vztahuje na
DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Základní sazba (dle Stock nerozpuštěných)
DocType: SMS Log,No of Requested SMS,Počet žádaným SMS
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Leave Without Pay does not match with approved Leave Application records,Nechat bez nároku na odměnu nesouhlasí se schválenými záznamů nechat aplikaci
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Next Steps,Další kroky
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Saved Items,Uložené položky
DocType: Travel Request,Domestic,Domácí
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Please supply the specified items at the best possible rates,Prosím dodávat uvedené položky na nejlepší možné ceny
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: Certification Application,USD,americký dolar
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Remaining Balance,Zůstatek účtu
DocType: Selling Settings,Auto close Opportunity after 15 days,Auto v blízkosti Příležitost po 15 dnech
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Příkazy na nákup nejsou pro {0} povoleny kvůli postavení skóre {1}.
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/report/consolidated_financial_statement/consolidated_financial_statement.js,End Year,konec roku
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot/Lead %,Quot / Lead%
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Contract End Date must be greater than Date of Joining,Smlouva Datum ukončení musí být větší než Datum spojování
DocType: Sales Invoice,Driver,Řidič
DocType: Vital Signs,Nutrition Values,Výživové hodnoty
DocType: Lab Test Template,Is billable,Je fakturován
DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,"Distributor / dealer / jednatel / partner / prodejce, který prodává produkty společnosti za provizi."
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Purchase Order {1},{0} proti nákupní objednávce {1}
DocType: Patient,Patient Demographics,Demografie pacientů
DocType: Task,Actual Start Date (via Time Sheet),Skutečné datum zahájení (přes Time Sheet)
apps/erpnext/erpnext/portal/doctype/homepage/homepage.py,This is an example website auto-generated from ERPNext,To je příklad webové stránky automaticky generované z ERPNext
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 1,Stárnutí Rozsah 1
DocType: Shopify Settings,Enable Shopify,Povolit funkci Shopify
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total claimed amount,Celková výše zálohy nesmí být vyšší než celková nároková částka
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í daň šablona, která může být použita pro všechny nákupních transakcí. Tato šablona může obsahovat seznam daňových hlav a také ostatní náklady hlavy jako ""doprava"", ""pojištění"", ""manipulace"" atd. 

 #### Poznámka: 

 daňovou sazbu, můžete definovat zde bude základní sazba daně pro všechny ** položky **. Pokud jsou položky ** **, které mají různé ceny, musí být přidány v ** Položka daních ** stůl v ** položky ** mistra.

 #### Popis sloupců 

 1. Výpočet Type: 
 - To může být na ** Čistý Total ** (což je součet základní částky).
 - ** Na předchozí řady Total / Částka ** (pro kumulativní daní a poplatků). Zvolíte-li tuto možnost, bude daň se použije jako procento z předchozí řady (v daňové tabulky) množství nebo celkem.
 - ** Aktuální ** (jak je uvedeno).
 2. Účet Hlava: kniha účtu, pod kterým se bude tato daň rezervovat 
 3. Nákladové středisko: V případě, že daň / poplatek je příjmem (jako poštovné) nebo nákladů je třeba rezervovat na nákladové středisko.
 4. Popis: Popis daně (které budou vytištěny v faktur / uvozovek).
 5. Rate: Sazba daně.
 6. Částka: Částka daně.
 7. Celkem: Kumulativní celková k tomuto bodu.
 8. Zadejte Row: Je-li na základě ""předchozí řady Total"" můžete zvolit číslo řádku, která bude přijata jako základ pro tento výpočet (výchozí je předchozí řádek).
 9. Zvažte daň či poplatek za: V této části můžete nastavit, zda daň / poplatek je pouze pro ocenění (není součástí celkem), nebo pouze pro celkem (není přidanou hodnotu do položky), nebo pro obojí.
 10. Přidat nebo odečítat: Ať už chcete přidat nebo odečíst daň."
DocType: Homepage,Homepage,Domovská stránka
DocType: Grant Application,Grant Application Details ,Podrobnosti o žádosti o grant
DocType: Employee Separation,Employee Separation,Separace zaměstnanců
DocType: BOM Item,Original Item,Původní položka
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Date,Datum dokumentu
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py,Fee Records Created - {0},Fee Records Vytvořil - {0}
DocType: Asset Category Account,Asset Category Account,Asset Kategorie Account
apps/erpnext/erpnext/controllers/item_variant.py,The value {0} is already assigned to an exisiting Item {2}.,Hodnota {0} je již přiřazena k existující položce {2}.
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á
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Cannot produce more Item {0} than Sales Order quantity {1},Nelze produkují více položku {0} než prodejní objednávky množství {1}
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Nothing is included in gross,V hrubé hodnotě není zahrnuto nic
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill already exists for this document,Pro tento dokument již existuje e-Way Bill
apps/erpnext/erpnext/stock/doctype/item/item.js,Select Attribute Values,Vyberte hodnoty atributů
DocType: Purchase Invoice,Reason For Issuing document,Důvod pro vydávací dokument
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Stock Entry {0} is not submitted,Skladový pohyb {0} není založen
DocType: Payment Reconciliation,Bank / Cash Account,Bank / Peněžní účet
DocType: Bank Transaction,ACC-BTN-.YYYY.-,ACC-BTN-.RRRR.-
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Next Contact By cannot be same as the Lead Email Address,Následující Kontakt Tím nemůže být stejný jako hlavní e-mailovou adresu
DocType: Tax Rule,Billing City,Fakturace City
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is an Individual or a Proprietorship,"Platí, pokud je společnost jednotlivec nebo vlastník"
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,Log Type is required for check-ins falling in the shift: {0}.,Pro přihlášení spadající do směny je vyžadován typ protokolu: {0}.
DocType: Asset,Manual,Manuál
DocType: Tally Migration,Is Master Data Processed,Zpracovává se kmenová data
DocType: Salary Component Account,Salary Component Account,Účet plat Component
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} Operations: {1},{0} Operace: {1}
DocType: Global Defaults,Hide Currency Symbol,Skrýt symbol měny
apps/erpnext/erpnext/config/non_profit.py,Donor information.,Informace dárce.
apps/erpnext/erpnext/config/accounts.py,"e.g. Bank, Cash, Credit Card","např. banka, hotovost, kreditní karty"
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ého pacienta je přibližně 120 mmHg systolický a 80 mmHg diastolický, zkráceně &quot;120/80 mmHg&quot;"
DocType: Journal Entry,Credit Note,Dobropis
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Finished Good Item Code,Kód dokončeného zboží
apps/erpnext/erpnext/config/desktop.py,Quality,Kvalita
DocType: Projects Settings,Ignore Employee Time Overlap,Ignorovat překrytí času zaměstnanců
DocType: Warranty Claim,Service Address,Servisní adresy
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Master Data,Import kmenových dat
DocType: Asset Maintenance Task,Calibration,Kalibrace
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} is a company holiday,{0} je obchodní svátek
apps/erpnext/erpnext/projects/report/billing_summary.py,Billable Hours,Fakturovatelné hodiny
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Status Notification,Odešlete oznámení o stavu
DocType: Patient Appointment,Procedure Prescription,Předepsaný postup
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
DocType: Travel Request,Travel Type,Typ cesty
DocType: Purchase Invoice Item,Manufacture,Výroba
DocType: Blanket Order,MFG-BLR-.YYYY.-,MFG-BLR-.YYYY.-
,Lab Test Report,Zkušební protokol
DocType: Employee Benefit Application,Employee Benefit Application,Aplikace pro zaměstnance
DocType: Appointment,Unverified,Neověřeno
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.py,Row({0}): {1} is already discounted in {2},Řádek ({0}): {1} je již zlevněn v {2}
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Additional Salary Component Exists.,Další platová složka existuje.
DocType: Purchase Invoice,Unregistered,Neregistrováno
DocType: Student Applicant,Application Date,aplikace Datum
DocType: Salary Component,Amount based on formula,Částka podle vzorce
DocType: Purchase Invoice,Currency and Price List,Měna a ceník
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Create Maintenance Visit,Vytvořte návštěvu údržby
DocType: Opportunity,Customer / Lead Name,Zákazník / Lead Name
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date not mentioned,Výprodej Datum není uvedeno
DocType: Payroll Period,Taxable Salary Slabs,Zdanitelné platové desky
DocType: Job Card,Production,Výroba
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.
apps/erpnext/erpnext/stock/report/stock_and_account_value_comparison/stock_and_account_value_comparison.py,Account Value,Hodnota účtu
DocType: Guardian,Occupation,Povolání
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Row {0}:Start Date must be before End Date,"Row {0}: datum zahájení, musí být před koncem roku Datum"
DocType: Salary Component,Max Benefit Amount (Yearly),Maximální částka prospěchu (ročně)
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,TDS Rate %,Míra TDS%
DocType: Crop,Planting Area,Plocha pro výsadbu
apps/erpnext/erpnext/controllers/trends.py,Total(Qty),Total (ks)
DocType: Installation Note Item,Installed Qty,Instalované množství
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Asset {0} does not belongs to the location {1},Aktiva {0} nepatří do umístění {1}
,Product Bundle Balance,Zůstatek produktu
DocType: Purchase Taxes and Charges,Parenttype,Parenttype
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Central Tax,Centrální daň
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Result,Trénink Výsledek
DocType: Purchase Invoice,Is Paid,se vyplácí
DocType: Salary Structure,Total Earning,Celkem Zisk
DocType: Purchase Receipt,Time at which materials were received,"Čas, kdy bylo přijato materiály"
DocType: Products Settings,Products per Page,Produkty na stránku
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Quantity to Manufacture,Množství k výrobě
DocType: Stock Ledger Entry,Outgoing Rate,Odchozí Rate
apps/erpnext/erpnext/controllers/accounts_controller.py, or ,nebo
apps/erpnext/erpnext/public/js/purchase_trends_filters.js,Billing Date,Datum fakturace
DocType: Import Supplier Invoice,Import Supplier Invoice,Importovat dodavatelskou fakturu
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be negative,Přidělené množství nemůže být záporné
DocType: Import Supplier Invoice,Zip File,Soubor ZIP
DocType: Sales Order,Billing Status,Status Fakturace
apps/erpnext/erpnext/public/js/conf.js,Report an Issue,Nahlásit problém
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 aplikováno schéma <b>{3}</b> ."
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Utility Expenses,Utility Náklady
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,90-Above,90 Nad
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}: Journal Entry {1} nemá účet {2} nebo již uzavřeno proti jinému poukazu
DocType: Supplier Scorecard Criteria,Criteria Weight,Kritéria Váha
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Account: {0} is not permitted under Payment Entry,Účet: {0} není povolen v rámci zadání platby
DocType: Production Plan,Ignore Existing Projected Quantity,Ignorujte existující předpokládané množství
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Approval Notification,Zanechat oznámení o schválení
DocType: Buying Settings,Default Buying Price List,Výchozí Nákup Ceník
DocType: Payroll Entry,Salary Slip Based on Timesheet,Plat Slip na základě časového rozvrhu
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Rate,Rychlost nákupu
apps/erpnext/erpnext/controllers/buying_controller.py,Row {0}: Enter location for the asset item {1},Řádek {0}: Zadejte umístění položky aktiv {1}
apps/erpnext/erpnext/hr/doctype/attendance/attendance_list.js,Attendance Marked,Účast označena
DocType: Request for Quotation,PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-
apps/erpnext/erpnext/public/js/hub/pages/Seller.vue,About the Company,O společnosti
apps/erpnext/erpnext/config/settings.py,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Nastavit jako výchozí hodnoty, jako je společnost, měna, aktuálním fiskálním roce, atd"
DocType: Payment Entry,Payment Type,Typ platby
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 položku Dávka pro položku {0}. Nelze najít jednu dávku, která splňuje tento požadavek"
DocType: Asset Maintenance Log,ACC-AML-.YYYY.-,ACC-AML-.RRRR.-
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,No gain or loss in the exchange rate,Žádné zisky nebo ztráty ve směnném kurzu
DocType: Leave Control Panel,Select Employees,Vybrat Zaměstnanci
DocType: Shopify Settings,Sales Invoice Series,Série faktur
DocType: Opportunity,Potential Sales Deal,Potenciální prodej
DocType: Complaint,Complaints,Stížnosti
DocType: Employee Tax Exemption Declaration,Employee Tax Exemption Declaration,Vyhlášení osvobození od daně z pracovních sil
DocType: Payment Entry,Cheque/Reference Date,Šek / Referenční datum
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials.,Žádné položky s kusovníkem.
apps/erpnext/erpnext/portal/doctype/homepage/homepage.js,Customize Homepage Sections,Přizpůsobte sekce domovské stránky
DocType: Purchase Invoice,Total Taxes and Charges,Celkem Daně a poplatky
DocType: Payment Entry,Company Bank Account,Firemní bankovní účet
DocType: Employee,Emergency Contact,Kontakt v nouzi
DocType: Bank Reconciliation Detail,Payment Entry,platba Entry
,sales-browser,Prodejní-browser
apps/erpnext/erpnext/accounts/doctype/account/account.js,Ledger,Účetní kniha
DocType: Drug Prescription,Drug Code,Drogový kód
DocType: Target Detail,Target  Amount,Cílová částka
apps/erpnext/erpnext/education/utils.py,Quiz {0} does not exist,Kvíz {0} neexistuje
DocType: POS Profile,Print Format for Online,Formát tisku pro online
DocType: Shopping Cart Settings,Shopping Cart Settings,Nákupní košík Nastavení
DocType: Journal Entry,Accounting Entries,Účetní záznamy
DocType: Job Card Time Log,Job Card Time Log,Časový záznam karty práce
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.","Je-li vybráno pravidlo pro stanovení cen, provede se přepínání ceníku. Cenová sazba Pravidlo je konečná sazba, takže by neměla být použita žádná další sleva. Proto v transakcích, jako je Prodejní objednávka, Objednávka apod., Bude vybírána v poli &#39;Cena&#39; namísto &#39;Pole cenových listů&#39;."
DocType: Journal Entry,Paid Loan,Placený úvěr
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Subcontract: Raw materials quantity to make subcontracted items.,Vyhrazeno Množství pro subdodávky: Množství surovin pro výrobu subdodávek.
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}
DocType: Journal Entry Account,Reference Due Date,Referenční datum splatnosti
DocType: Purchase Order,Ref SQ,Ref SQ
DocType: Issue,Resolution By,Rozlišení podle
DocType: Leave Type,Applicable After (Working Days),Platí po (pracovní dny)
apps/erpnext/erpnext/education/doctype/student/student.py,Joining Date can not be greater than Leaving Date,Datum připojení nesmí být větší než datum opuštění
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Receipt document must be submitted,Příjem dokument musí být předložen
DocType: Purchase Invoice Item,Received Qty,Přijaté Množství
DocType: Stock Entry Detail,Serial No / Batch,Výrobní číslo / Batch
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Not Paid and Not Delivered,Nezaplatil a není doručení
DocType: Product Bundle,Parent Item,Nadřazená položka
DocType: Account,Account Type,Typ účtu
DocType: Shopify Settings,Webhooks Details,Webhooks Podrobnosti
apps/erpnext/erpnext/templates/pages/projects.html,No time sheets,Žádné pracovní výkazy
DocType: GoCardless Mandate,GoCardless Customer,Zákazník GoCardless
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leave Type {0} cannot be carry-forwarded,Nechte typ {0} nelze provádět předávány
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. Prosím, klikněte na ""Generovat Schedule"""
,To Produce,K výrobě
DocType: Leave Encashment,Payroll,Mzdy
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 v rychlosti položku jsou {2}, řádky {3} musí být také zahrnuty"
DocType: Healthcare Service Unit,Parent Service Unit,Rodičovská služba
DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikace balíčku pro dodávky (pro tisk)
apps/erpnext/erpnext/support/doctype/issue/issue.js,Service Level Agreement was reset.,Dohoda o úrovni služeb byla resetována.
DocType: Bin,Reserved Quantity,Vyhrazeno Množství
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Please enter valid email address,Zadejte platnou e-mailovou adresu
DocType: Volunteer Skill,Volunteer Skill,Dobrovolnické dovednosti
DocType: Bank Reconciliation,Include POS Transactions,Zahrnout POS transakce
DocType: Quality Action,Corrective/Preventive,Nápravné / preventivní
DocType: Purchase Invoice,Inter Company Invoice Reference,Interní reference faktury společnosti
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select an item in the cart,Vyberte prosím položku v košíku
DocType: Landed Cost Voucher,Purchase Receipt Items,Položky příjemky
apps/erpnext/erpnext/regional/italy/utils.py,Please set Tax ID for the customer '%s',Nastavte prosím daňové identifikační číslo pro zákazníka &#39;% s&#39;
apps/erpnext/erpnext/config/help.py,Customizing Forms,Přizpůsobení Formuláře
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Arrear,nedoplatek
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Amount during the period,Odpisy hodnoty v průběhu období
DocType: Sales Invoice,Is Return (Credit Note),Je návrat (kreditní poznámka)
DocType: Leave Control Panel,Allocate Leaves,Přidělit listy
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py,Disabled template must not be default template,Bezbariérový šablona nesmí být výchozí šablonu
DocType: Pricing Rule,Price or Product Discount,Cena nebo sleva produktu
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: Account,Income Account,Účet příjmů
DocType: Payment Request,Amount in customer's currency,Částka v měně zákazníka
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Delivery,Dodávka
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Assigning Structures...,Přiřazení struktur ...
DocType: Stock Reconciliation Item,Current Qty,Aktuální Množství
DocType: Restaurant Menu,Restaurant Menu,Nabídka restaurací
apps/erpnext/erpnext/public/js/event.js,Add Suppliers,Přidat dodavatele
DocType: Sales Invoice,ACC-SINV-.YYYY.-,ACC-SINV-.YYYY.-
DocType: Loyalty Program,Help Section,Část nápovědy
apps/erpnext/erpnext/www/all-products/index.html,Prev,Předch
DocType: Appraisal Goal,Key Responsibility Area,Key Odpovědnost Area
DocType: Delivery Trip,Distance UOM,Vzdálenost UOM
apps/erpnext/erpnext/utilities/activation.py,"Student Batches help you track attendance, assessments and fees for students","Student Šarže pomůže sledovat docházku, posudky a poplatků pro studenty"
DocType: Payment Entry,Total Allocated Amount,Celková alokovaná částka
apps/erpnext/erpnext/setup/doctype/company/company.py,Set default inventory account for perpetual inventory,Nastavte výchozí inventář pro trvalý inventář
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 doručit pořadové číslo {0} položky {1}, protože je rezervováno pro \ fullfill Sales Order {2}"
DocType: Material Request Plan Item,Material Request Type,Materiál Typ požadavku
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js,Send Grant Review Email,Odeslání e-mailu o revizi grantu
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full, did not save","Místní úložiště je plné, nezachránil"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}: UOM Conversion Factor is mandatory,Řádek {0}: UOM Konverzní faktor je povinné
DocType: Employee Benefit Claim,Claim Date,Datum uplatnění nároku
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field Asset Account cannot be blank,Pole Účet aktiv nesmí být prázdné
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Already record exists for the item {0},Již existuje záznam pro položku {0}
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Ref,Ref
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 vygenerovaných fakturách. Opravdu chcete tento odběr restartovat?
DocType: Lab Test,LP-,LP-
DocType: Healthcare Settings,Registration Fee,Registrační poplatek
DocType: Loyalty Program Collection,Loyalty Program Collection,Věrnostní program
DocType: Stock Entry Detail,Subcontracted Item,Subdodavatelská položka
apps/erpnext/erpnext/education/__init__.py,Student {0} does not belong to group {1},Student {0} nepatří do skupiny {1}
DocType: Budget,Cost Center,Nákladové středisko
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Voucher #,Voucher #
DocType: Tax Rule,Shipping Country,Země dodání
DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Inkognito daně zákazníka z prodejních transakcí
DocType: Upload Attendance,Upload HTML,Nahrát HTML
DocType: Employee,Relieving Date,Uvolnění Datum
apps/erpnext/erpnext/projects/doctype/project/project.js,Duplicate Project with Tasks,Duplikovat projekt s úkoly
DocType: Purchase Invoice,Total Quantity,Celkové množství
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.","Ceny Pravidlo je vyrobena přepsat Ceník / definovat slevy procenta, na základě určitých kritérií."
apps/erpnext/erpnext/support/doctype/issue/issue.py,Service Level Agreement has been changed to {0}.,Smlouva o úrovni služeb byla změněna na {0}.
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Změnu skladu je možné provést pouze prostřednictvím Skladového pohybu / dodacím listem / nákupním dokladem
DocType: Employee Education,Class / Percentage,Třída / Procento
DocType: Shopify Settings,Shopify Settings,Shopify Nastavení
DocType: Amazon MWS Settings,Market Place ID,ID místa na trhu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Head of Marketing and Sales,Vedoucí marketingu a prodeje
DocType: Video,Vimeo,Vimeo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Income Tax,Daň z příjmů
DocType: HR Settings,Check Vacancies On Job Offer Creation,Zkontrolujte volná místa při vytváření pracovních nabídek
DocType: Subscription,Cancel At End Of Period,Zrušit na konci období
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Property already added,Vlastnictví již bylo přidáno
DocType: Item Supplier,Item Supplier,Položka Dodavatel
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please enter Item Code to get batch no,"Prosím, zadejte kód položky se dostat dávku no"
apps/erpnext/erpnext/public/js/utils.js,Loyalty Points: {0},Věrnostní body: {0}
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js,Please select a value for {0} quotation_to {1},Vyberte prosím hodnotu pro {0} quotation_to {1}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,No Items selected for transfer,Nebyly vybrány žádné položky pro přenos
apps/erpnext/erpnext/config/buying.py,All Addresses.,Všechny adresy.
DocType: Company,Stock Settings,Stock Nastavení
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","Spojení je možné pouze tehdy, pokud tyto vlastnosti jsou stejné v obou záznamech. Je Group, Root Type, Company"
DocType: Vehicle,Electric,Elektrický
DocType: Task,% Progress,% Progress
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 aktiv likvidaci
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.",Do následující tabulky bude vybrán pouze žadatel o studium se statusem &quot;Schváleno&quot;.
DocType: Tax Withholding Category,Rates,Ceny
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> Prosím, nastavte účetní řád správně."
DocType: Task,Depends on Tasks,Závisí na Úkoly
apps/erpnext/erpnext/config/crm.py,Manage Customer Group Tree.,Správa zákazníků skupiny Tree.
DocType: Normal Test Items,Result Value,Výsledek Hodnota
DocType: Hotel Room,Hotels,Hotely
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,New Cost Center Name,Jméno Nového Nákladového Střediska
DocType: Leave Control Panel,Leave Control Panel,Ovládací panel dovolených
DocType: Project,Task Completion,úkol Dokončení
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,Not in Stock,Není skladem
DocType: Volunteer,Volunteer Skills,Dobrovolnické dovednosti
DocType: Additional Salary,HR User,HR User
DocType: Bank Guarantee,Reference Document Name,Název referenčního dokumentu
DocType: Purchase Invoice,Taxes and Charges Deducted,Daně a odečtené
DocType: Support Settings,Issues,Problémy
DocType: Loyalty Program,Loyalty Program Name,Název věrnostního programu
apps/erpnext/erpnext/controllers/status_updater.py,Status must be one of {0},Stav musí být jedním z {0}
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Reminder to update GSTIN Sent,Připomenutí k aktualizaci zprávy GSTIN Sent
DocType: Discounted Invoice,Debit To,Debetní K
DocType: Restaurant Menu Item,Restaurant Menu Item,Položka nabídky restaurace
DocType: Delivery Note,Required only for sample item.,Požadováno pouze pro položku vzorku.
DocType: Stock Ledger Entry,Actual Qty After Transaction,Skutečné Množství Po transakci
,Pending SO Items For Purchase Request,"Do doby, než SO položky k nákupu Poptávka"
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Student Admissions,Student Přijímací
apps/erpnext/erpnext/accounts/party.py,{0} {1} is disabled,{0} {1} je zakázán
DocType: Supplier,Billing Currency,Fakturace Měna
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Extra Large,Extra Velké
DocType: Loan,Loan Application,Žádost o půjčku
DocType: Crop,Scientific Name,Odborný název
DocType: Healthcare Service Unit,Service Unit Type,Typ servisní jednotky
DocType: Bank Account,Branch Code,Kód pobočky
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Leaves,Celkem Listy
DocType: Customer,"Reselect, if the chosen contact is edited after save","Zvolte znovu, pokud je vybraný kontakt po uložení změněn"
DocType: Quality Procedure,Parent Procedure,Rodičovský postup
DocType: Patient Encounter,In print,V tisku
DocType: Accounting Dimension,Accounting Dimension,Účetní dimenze
,Profit and Loss Statement,Výkaz zisků a ztrát
DocType: Bank Reconciliation Detail,Cheque Number,Šek číslo
apps/erpnext/erpnext/healthcare/utils.py,The item referenced by {0} - {1} is already invoiced,Položka odkazovaná na {0} - {1} je již fakturována
,Sales Browser,Sales Browser
DocType: Journal Entry,Total Credit,Celkový Credit
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Warning: Another {0} # {1} exists against stock entry {2},Upozornění: dalším {0} č. {1} existuje proti pohybu skladu {2}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Local,Místní
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/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Debtors,Dlužníci
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Large,Velký
DocType: Bank Statement Settings,Bank Statement Settings,Nastavení bankovního výpisu
DocType: Shopify Settings,Customer Settings,Nastavení zákazníka
DocType: Homepage Featured Product,Homepage Featured Product,Úvodní Doporučené zboží
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,View Orders,Zobrazit objednávky
DocType: Marketplace Settings,Marketplace URL (to hide and update label),Adresa URL tržiště (skrýt a aktualizovat štítek)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Assessment Groups,Všechny skupiny Assessment
apps/erpnext/erpnext/regional/india/utils.py,{} is required to generate e-Way Bill JSON,{} je vyžadován pro vygenerování e-Way Bill JSON
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,New Warehouse Name,Název nového skladu
DocType: Shopify Settings,App Type,Typ aplikace
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py,Total {0} ({1}),Celkem {0} ({1})
DocType: C-Form Invoice Detail,Territory,Území
DocType: Pricing Rule,Apply Rule On Item Code,Použít pravidlo na kód položky
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,"Prosím, uveďte počet požadovaných návštěv"
apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Zpráva o stavu zásob
DocType: Stock Settings,Default Valuation Method,Výchozí metoda ocenění
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Poplatek
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Zobrazit kumulativní částku
apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Aktualizace probíhá. Může chvíli trvat.
DocType: Production Plan Item,Produced Qty,Vyrobeno množství
DocType: Vehicle Log,Fuel Qty,palivo Množství
DocType: Work Order Operation,Planned Start Time,Plánované Start Time
DocType: Course,Assessment,Posouzení
DocType: Payment Entry Reference,Allocated,Přidělené
apps/erpnext/erpnext/config/accounts.py,Close Balance Sheet and book Profit or Loss.,Zavřete Rozvahu a zapiš účetní zisk nebo ztrátu.
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,ERPNext could not find any matching payment entry,ERPNext nemohl najít žádnou odpovídající platební položku
DocType: Student Applicant,Application Status,Stav aplikace
DocType: Additional Salary,Salary Component Type,Typ platového komponentu
DocType: Sensitivity Test Items,Sensitivity Test Items,Položky testu citlivosti
DocType: Website Attribute,Website Attribute,Atribut webové stránky
DocType: Project Update,Project Update,Aktualizace projektu
DocType: Journal Entry Account,Fees,Poplatky
DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Zadejte Exchange Rate převést jednu měnu na jinou
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Quotation {0} is cancelled,Nabídka {0} je zrušena
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Total Outstanding Amount,Celková dlužná částka
DocType: Sales Partner,Targets,Cíle
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: Quality Action Table,Responsible,Odpovědný
DocType: Email Digest,Sales Orders to Bill,Prodejní příkazy k Billu
DocType: Price List,Price List Master,Ceník Master
DocType: GST Account,CESS Account,Účet CESS
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 si můžete nastavit a sledovat cíle."
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Link to Material Request,Odkaz na materiálovou žádost
DocType: Quiz,Score out of 100,Skóre ze 100
apps/erpnext/erpnext/templates/pages/help.html,Forum Activity,Aktivita fóra
DocType: Quiz,Grading Basis,Základ klasifikace
apps/erpnext/erpnext/selling/report/pending_so_items_for_purchase_request/pending_so_items_for_purchase_request.py,S.O. No.,SO Ne.
DocType: Bank Statement Transaction Settings Item,Bank Statement Transaction Settings Item,Položka položek transakce bankovního výpisu
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 uvolnění zaměstnance
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Please create Customer from Lead {0},Prosím vytvořte Zákazník z olova {0}
apps/erpnext/erpnext/healthcare/page/patient_history/patient_history.html,Select Patient,Vyberte pacienta
DocType: Price List,Applicable for Countries,Pro země
DocType: Supplier Scorecard Scoring Variable,Parameter Name,Název parametru
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,"Nechte pouze aplikace, které mají status &quot;schváleno&quot; i &quot;Zamítnuto&quot; může být předložena"
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py,Creating Dimensions...,Vytváření dimenzí ...
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Student Group Name is mandatory in row {0},Student Název skupiny je povinné v řadě {0}
DocType: Homepage,Products to be shown on website homepage,"Produkty, které mají být uvedeny na internetových stránkách domovské"
DocType: HR Settings,Password Policy,Zásady hesla
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js,This is a root customer group and cannot be edited.,"To je kořen skupiny zákazníků, a nelze upravovat."
DocType: Student,AB-,AB-
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Total completed qty must be greater than zero,Celkové dokončené množství musí být větší než nula
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on PO,Akce při překročení akumulovaného měsíčního rozpočtu v PO
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Place,Na místo
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select a Sales Person for item: {0},Vyberte obchodní osobu pro položku: {0}
DocType: Stock Entry,Stock Entry (Outward GIT),Zásoby (Outward GIT)
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation,Přehodnocení směnného kurzu
DocType: POS Profile,Ignore Pricing Rule,Ignorovat Ceny pravidlo
DocType: Employee Education,Graduate,Absolvent
DocType: Leave Block List,Block Days,Blokové dny
DocType: Appointment,Linked Documents,Propojené dokumenty
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please enter Item Code to get item taxes,"Zadejte kód položky, abyste získali daně z zboží"
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,"Shipping Address does not have country, which is required for this Shipping Rule","Odeslání adresy nemá zemi, která je požadována pro toto Pravidlo plavby"
DocType: Journal Entry,Excise Entry,Spotřební Entry
DocType: Bank,Bank Transaction Mapping,Mapování bankovních transakcí
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Upozornění: prodejní objednávky {0} již existuje proti Zákazníka Objednávky {1}
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.","Všeobecné obchodní podmínky, které mohou být přidány do prodejů a nákupů.

 Příklady: 

 1. Platnost nabídky.
 1. Platební podmínky (v předstihu, na úvěr, část zálohy atd.)
 1. Co je to další (nebo zaplatit zákazníkem).
 1. Bezpečnost / varování využití.
 1. Záruka, pokud existuje.
 1. Vrátí zásady.
 1. Podmínky přepravy, v případě potřeby.
 1. Způsoby řešení sporů, náhrady škody, odpovědnosti za škodu, atd 
 1. Adresa a kontakt na vaši společnost."
DocType: Homepage Section,Section Based On,Sekce založená na
DocType: Shopping Cart Settings,Show Apply Coupon Code,Zobrazit Použít kód kupónu
DocType: Issue,Issue Type,Typ vydání
DocType: Attendance,Leave Type,Typ absence
DocType: Purchase Invoice,Supplier Invoice Details,Dodavatel fakturační údaje
DocType: Agriculture Task,Ignore holidays,Ignorovat svátky
apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Přidat / upravit podmínky kupónu
apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Náklady / Rozdíl účtu ({0}), musí být ""zisk nebo ztráta"" účet"
DocType: Stock Entry Detail,Stock Entry Child,Zásoby dítě
DocType: Project,Copied From,Zkopírován z
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Invoice already created for all billing hours,Faktura již vytvořená pro všechny fakturační hodiny
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Name error: {0},Název chyba: {0}
DocType: Healthcare Service Unit Type,Item Details,Položka Podrobnosti
DocType: Cash Flow Mapping,Is Finance Cost,Jsou finanční náklady
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance for employee {0} is already marked,Účast na zaměstnance {0} je již označen
DocType: Packing Slip,If more than one package of the same type (for print),Pokud je více než jeden balík stejného typu (pro tisk)
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please set default customer in Restaurant Settings,Nastavte výchozího zákazníka v nastavení restaurace
,Salary Register,plat Register
DocType: Company,Default warehouse for Sales Return,Výchozí sklad pro vrácení prodeje
DocType: Pick List,Parent Warehouse,Nadřízený sklad
DocType: Subscription,Net Total,Net Total
apps/erpnext/erpnext/stock/doctype/batch/batch.py,"Set item's shelf life in days, to set expiry based on manufacturing date plus shelf-life.","Nastavte dobu použitelnosti položky ve dnech, nastavte dobu použitelnosti na základě data výroby plus doby použitelnosti."
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Default BOM not found for Item {0} and Project {1},Výchozí kusovník nebyl nalezen pro položku {0} a projekt {1}
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the Mode of Payment in Payment Schedule,Řádek {0}: Nastavte prosím platební režim v plánu plateb
apps/erpnext/erpnext/config/non_profit.py,Define various loan types,Definovat různé typy půjček
DocType: Bin,FCFS Rate,FCFS Rate
DocType: Bank Statement Transaction Invoice Item,Outstanding Amount,Dlužné částky
apps/erpnext/erpnext/templates/generators/bom.html,Time(in mins),Čas (v min)
DocType: Task,Working,Pracovní
DocType: Stock Ledger Entry,Stock Queue (FIFO),Sklad fronty (FIFO)
DocType: Homepage Section,Section HTML,Sekce HTML
apps/erpnext/erpnext/public/js/setup_wizard.js,Financial Year,Finanční rok
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,{0} does not belong to Company {1},{0} nepatří do Společnosti {1}
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.,"Nelze vyřešit funkci skóre kritérií pro {0}. Zkontrolujte, zda je vzorec platný."
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost as on,Stát jak na
DocType: Healthcare Settings,Out Patient Settings,Out Nastavení pacienta
DocType: Account,Round Off,Zaokrouhlit
DocType: Service Level Priority,Resolution Time,Čas rozlišení
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Quantity must be positive,Množství musí být kladné
DocType: Job Card,Requested Qty,Požadované množství
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The fields From Shareholder and To Shareholder cannot be blank,Políčka Od Akcionáře a Akcionáře nesmí být prázdná
DocType: Cashier Closing,Cashier Closing,Pokladní pokladna
DocType: Tax Rule,Use for Shopping Cart,Použití pro Košík
DocType: Homepage,Homepage Slideshow,Domovská stránka Prezentace
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Serial Numbers,Zvolte sériová čísla
DocType: BOM Item,Scrap %,Scrap%
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ěleny úměrně na základě položky Množství nebo částkou, dle Vašeho výběru"
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Create Supplier Quotation,Vytvořit nabídku dodavatele
DocType: Travel Request,Require Full Funding,Požádejte o plné financování
DocType: Maintenance Visit,Purposes,Cíle
DocType: Stock Entry,MAT-STE-.YYYY.-,MAT-STE-.YYYY.-
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 s negativním množství ve vratném dokumentu
DocType: Shift Type,Grace Period Settings For Auto Attendance,Nastavení doby odkladu pro automatickou účast
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","Provoz {0} déle, než všech dostupných pracovních hodin v pracovní stanici {1}, rozložit provoz do několika operací"
DocType: Membership,Membership Status,Stav členství
DocType: Travel Itinerary,Lodging Required,Požadováno ubytování
DocType: Promotional Scheme,Price Discount Slabs,Cenové slevové desky
DocType: Stock Reconciliation Item,Current Serial No,Aktuální sériové číslo
DocType: Employee,Attendance and Leave Details,Docházka a podrobnosti o dovolené
,BOM Comparison Tool,Nástroj pro porovnání kusovníků
,Requested,Požadované
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,No Remarks,Žádné poznámky
DocType: Asset,In Maintenance,V údržbě
DocType: Amazon MWS Settings,Click this button to pull your Sales Order data from Amazon MWS.,Kliknutím na toto tlačítko vygenerujete údaje o prodejní objednávce z Amazon MWS.
DocType: Vital Signs,Abdomen,Břicho
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,No outstanding invoices require exchange rate revaluation,Žádné nevyfakturované faktury nevyžadují přehodnocení směnného kurzu
DocType: Purchase Invoice,Overdue,Zpožděný
DocType: Account,Stock Received But Not Billed,Sklad nepřijali Účtovaný
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root Account must be a group,Root účet musí být skupina
DocType: Drug Prescription,Drug Prescription,Předepisování léků
DocType: Service Level,Support and Resolution,Podpora a rozlišení
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Free item code is not selected,Volný kód položky není vybrán
DocType: Loan,Repaid/Closed,Splacena / Zavřeno
DocType: Amazon MWS Settings,CA,CA
DocType: Item,Total Projected Qty,Celková předpokládaná Množství
DocType: Monthly Distribution,Distribution Name,Distribuce Name
DocType: Chart of Accounts Importer,Chart Tree,Strom grafu
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Include UOM,Zahrnout UOM
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Material Request No,Materiál Poptávka No
DocType: Service Level Agreement,Default Service Level Agreement,Výchozí dohoda o úrovni služeb
DocType: SG Creation Tool Course,Course Code,Kód předmětu
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
DocType: Pick List,Qty of raw materials will be decided based on the qty of the Finished Goods Item,Množství surovin bude rozhodnuto na základě množství hotového zboží
DocType: Location,Parent Location,Umístění rodiče
DocType: POS Settings,Use POS in Offline Mode,Používejte POS v režimu offline
apps/erpnext/erpnext/support/doctype/issue/issue.py,Priority has been changed to {0}.,Priorita byla změněna na {0}.
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á, že záznam o výměně měny není vytvořen pro {1} až {2}"
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: Purchase Invoice Item,Net Rate (Company Currency),Čistý Rate (Company měny)
DocType: Salary Detail,Condition and Formula Help,Stav a Formula nápovědy
apps/erpnext/erpnext/config/crm.py,Manage Territory Tree.,Správa Territory strom.
apps/erpnext/erpnext/config/getting_started.py,Import Chart Of Accounts from CSV / Excel files,Importujte graf účtů ze souborů CSV / Excel
DocType: Patient Service Unit,Patient Service Unit,Jednotka služeb pacienta
DocType: Bank Statement Transaction Invoice Item,Sales Invoice,Prodejní faktury
DocType: Journal Entry Account,Party Balance,Balance Party
DocType: Cash Flow Mapper,Section Subtotal,Sekce Mezisoučet
apps/erpnext/erpnext/accounts/page/pos/pos.js,Please select Apply Discount On,"Prosím, vyberte Použít Sleva na"
DocType: Stock Settings,Sample Retention Warehouse,Úložiště uchovávání vzorků
DocType: Company,Default Receivable Account,Výchozí pohledávek účtu
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Projected Quantity Formula,Předpokládané množství
DocType: Sales Invoice,Deemed Export,Považován za export
DocType: Pick List,Material Transfer for Manufacture,Materiál Přenos: Výroba
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.,Sleva v procentech lze použít buď proti Ceníku nebo pro všechny Ceníku.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Accounting Entry for Stock,Účetní položka na skladě
DocType: Lab Test,LabTest Approver,Nástroj LabTest
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,You have already assessed for the assessment criteria {}.,Již jste hodnotili kritéria hodnocení {}.
DocType: Vehicle Service,Engine Oil,Motorový olej
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Orders Created: {0},Vytvořené zakázky: {0}
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,Please set an email id for the Lead {0},Zadejte prosím e-mailové ID pro potenciálního zákazníka {0}
DocType: Sales Invoice,Sales Team1,Sales Team1
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} does not exist,Bod {0} neexistuje
DocType: Sales Invoice,Customer Address,Zákazník Address
DocType: Loan,Loan Details,půjčka Podrobnosti
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup post company fixtures,Nepodařilo se nastavit příslušenství společnosti
DocType: Company,Default Inventory Account,Výchozí účet inventáře
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The folio numbers are not matching,Čísla fólií se neodpovídají
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Request for {0},Žádost o platbu za {0}
DocType: Item Barcode,Barcode Type,Typ čárového kódu
DocType: Antibiotic,Antibiotic Name,Název antibiotika
apps/erpnext/erpnext/config/buying.py,Supplier Group master.,Hlavní dodavatel skupiny.
DocType: Healthcare Service Unit,Occupancy Status,Stav obsazení
apps/erpnext/erpnext/accounts/dashboard_chart_source/account_balance_timeline/account_balance_timeline.py,Account is not set for the dashboard chart {0},Účet není nastaven pro graf dashboardu {0}
DocType: Purchase Invoice,Apply Additional Discount On,Použít dodatečné Sleva na
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Type...,Vyberte typ ...
apps/erpnext/erpnext/templates/pages/help.html,Your tickets,Vaše lístky
DocType: Account,Root Type,Root Type
DocType: Item,FIFO,FIFO
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Close the POS,Zavřete POS
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 bodu {2}
DocType: Item Group,Show this slideshow at the top of the page,Zobrazit tuto prezentaci v horní části stránky
DocType: BOM,Item UOM,Položka UOM
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Částka daně po slevě Částka (Company měny)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Target warehouse is mandatory for row {0},Target sklad je povinná pro řadu {0}
apps/erpnext/erpnext/config/retail.py,Retail Operations,Maloobchodní operace
DocType: Cheque Print Template,Primary Settings,primární Nastavení
DocType: Attendance Request,Work From Home,Práce z domova
DocType: Purchase Invoice,Select Supplier Address,Vybrat Dodavatel Address
apps/erpnext/erpnext/public/js/event.js,Add Employees,Přidejte Zaměstnanci
DocType: Purchase Invoice Item,Quality Inspection,Kontrola kvality
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Extra Small,Extra Malé
DocType: Company,Standard Template,standardní šablona
DocType: Training Event,Theory,Teorie
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Warning: Material Requested Qty is less than Minimum Order Qty,Upozornění: Materiál Požadované množství je menší než minimální objednávka Množství
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Account {0} is frozen,Účet {0} je zmrazen
DocType: Quiz Question,Quiz Question,Kvízová otázka
DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,"Právní subjekt / dceřiná společnost s oddělenou Graf účtů, které patří do organizace."
DocType: Payment Request,Mute Email,Mute Email
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,"Food, Beverage & Tobacco","Potraviny, nápoje a tabák"
apps/erpnext/erpnext/controllers/buying_controller.py,"Cannot cancel this document as it is linked with submitted asset {0}.\
								Please cancel the it to continue.","Tento dokument nelze zrušit, protože je spojen s odeslaným podkladem {0}. \ Chcete-li pokračovat, zrušte jej."
DocType: Account,Account Number,Číslo účtu
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Can only make payment against unbilled {0},Lze provést pouze platbu proti nevyfakturované {0}
DocType: Call Log,Missed,Zmeškal
apps/erpnext/erpnext/controllers/selling_controller.py,Commission rate cannot be greater than 100,Rychlost Komise nemůže být větší než 100
apps/erpnext/erpnext/stock/doctype/item_manufacturer/item_manufacturer.py,Duplicate entry against the item code {0} and manufacturer {1},Duplicitní zadání oproti kódu položky {0} a výrobci {1}
DocType: Sales Invoice,Allocate Advances Automatically (FIFO),Automaticky přidělit předdavky (FIFO)
DocType: Volunteer,Volunteer,Dobrovolník
DocType: Buying Settings,Subcontract,Subdodávka
apps/erpnext/erpnext/public/js/utils/party.js,Please enter {0} first,"Prosím, zadejte {0} jako první"
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,No replies from,Žádné odpovědi od
DocType: Work Order Operation,Actual End Time,Aktuální End Time
DocType: Purchase Invoice Item,Manufacturer Part Number,Typové označení
DocType: Taxable Salary Slab,Taxable Salary Slab,Zdanitelná mzdová deska
DocType: Work Order Operation,Estimated Time and Cost,Odhadovná doba a náklady
apps/erpnext/erpnext/controllers/stock_controller.py,Quality Inspection: {0} is not submitted for the item: {1} in row {2},Kontrola kvality: {0} není zadán pro položku: {1} v řádku {2}
DocType: Bin,Bin,Popelnice
DocType: Bank Transaction,Bank Transaction,Bankovní transakce
DocType: Crop,Crop Name,Název plodiny
apps/erpnext/erpnext/hub_node/api.py,Only users with {0} role can register on Marketplace,Pouze uživatelé s rolí {0} se mohou zaregistrovat na trhu
DocType: SMS Log,No of Sent SMS,Počet odeslaných SMS
DocType: Leave Application,HR-LAP-.YYYY.-,HR-LAP-.YYYY.-
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py,Appointments and Encounters,Setkání a setkání
DocType: Antibiotic,Healthcare Administrator,Správce zdravotní péče
DocType: Dosage Strength,Dosage Strength,Síla dávkování
DocType: Healthcare Practitioner,Inpatient Visit Charge,Poplatek za návštěvu v nemocnici
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,Published Items,Publikované položky
DocType: Account,Expense Account,Účtet nákladů
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Software,Software
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Colour,Barevné
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Plan Assessment Criteria
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Transakce
DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Zabránit nákupním objednávkám
DocType: Coupon Code,Coupon Name,Název kupónu
apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Citlivý
DocType: Shift Type,Working Hours Calculation Based On,Výpočet pracovní doby na základě
apps/erpnext/erpnext/config/buying.py,Request for quotation.,Žádost o cenovou nabídku.
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","Prosím, vyberte položku, kde &quot;Je skladem,&quot; je &quot;Ne&quot; a &quot;je Sales Item&quot; &quot;Ano&quot; a není tam žádný jiný produkt Bundle"
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js,Select Customer,Vyberte zákazníka
DocType: Student Log,Academic,Akademický
DocType: Patient,Personal and Social History,Osobní a sociální historie
apps/erpnext/erpnext/education/doctype/guardian/guardian.py,User {0} created,Uživatel {0} byl vytvořen
DocType: Fee Schedule,Fee Breakup for each student,Rozdělení poplatků za každého studenta
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}) na objednávku {1} nemůže být větší než celkový součet ({2})
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Code,Změnit kód
DocType: Purchase Invoice Item,Valuation Rate,Ocenění
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Vytvoření variant
DocType: Vehicle,Diesel,motorová nafta
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Completed Quantity,Dokončené množství
apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Ceníková Měna není zvolena
DocType: Quick Stock Balance,Available Quantity,dostupné množství
DocType: Purchase Invoice,Availed ITC Cess,Využil ITC Cess
,Student Monthly Attendance Sheet,Student měsíční návštěvnost Sheet
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Pravidlo plavby platí pouze pro prodej
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Odpisový řádek {0}: Další datum odpisu nemůže být před datem nákupu
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Start Date,Datum zahájení projektu
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Until,Dokud
DocType: Rename Tool,Rename Log,Přejmenovat Přihlásit
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Student Group or Course Schedule is mandatory,Studentská skupina nebo program je povinný
DocType: Maintenance Visit Purpose,Against Document No,Proti dokumentu č
DocType: BOM,Scrap,Šrot
apps/erpnext/erpnext/config/selling.py,Manage Sales Partners.,Správa prodejních partnerů.
DocType: Quality Inspection,Inspection Type,Kontrola Type
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,All bank transactions have been created,Byly vytvořeny všechny bankovní transakce
DocType: Fee Validity,Visited yet,Ještě navštěvováno
apps/erpnext/erpnext/public/js/hub/pages/FeaturedItems.vue,You can Feature upto 8 items.,Můžete zadat až 8 položek.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to group.,Sklady se stávajícími transakce nelze převést na skupinu.
DocType: Assessment Result Tool,Result HTML,výsledek HTML
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í.
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expires On,vyprší dne
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,The total completed qty({0}) must be equal to qty to manufacture({1}),Celkové dokončené množství ({0}) se musí rovnat množství při výrobě ({1})
apps/erpnext/erpnext/utilities/activation.py,Add Students,Přidejte studenty
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js,Please select {0},"Prosím, vyberte {0}"
DocType: C-Form,C-Form No,C-Form No
DocType: Delivery Stop,Distance,Vzdálenost
DocType: Water Analysis,Storage Temperature,Skladovací teplota
DocType: Sales Order,SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-
DocType: Employee Attendance Tool,Unmarked Attendance,Neoznačené Návštěvnost
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Creating Payment Entries......,Vytváření položek platby ......
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Researcher,Výzkumník
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid public token error,Plaid public token error
DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Registrace do programu Student Tool
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 menší než datum ukončení úkolu {0}
,Consolidated Financial Statement,Konsolidovaný finanční výkaz
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py,Name or Email is mandatory,Jméno nebo e-mail je povinné
DocType: Instructor,Instructor Log,Příručka instruktora
DocType: Clinical Procedure,Clinical Procedure,Klinický postup
DocType: Shopify Settings,Delivery Note Series,Série dodacích poznámek
DocType: Purchase Order Item,Returned Qty,Vrácené Množství
DocType: Student,Exit,Východ
DocType: Communication Medium,Communication Medium,Komunikační médium
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root Type is mandatory,Root Type je povinné
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to install presets,Instalace předvoleb se nezdařila
DocType: Healthcare Service Unit Type,UOM Conversion in Hours,Převod UOM v hodinách
DocType: Contract,Signee Details,Signee Podrobnosti
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} v současné době disponuje {1} hodnotící tabulkou dodavatelů a RFQ tohoto dodavatele by měla být vydána s opatrností.
DocType: Certified Consultant,Non Profit Manager,Neziskový manažer
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} created,Pořadové číslo {0} vytvořil
DocType: Homepage,Company Description for website homepage,Společnost Popis pro webové stránky domovskou stránku
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ů, tyto kódy mohou být použity v tiskových formátech, jako na fakturách a dodacích listech"
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py,Suplier Name,Jméno suplier
apps/erpnext/erpnext/accounts/report/financial_statements.py,Could not retrieve information for {0}.,Nelze načíst informace pro {0}.
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py,Opening Entry Journal,Otevření deníku zápisu
DocType: Contract,Fulfilment Terms,Podmínky plnění
DocType: Sales Invoice,Time Sheet List,Doba Seznam Sheet
DocType: Healthcare Settings,Result Printed,Tiskový výsledek
DocType: Asset Category Account,Depreciation Expense Account,Odpisy Náklady účtu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Probationary Period,Zkušební doba
DocType: Tax Category,Is Inter State,Je Inter State
apps/erpnext/erpnext/config/hr.py,Shift Management,Shift Management
DocType: Customer Group,Only leaf nodes are allowed in transaction,Pouze koncové uzly jsou povoleny v transakci
DocType: Project,Total Costing Amount (via Timesheets),Celková částka kalkulování (prostřednictvím časových lístků)
DocType: Department,Expense Approver,Schvalovatel výdajů
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Řádek {0}: Advance proti zákazník musí být úvěr
DocType: Quality Meeting,Quality Meeting,Kvalitní setkání
apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-skupiny ke skupině
DocType: Employee,ERPNext User,ERPN další uživatel
DocType: Coupon Code,Coupon Description,Popis kupónu
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}
DocType: Company,Default Buying Terms,Výchozí nákupní podmínky
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Doklad o koupi Item Dodávané
DocType: Amazon MWS Settings,Enable Scheduled Synch,Povolit naplánovanou synchronizaci
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py,To Datetime,Chcete-li datetime
apps/erpnext/erpnext/config/crm.py,Logs for maintaining sms delivery status,Protokoly pro udržení stavu doručení sms
DocType: Accounts Settings,Make Payment via Journal Entry,Provést platbu přes Journal Entry
apps/erpnext/erpnext/controllers/item_variant.py,Please do not create more than 500 items at a time,Nevytvářejte více než 500 položek najednou
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Printed On,Vytištěno na
DocType: Clinical Procedure Template,Clinical Procedure Template,Šablona klinického postupu
DocType: Item,Inspection Required before Delivery,Inspekce Požadované před porodem
apps/erpnext/erpnext/config/education.py,Content Masters,Obsahové mastery
DocType: Item,Inspection Required before Purchase,Inspekce Požadované před nákupem
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Pending Activities,Nevyřízené Aktivity
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Lab Test,Vytvořit laboratorní test
DocType: Patient Appointment,Reminded,Připomenuto
DocType: Homepage Section,Cards,Karty
apps/erpnext/erpnext/public/js/setup_wizard.js,View Chart of Accounts,Zobrazit přehled účtů
DocType: Chapter Member,Chapter Member,Člen kapitoly
DocType: Material Request Plan Item,Minimum Order Quantity,Minimální množství pro objednání
apps/erpnext/erpnext/public/js/setup_wizard.js,Your Organization,Vaše organizace
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čit přidělení alokace pro následující zaměstnance, jelikož proti nim existují záznamy o přidělení alokace. {0}"
DocType: Fee Component,Fees Category,Kategorie poplatky
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please enter relieving date.,Zadejte zmírnění datum.
apps/erpnext/erpnext/controllers/trends.py,Amt,Amt
DocType: Travel Request,"Details of Sponsor (Name, Location)","Podrobnosti o sponzoru (název, umístění)"
DocType: Supplier Scorecard,Notify Employee,Upozornit zaměstnance
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Enter value betweeen {0} and {1},Zadejte hodnotu mezi {0} a {1}
DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,"Zadejte název kampaně, pokud zdroj šetření je kampaň"
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Newspaper Publishers,Vydavatelé novin
apps/erpnext/erpnext/hr/utils.py,Future dates not allowed,Budoucí data nejsou povolená
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
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Reorder Level,Změna pořadí Level
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Chart Of Accounts Template,Účtový rozvrh šablony
DocType: Attendance,Attendance Date,Účast Datum
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Update stock must be enable for the purchase invoice {0},Aktualizace akcií musí být povolena pro nákupní fakturu {0}
apps/erpnext/erpnext/stock/get_item_details.py,Item Price updated for {0} in Price List {1},Položka Cena aktualizován pro {0} v Ceníku {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Number Created,Sériové číslo vytvořeno
,DATEV,DATEV
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Plat rozpad na základě Zisk a dedukce.
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 hlavní účetní knihu
DocType: Purchase Invoice Item,Accepted Warehouse,Schválený sklad
DocType: Bank Reconciliation Detail,Posting Date,Datum zveřejnění
DocType: Item,Valuation Method,Metoda ocenění
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í pouze jednoho loajálního programu.
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Half Day,Mark Půldenní
DocType: Sales Invoice,Sales Team,Prodejní tým
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Duplicate entry,Duplicitní záznam
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.
DocType: Program Enrollment Tool,Get Students,Získat studenty
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Bank Data mapper doesn't exist,Mapovač bankovních dat neexistuje
DocType: Serial No,Under Warranty,V rámci záruky
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 karty na řádek."
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,[Error],[Chyba]
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Reconcile Entries,Smíření položek
DocType: Sales Order,In Words will be visible once you save the Sales Order.,"Ve slovech budou viditelné, jakmile uložíte prodejní objednávky."
,Employee Birthday,Narozeniny zaměstnance
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0}: Cost Center {1} does not belong to company {2},Řádek # {0}: Nákladové středisko {1} nepatří společnosti {2}
apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py,Please select Completion Date for Completed Repair,Zvolte datum dokončení dokončené opravy
DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Student Batch Účast Tool
apps/erpnext/erpnext/controllers/status_updater.py,Limit Crossed,Limit zkříženými
DocType: Appointment Booking Settings,Appointment Booking Settings,Nastavení rezervace schůzek
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js,Scheduled Upto,Naplánováno až
apps/erpnext/erpnext/hr/doctype/shift_type/shift_type.js,Attendance has been marked as per employee check-ins,Docházka byla označena podle odbavení zaměstnanců
DocType: Woocommerce Settings,Secret,Tajný
DocType: Plaid Settings,Plaid Secret,Plaid Secret
DocType: Company,Date of Establishment,Datum založení
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Venture Capital,Venture Capital
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 &quot;akademický rok &#39;{0} a&quot; Jméno Termín&#39; {1} již existuje. Upravte tyto položky a zkuste to znovu.
apps/erpnext/erpnext/stock/doctype/item/item.py,"As there are existing transactions against item {0}, you can not change the value of {1}",Stejně jako existují nějaké transakce proti položce {0} nelze změnit hodnotu {1}
DocType: UOM,Must be Whole Number,Musí být celé číslo
DocType: Campaign Email Schedule,Send After (days),Odeslat po (dny)
DocType: Leave Control Panel,New Leaves Allocated (In Days),Nové Listy Přidělené (ve dnech)
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse not found against the account {0},Sklad nebyl nalezen proti účtu {0}
DocType: Purchase Invoice,Invoice Copy,Kopie faktury
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,Serial No {0} does not exist,Pořadové číslo {0} neexistuje
DocType: Sales Invoice Item,Customer Warehouse (Optional),Zákaznický sklad (volitelně)
DocType: Blanket Order Item,Blanket Order Item,Dekorační objednávka zboží
DocType: Pricing Rule,Discount Percentage,Sleva v procentech
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sub contracting,Vyhrazeno pro uzavření smlouvy
DocType: Payment Reconciliation Invoice,Invoice Number,Číslo faktury
DocType: Shopping Cart Settings,Orders,Objednávky
DocType: Travel Request,Event Details,Podrobnosti události
DocType: Department,Leave Approver,Schvalovatel absenece
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select a batch,Vyberte dávku
DocType: Sales Invoice,Redemption Cost Center,Centrum nákupních nákladů
DocType: QuickBooks Migrator,Scope,Rozsah
DocType: Assessment Group,Assessment Group Name,Název skupiny Assessment
DocType: Manufacturing Settings,Material Transferred for Manufacture,Převádí jaderný materiál pro Výroba
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Add to Details,Přidat do podrobností
DocType: Travel Itinerary,Taxi,Taxi
DocType: Shopify Settings,Last Sync Datetime,Poslední datum synchronizace
DocType: Landed Cost Item,Receipt Document Type,Příjem Document Type
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal/Price Quote,Návrh / cenová nabídka
DocType: Antibiotic,Healthcare,Zdravotní péče
DocType: Target Detail,Target Detail,Target Detail
apps/erpnext/erpnext/stock/doctype/item/item.js,Single Variant,Jediný variant
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,All Jobs,Všechny Jobs
DocType: Sales Order,% of materials billed against this Sales Order,% materiálů fakturovaných proti této prodejní obědnávce
DocType: Program Enrollment,Mode of Transportation,Způsob dopravy
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"From a supplier under composition scheme, Exempt and Nil rated",Od dodavatele v rámci skladebního schématu je společnost Vyjímka a Nil hodnocena
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Period Closing Entry,Období Uzávěrka Entry
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Department...,Vyberte oddělení ...
DocType: Pricing Rule,Free Item,Zdarma položka
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Suppliies made to Composition Taxable Persons,Doplňky pro osoby povinné k dani ze složení
apps/erpnext/erpnext/regional/india/utils.py,Distance cannot be greater than 4000 kms,Vzdálenost nesmí být větší než 4000 km
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 se stávajícími transakcemi nelze převést do skupiny
DocType: QuickBooks Migrator,Authorization URL,Autorizační adresa URL
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} {2} {3},Množství {0} {1} {2} {3}
DocType: Account,Depreciation,Znehodnocení
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, prosím odstraňte zaměstnance <a href=""#Form/Employee/{0}"">{0}</a> \"
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í je nekonzistentní
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Supplier(s),Dodavatel (é)
DocType: Employee Attendance Tool,Employee Attendance Tool,Docházky zaměstnanců Tool
DocType: Guardian Student,Guardian Student,Guardian Student
DocType: Supplier,Credit Limit,Úvěrový limit
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Avg. Selling Price List Rate,Průměrné Míra prodejních cen
DocType: Loyalty Program Collection,Collection Factor (=1 LP),Faktor sbírky (= 1 LP)
DocType: Additional Salary,Salary Component,plat Component
apps/erpnext/erpnext/accounts/utils.py,Payment Entries {0} are un-linked,Platební Příspěvky {0} jsou un-spojený
DocType: GL Entry,Voucher No,Voucher No
,Lead Owner Efficiency,Vedoucí účinnost vlastníka
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Workday {0} has been repeated.,Pracovní den {0} byl opakován.
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 požadovat pouze částku {0}, zbývající částku {1} by měla být v aplikaci jako složka pro-rata"
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Employee A/C Number,Číslo A / C zaměstnance
DocType: Amazon MWS Settings,Customer Type,Typ zákazníka
DocType: Compensatory Leave Request,Leave Allocation,Přidelení dovolené
DocType: Payment Request,Recipient Message And Payment Details,Příjemce zprávy a platebních informací
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Please select a Delivery Note,Vyberte dodací list
DocType: Support Search Source,Source DocType,Zdroj DocType
apps/erpnext/erpnext/templates/pages/help.html,Open a new ticket,Otevřete novou lístek
DocType: Training Event,Trainer Email,trenér Email
DocType: Sales Invoice,Transporter,Přepravce
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Day Book Data,Importovat údaje o denní knize
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Priority {0} has been repeated.,Priorita {0} byla opakována.
DocType: Restaurant Reservation,No of People,Počet lidí
apps/erpnext/erpnext/config/accounts.py,Template of terms or contract.,Šablona podmínek nebo smlouvy.
DocType: Bank Account,Address and Contact,Adresa a Kontakt
DocType: Vital Signs,Hyper,Hyper
DocType: Cheque Print Template,Is Account Payable,Je účtu splatný
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Stock cannot be updated against Purchase Receipt {0},Sklad nelze aktualizovat proti dokladu o koupi {0}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Create Delivery Trip,Vytvořit doručovací cestu
DocType: Support Settings,Auto close Issue after 7 days,Auto v blízkosti Issue po 7 dnech
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ěleny před {0}, protože rovnováha dovolené již bylo carry-předávány v budoucí přidělení dovolenou záznamu {1}"
apps/erpnext/erpnext/accounts/party.py,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Poznámka: Z důvodu / Referenční datum překračuje povolené zákazníků úvěrové dní od {0} den (s)
DocType: Program Enrollment Tool,Student Applicant,Student Žadatel
DocType: Hub Tracked Item,Hub Tracked Item,Hubová sledovaná položka
DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINÁL PRO PŘÍJEMCE
DocType: Asset Category Account,Accumulated Depreciation Account,Účet oprávek
DocType: Certified Consultant,Discuss ID,Diskutujte o ID
DocType: Stock Settings,Freeze Stock Entries,Freeze Stock Příspěvky
DocType: Program Enrollment,Boarding Student,Stravující student
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Booking Actual Expenses,Uveďte prosím platný údaj o skutečných výdajích za rezervaci
DocType: Asset Finance Book,Expected Value After Useful Life,Očekávaná hodnota po celou dobu životnosti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For quantity {0} should not be greater than work order quantity {1},Pro množství {0} by nemělo být větší než množství pro pracovní objednávku {1}
DocType: Item,Reorder level based on Warehouse,Úroveň Změna pořadí na základě Warehouse
DocType: Activity Cost,Billing Rate,Fakturace Rate
,Qty to Deliver,Množství k dodání
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Disbursement Entry,Vytvořit záznam o výplatě
DocType: Amazon MWS Settings,Amazon will synch data updated after this date,Amazon bude synchronizovat data aktualizovaná po tomto datu
,Stock Analytics,Stock Analytics
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Operations cannot be left blank,Operace nemůže být prázdné
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Select a Default Priority.,Vyberte výchozí prioritu.
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,Lab Test(s) ,Laboratorní test (y)
DocType: Maintenance Visit Purpose,Against Document Detail No,Proti Detail dokumentu č
apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Smazání není povoleno pro zemi {0}
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Typ strana je povinná
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Použijte kód kupónu
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 zaměstnání {0} můžete provést pouze záznam typu „Převod materiálu pro výrobu“
DocType: Quality Inspection,Outgoing,Vycházející
DocType: Customer Feedback Table,Customer Feedback Table,Tabulka zpětné vazby od zákazníka
apps/erpnext/erpnext/config/support.py,Service Level Agreement.,Dohoda o úrovni služeb.
DocType: Material Request,Requested For,Požadovaných pro
DocType: Quotation Item,Against Doctype,Proti DOCTYPE
apps/erpnext/erpnext/controllers/selling_controller.py,{0} {1} is cancelled or closed,{0} {1} je zrušen nebo zavřené
DocType: Asset,Calculate Depreciation,Vypočítat odpisy
DocType: Delivery Note,Track this Delivery Note against any Project,Sledovat tento dodacím listu proti jakémukoli projektu
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Investing,Čistý peněžní tok z investiční
DocType: Purchase Invoice,Import Of Capital Goods,Dovoz investičního zboží
DocType: Work Order,Work-in-Progress Warehouse,Work-in-Progress sklad
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset {0} must be submitted,Asset {0} musí být předloženy
DocType: Fee Schedule Program,Total Students,Celkem studentů
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Attendance Record {0} exists against Student {1},Účast Record {0} existuje proti Student {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference #{0} dated {1},Reference # {0} ze dne {1}
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Eliminated due to disposal of assets,Odpisy vypadl v důsledku nakládání s majetkem
DocType: Employee Transfer,New Employee ID,Nové číslo zaměstnance
DocType: Loan,Member,Člen
DocType: Work Order Item,Work Order Item,Položka objednávky
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js,Show Opening Entries,Zobrazit otevírací položky
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.js,Unlink external integrations,Odpojte externí integrace
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Choose a corresponding payment,Vyberte odpovídající platbu
DocType: Pricing Rule,Item Code,Kód položky
DocType: Student,EDU-STU-.YYYY.-,EDU-STU-.YYYY.-
DocType: Serial No,Warranty / AMC Details,Záruka / AMC Podrobnosti
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Select students manually for the Activity based Group,Vyberte studenty ručně pro skupinu založenou na aktivitách
DocType: Journal Entry,User Remark,Uživatel Poznámka
DocType: Travel Itinerary,Non Diary,Bez deníku
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: Lead,Market Segment,Segment trhu
DocType: Agriculture Analysis Criteria,Agriculture Manager,Zemědělský manažer
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Paid Amount cannot be greater than total negative outstanding amount {0},Zaplacená částka nemůže být vyšší než celkový negativní dlužné částky {0}
DocType: Supplier Scorecard Period,Variables,Proměnné
DocType: Employee Internal Work History,Employee Internal Work History,Interní historie práce zaměstnance
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Closing (Dr),Uzavření (Dr)
DocType: Cheque Print Template,Cheque Size,Šek Velikost
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} not in stock,Pořadové číslo {0} není skladem
apps/erpnext/erpnext/config/accounts.py,Tax template for selling transactions.,Daňové šablona na prodej transakce.
DocType: Sales Invoice,Write Off Outstanding Amount,Odepsat dlužné částky
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}
DocType: Education Settings,Current Academic Year,Aktuální akademický rok
DocType: Stock Settings,Default Stock UOM,Výchozí Skladem UOM
DocType: Asset,Number of Depreciations Booked,Počet Odpisy rezervováno
apps/erpnext/erpnext/public/js/pos/pos.html,Qty Total,Množství celkem
DocType: Landed Cost Item,Receipt Document,příjem dokumentů
DocType: Employee Education,School/University,Škola / University
DocType: Sales Invoice Item,Available Qty at Warehouse,Množství k dispozici na skladu
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Billed Amount,Fakturovaná částka
DocType: Share Transfer,(including),(včetně)
DocType: Quality Review Table,Yes/No,Ano ne
DocType: Asset,Double Declining Balance,Double degresivní
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Closed order cannot be cancelled. Unclose to cancel.,Uzavřená objednávka nemůže být zrušen. Otevřít zrušit.
DocType: Amazon MWS Settings,Synch Products,Synchronizace produktů
DocType: Loyalty Point Entry,Loyalty Program,Věrnostní program
DocType: Student Guardian,Father,Otec
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Support Tickets,Vstupenky na podporu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,'Update Stock' cannot be checked for fixed asset sale,"""Aktualizace Sklad"" nemohou být zaškrtnuty na prodej dlouhodobého majetku"
DocType: Bank Reconciliation,Bank Reconciliation,Bank Odsouhlasení
DocType: Attendance,On Leave,Na odchodu
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Get Updates,Získat aktualizace
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ří do společnosti {3}
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 atributu.
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Please login as a Marketplace User to edit this item.,"Chcete-li tuto položku upravit, přihlaste se jako uživatel Marketplace."
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Material Request {0} is cancelled or stopped,Materiál Request {0} je zrušena nebo zastavena
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Dispatch State,Stav odeslání
apps/erpnext/erpnext/config/help.py,Leave Management,Správa absencí
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Groups,Skupiny
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Account,Seskupit podle účtu
DocType: Purchase Invoice,Hold Invoice,Podržte fakturu
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Please select Employee,Vyberte prosím zaměstnance
DocType: Sales Order,Fully Delivered,Plně Dodáno
DocType: Promotional Scheme Price Discount,Min Amount,Min. Částka
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Lower Income,S nižšími příjmy
DocType: Restaurant Order Entry,Current Order,Aktuální objednávka
DocType: Delivery Trip,Driver Address,Adresa řidiče
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Source and target warehouse cannot be same for row {0},Zdroj a cíl sklad nemůže být stejná pro řádek {0}
DocType: Account,Asset Received But Not Billed,"Aktivum bylo přijato, ale nebylo účtováno"
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","Rozdíl účet musí být typu aktiv / Odpovědnost účet, protože to Reklamní Smíření je Entry Otevření"
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Disbursed Amount cannot be greater than Loan Amount {0},Zaplacené částky nemůže být větší než Výše úvěru {0}
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ž částka, která nebyla požadována. {2}"
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Purchase Order number required for Item {0},Číslo vydané objednávky je potřebné k položce {0}
DocType: Leave Allocation,Carry Forwarded Leaves,Carry Předáno listy
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,'From Date' must be after 'To Date',"""Datum DO"" musí být po ""Datum OD"""
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.js,No Staffing Plans found for this Designation,Pro toto označení nebyly nalezeny plány personálního zabezpečení
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: Leave Policy Detail,Annual Allocation,Roční přidělení
DocType: Travel Request,Address of Organizer,Adresa pořadatele
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Healthcare Practitioner...,Vyberte zdravotnického lékaře ...
DocType: Employee Boarding Activity,Applicable in the case of Employee Onboarding,Platí pro zaměstnance na palubě
apps/erpnext/erpnext/config/accounts.py,Tax template for item tax rates.,Šablona daně pro sazby daně z zboží.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods Transferred,Převedené zboží
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Cannot change status as student {0} is linked with student application {1},Nemůže změnit statut studenta {0} je propojen s aplikací studentské {1}
DocType: Asset,Fully Depreciated,plně odepsán
DocType: Item Barcode,UPC-A,UPC-A
,Stock Projected Qty,Reklamní Plánovaná POČET
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Customer {0} does not belong to project {1},Zákazník {0} nepatří k projektu {1}
DocType: Employee Attendance Tool,Marked Attendance HTML,Výrazná Účast HTML
apps/erpnext/erpnext/utilities/activation.py,"Quotations are proposals, bids you have sent to your customers","Citace jsou návrhy, nabídky jste svým zákazníkům odeslané"
DocType: Sales Invoice,Customer's Purchase Order,Zákazníka Objednávka
DocType: Clinical Procedure,Patient,Pacient
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Bypass credit check at Sales Order ,Objednávka kreditu bypassu na objednávce
DocType: Employee Onboarding Activity,Employee Onboarding Activity,Činnost zaměstnanců na palubě
DocType: Location,Check if it is a hydroponic unit,"Zkontrolujte, zda jde o hydroponickou jednotku"
DocType: Pick List Item,Serial No and Batch,Pořadové číslo a Batch
DocType: Warranty Claim,From Company,Od Společnosti
DocType: GSTR 3B Report,January,leden
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,Sum of Scores of Assessment Criteria needs to be {0}.,Součet skóre hodnotících kritérií musí být {0}.
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please set Number of Depreciations Booked,Prosím nastavte Počet Odpisy rezervováno
DocType: Supplier Scorecard Period,Calculations,Výpočty
apps/erpnext/erpnext/public/js/stock_analytics.js,Value or Qty,Hodnota nebo Množství
DocType: Payment Terms Template,Payment Terms,Platební podmínky
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Productions Orders cannot be raised for:,Productions Objednávky nemůže být zvýšena pro:
DocType: Quality Meeting Minutes,Minute,Minuta
DocType: Purchase Invoice,Purchase Taxes and Charges,Nákup Daně a poplatky
DocType: Chapter,Meetup Embed HTML,Meetup Embed HTML
DocType: Asset,Insured value,Pojistná hodnota
DocType: POS Closing Voucher Taxes,POS Closing Voucher Taxes,Závěrečné dluhopisy POS
,Qty to Receive,Množství pro příjem
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é datum, které nejsou v platném mzdovém období, nelze vypočítat {0}."
DocType: Leave Block List,Leave Block List Allowed,Nechte Block List povolena
DocType: Grading Scale Interval,Grading Scale Interval,Klasifikační stupnice Interval
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Expense Claim for Vehicle Log {0},Náklady Nárok na Vehicle Log {0}
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Sleva (%) na cenovou nabídku s marží
DocType: Healthcare Service Unit Type,Rate / UOM,Rate / UOM
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py,All Warehouses,Celý sklad
apps/erpnext/erpnext/hooks.py,Appointment Booking,Rezervace schůzek
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,No {0} found for Inter Company Transactions.,Nebylo nalezeno {0} pro interní transakce společnosti.
DocType: Travel Itinerary,Rented Car,Pronajaté auto
apps/erpnext/erpnext/public/js/hub/components/profile_dialog.js,About your Company,O vaší společnosti
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Show Stock Ageing Data,Zobrazit údaje o stárnutí populace
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Balance Sheet account,Připsat na účet musí být účtu Rozvaha
DocType: Donor,Donor,Dárce
apps/erpnext/erpnext/regional/doctype/gst_hsn_code/gst_hsn_code.js,Update Taxes for Items,Aktualizace daní za položky
DocType: Global Defaults,Disable In Words,Zakázat ve slovech
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Quotation {0} not of type {1},Nabídka {0} není typu {1}
DocType: Maintenance Schedule Item,Maintenance Schedule Item,Plán údržby Item
DocType: Sales Order,%  Delivered,% Dodáno
apps/erpnext/erpnext/education/doctype/fees/fees.js,Please set the Email ID for the Student to send the Payment Request,"Prosím, nastavte ID e-mailu, aby Student odeslal Žádost o platbu"
DocType: Skill,Skill Name,Jméno dovednosti
DocType: Patient,Medical History,Zdravotní historie
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Bank Overdraft Account,Kontokorentní úvěr na účtu
DocType: Patient,Patient ID,ID pacienta
DocType: Practitioner Schedule,Schedule Name,Název plánu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.py,Please enter GSTIN and state for the Company Address {0},Zadejte GSTIN a uveďte adresu společnosti {0}
DocType: Currency Exchange,For Buying,Pro nákup
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Při zadávání objednávky
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Přidat všechny dodavatele
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ž zůstatek.
DocType: Tally Migration,Parties,Strany
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Procházet kusovník
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Zajištěné úvěry
DocType: Purchase Invoice,Edit Posting Date and Time,Úpravy účtování Datum a čas
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set Depreciation related Accounts in Asset Category {0} or Company {1},"Prosím, amortizace účty s ním souvisejících v kategorii Asset {0} nebo {1} Company"
DocType: Lab Test Groups,Normal Range,Normální vzdálenost
DocType: Call Log,Call Duration in seconds,Délka hovoru v sekundách
DocType: Academic Term,Academic Year,Akademický rok
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Available Selling,Dostupné prodeje
DocType: Loyalty Point Entry Redemption,Loyalty Point Entry Redemption,Vrácení bodů vkladů
apps/erpnext/erpnext/config/accounts.py,Cost Center and Budgeting,Nákladové středisko a rozpočtování
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Opening Balance Equity,Počáteční stav Equity
DocType: Appointment,CRM,CRM
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Payment Schedule,Nastavte prosím časový rozvrh plateb
DocType: Pick List,Items under this warehouse will be suggested,Položky v tomto skladu budou navrženy
DocType: Purchase Invoice,N,N
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Remaining,Zbývající
DocType: Appraisal,Appraisal,Ocenění
DocType: Loan,Loan Account,Úvěrový účet
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from and valid upto fields are mandatory for the cumulative,Kumulativní jsou povinná a platná až pole
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.py,"For item {0} at row {1}, count of serial numbers does not match with the picked quantity",U položky {0} v řádku {1} se počet sériových čísel neshoduje s vybraným množstvím
DocType: Purchase Invoice,GST Details,Podrobnosti GST
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 zdravotnickému lékaři.
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Email sent to supplier {0},E-mailu zaslaného na dodavatele {0}
DocType: Item,Default Sales Unit of Measure,Výchozí prodejní jednotka měření
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Academic Year: ,Akademický rok:
DocType: Inpatient Record,Admission Schedule Date,Datum příjezdu
DocType: Subscription,Past Due Date,Datum splatnosti
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Neumožňuje nastavit alternativní položku pro položku {0}
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Datum se opakuje
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Prokurista
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Dostupné ITC (A) - (B)
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Vytvořte poplatky
DocType: Project,Total Purchase Cost (via Purchase Invoice),Celkové pořizovací náklady (přes nákupní faktury)
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Select Quantity,Zvolte množství
DocType: Loyalty Point Entry,Loyalty Points,Věrnostní body
DocType: Customs Tariff Number,Customs Tariff Number,Celního sazebníku
DocType: Employee Tax Exemption Proof Submission Detail,Maximum Exemption Amount,Maximální částka pro výjimku
DocType: Products Settings,Item Fields,Pole položek
DocType: Patient Appointment,Patient Appointment,Setkání pacienta
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 pravidlo se vztahuje na
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Unsubscribe from this Email Digest,Odhlásit se z tohoto Email Digest
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Get Suppliers By,Získejte dodavatele
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,{0} not found for Item {1},{0} nebyl nalezen pro položku {1}
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: Accounts Settings,Show Inclusive Tax In Print,Zobrazit inkluzivní daň v tisku
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é"
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Message Sent,Zpráva byla odeslána
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with child nodes cannot be set as ledger,Účet s podřízené uzly nelze nastavit jako hlavní knihy
DocType: C-Form,II,II
apps/erpnext/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py,Vendor Name,Jméno prodejce
DocType: Quiz Result,Wrong,Špatně
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Sazba, za kterou je ceníková měna převedena na základní měnu zákazníka"
DocType: Purchase Invoice Item,Net Amount (Company Currency),Čistá částka (Company Měna)
DocType: Sales Partner,Referral Code,Kód doporučení
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Celková výše zálohy nesmí být vyšší než celková částka sankce
DocType: Salary Slip,Hour Rate,Hour Rate
apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Povolit automatické opětovné objednání
DocType: Stock Settings,Item Naming By,Položka Pojmenování By
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Another Period Closing Entry {0} has been made after {1},Další období Uzávěrka Entry {0} byla podána po {1}
DocType: Work Order,Material Transferred for Manufacturing,Materiál Přenesená pro výrobu
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Account {0} does not exists,Účet {0} neexistuje
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Select Loyalty Program,Vyberte Věrnostní program
DocType: Project,Project Type,Typ projektu
apps/erpnext/erpnext/projects/doctype/task/task.py,Child Task exists for this Task. You can not delete this Task.,Dětská úloha existuje pro tuto úlohu. Tuto úlohu nelze odstranit.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,Either target qty or target amount is mandatory.,Buď cílové množství nebo cílová částka je povinná.
apps/erpnext/erpnext/config/projects.py,Cost of various activities,Náklady na různých aktivit
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í do {0}, protože zaměstnanec připojena k níže prodejcům nemá ID uživatele {1}"
DocType: Timesheet,Billing Details,fakturační údaje
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Source and target warehouse must be different,Zdrojové a cílové sklad se musí lišit
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Failed. Please check your GoCardless Account for more details,Platba selhala. Zkontrolujte svůj účet GoCardless pro více informací
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Not allowed to update stock transactions older than {0},Není dovoleno měnit obchodů s akciemi starší než {0}
DocType: Stock Entry,Inspection Required,Kontrola Povinné
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the Bank Guarantee Number before submittting.,Zadejte číslo bankovní záruky před odesláním.
DocType: Sales Order,Fully Billed,Plně Fakturovaný
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
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Buying,Pravidlo plavby platí pouze pro nákup
DocType: Vital Signs,BMI,BMI
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Cash In Hand,Pokladní hotovost
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Delivery warehouse required for stock item {0},Dodávka sklad potřebný pro živočišnou položku {0}
DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Celková hmotnost balení. Obvykle se čistá hmotnost + obalového materiálu hmotnosti. (Pro tisk)
DocType: Assessment Plan,Program,Program
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í se mohou nastavit na zmrazené účty a vytvořit / upravit účetní zápisy proti zmrazených účtů
DocType: Plaid Settings,Plaid Environment,Plaid Environment
,Project Billing Summary,Přehled fakturace projektu
DocType: Vital Signs,Cuts,Řezy
DocType: Serial No,Is Cancelled,Je Zrušeno
DocType: Student Group,Group Based On,Skupina založená na
DocType: Journal Entry,Bill Date,Datum účtu
DocType: Healthcare Settings,Laboratory SMS Alerts,Laboratorní SMS upozornění
DocType: Manufacturing Settings,Over Production for Sales and Work Order,Over Production for Sales and Work Order
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,"Service Item,Type,frequency and expense amount are required","je nutný servisní položky, typ, frekvence a množství náklady"
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 pravidla pro tvorbu cen s nejvyšší prioritou, pak následující interní priority jsou použity:"
DocType: Plant Analysis Criteria,Plant Analysis Criteria,Kritéria analýzy rostlin
DocType: Cheque Print Template,Cheque Height,Šek Výška
DocType: Supplier,Supplier Details,Dodavatele Podrobnosti
DocType: Setup Progress,Setup Progress,Pokročilé nastavení
DocType: Expense Claim,Approval Status,Stav schválení
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,From value must be less than to value in row {0},Z hodnota musí být menší než hodnota v řadě {0}
DocType: Program,Intro Video,Úvodní video
DocType: Manufacturing Settings,Default Warehouses for Production,Výchozí sklady pro výrobu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Wire Transfer,Bankovní převod
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,From Date must be before To Date,Datum od musí být dříve než datum do
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Check all,Zkontrolovat vše
,Issued Items Against Work Order,Vydávané položky proti pracovní zakázce
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.js,Vacancies cannot be lower than the current openings,Volná pracovní místa nemohou být nižší než stávající otvory
,BOM Stock Calculated,Výpočet zásob BOM
DocType: Vehicle Log,Invoice Ref,Faktura Ref
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non-GST outward supplies,Externí spotřební materiál mimo GST
DocType: Company,Default Income Account,Účet Default příjmů
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Patient History,Historie pacientů
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Unclosed Fiscal Years Profit / Loss (Credit),Neuzavřený fiskálních let Zisk / ztráta (Credit)
DocType: Sales Invoice,Time Sheets,čas listy
DocType: Healthcare Service Unit Type,Change In Item,Změna položky
DocType: Payment Gateway Account,Default Payment Request Message,Výchozí Platba Request Message
DocType: Retention Bonus,Bonus Amount,Bonusová částka
DocType: Item Group,Check this if you want to show in website,"Zaškrtněte, pokud chcete zobrazit v webové stránky"
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Balance ({0}),Zůstatek ({0})
DocType: Loyalty Point Entry,Redeem Against,Vykoupit proti
apps/erpnext/erpnext/config/accounts.py,Banking and Payments,Bankovnictví a platby
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Key,Zadejte prosím klíč API pro spotřebitele
DocType: Issue,Service Level Agreement Fulfilled,Splněna dohoda o úrovni služeb
,Welcome to ERPNext,Vítejte na ERPNext
apps/erpnext/erpnext/config/crm.py,Lead to Quotation,Lead na nabídku
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Email Reminders will be sent to all parties with email contacts,E-mailové připomenutí budou zasílány všem stranám s e-mailovými kontakty
DocType: Project,Twice Daily,Dvakrát denně
DocType: Inpatient Record,A Negative,Negativní
apps/erpnext/erpnext/templates/includes/product_list.js,Nothing more to show.,Nic víc ukázat.
DocType: Lead,From Customer,Od Zákazníka
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Calls,Volá
DocType: Employee Tax Exemption Declaration,Declarations,Prohlášení
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batches,Dávky
DocType: Appointment Booking Settings,Number of days appointments can be booked in advance,Počet dní schůzek si můžete rezervovat předem
DocType: Article,LMS User,Uživatel LMS
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Place Of Supply (State/UT),Místo dodávky (stát / UT)
DocType: Purchase Order Item Supplied,Stock UOM,Reklamní UOM
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Purchase Order {0} is not submitted,Vydaná objednávka {0} není odeslána
DocType: Account,Expenses Included In Asset Valuation,Náklady zahrnuté do ocenění majetku
DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normální referenční rozsah pro dospělou osobu je 16-20 dechů / minutu (RCP 2012)
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Set Response Time and Resolution for Priority {0} at index {1}.,Nastavte čas odezvy a rozlišení pro prioritu {0} na indexu {1}.
DocType: Customs Tariff Number,Tariff Number,tarif Počet
DocType: Work Order Item,Available Qty at WIP Warehouse,Dostupné množství v WIP skladu
apps/erpnext/erpnext/stock/doctype/item/item.js,Projected,Plánovaná
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Warehouse {1},Pořadové číslo {0} nepatří do skladu {1}
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 přes dobírku a over-rezervace pro item {0} jako množství nebo částka je 0
DocType: Issue,Opening Date,Datum otevření
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please save the patient first,Nejprve uložit pacienta
apps/erpnext/erpnext/education/api.py,Attendance has been marked successfully.,Účast byla úspěšně označena.
DocType: Program Enrollment,Public Transport,Veřejná doprava
DocType: Sales Invoice,GST Vehicle Type,Typ vozidla GST
DocType: Soil Texture,Silt Composition (%),Složené složení (%)
DocType: Journal Entry,Remark,Poznámka
DocType: Healthcare Settings,Avoid Confirmation,Vyhněte se potvrzení
DocType: Bank Account,Integration Details,Podrobnosti o integraci
DocType: Purchase Receipt Item,Rate and Amount,Cena a částka
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}
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Cannot Calculate Arrival Time as Driver Address is Missing.,"Nelze vypočítat čas příjezdu, protože chybí adresa řidiče."
DocType: Education Settings,Current Academic Term,Aktuální akademické označení
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Item added,Řádek # {0}: Položka byla přidána
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Service Start Date cannot be greater than Service End Date,Řádek # {0}: Datum zahájení služby nesmí být větší než datum ukončení služby
DocType: Sales Order,Not Billed,Ne Účtovaný
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Both Warehouse must belong to same Company,Oba Sklady musí patřit do stejné společnosti
DocType: Employee Grade,Default Leave Policy,Výchozí podmínky pro dovolenou
DocType: Shopify Settings,Shop URL,Adresa URL obchodu
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,The selected payment entry should be linked with a debtor bank transaction,Vybraný platební záznam by měl být spojen s transakcí s dlužníkem
apps/erpnext/erpnext/public/js/templates/contact_list.html,No contacts added yet.,Žádné kontakty přidán dosud.
DocType: Communication Medium Timeslot,Communication Medium Timeslot,Komunikační střední Timeslot
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Přistál Náklady Voucher Částka
,Item Balance (Simple),Balance položky (jednoduché)
apps/erpnext/erpnext/config/accounts.py,Bills raised by Suppliers.,Směnky vznesené dodavately
DocType: POS Profile,Write Off Account,Odepsat účet
DocType: Patient Appointment,Get prescribed procedures,Získejte předepsané postupy
DocType: Sales Invoice,Redemption Account,Účet zpětného odkupu
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.js,First add items in the Item Locations table,Nejprve přidejte položky do tabulky Umístění položky
DocType: Pricing Rule,Discount Amount,Částka slevy
DocType: Pricing Rule,Period Settings,Nastavení období
DocType: Purchase Invoice,Return Against Purchase Invoice,Návrat proti nákupní faktury
DocType: Item,Warranty Period (in days),Záruční doba (ve dnech)
DocType: Shift Type,Enable Entry Grace Period,Povolit období odkladu vstupu
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian1,Souvislost s Guardian1
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},Vyberte prosím kusovníku podle položky {0}
DocType: Shopping Cart Settings,Show Stock Quantity,Zobrazit množství zásob
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Čistý peněžní tok z provozní
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Bod 4
DocType: Student Admission,Admission End Date,Vstupné Datum ukončení
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Subdodávky
DocType: Journal Entry Account,Journal Entry Account,Zápis do deníku Účet
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js,Student Group,Student Group
DocType: Shopping Cart Settings,Quotation Series,Číselná řada nabídek
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}), prosím, změnit název skupiny položky nebo přejmenovat položku"
DocType: Soil Analysis Criteria,Soil Analysis Criteria,Kritéria analýzy půdy
DocType: Pricing Rule Detail,Pricing Rule Detail,Detail pravidla stanovení cen
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create BOM,Vytvořte kusovník
DocType: Pricing Rule,Apply Rule On Item Group,Použít pravidlo na skupinu položek
apps/erpnext/erpnext/accounts/page/pos/pos.js,Please select customer,Vyberte zákazníka
DocType: Employee Tax Exemption Declaration,Total Declared Amount,Celková deklarovaná částka
DocType: C-Form,I,já
DocType: Company,Asset Depreciation Cost Center,Asset Odpisy nákladového střediska
apps/erpnext/erpnext/templates/generators/item/item_configure.js,{0} item found.,Byla nalezena položka {0}.
DocType: Production Plan Sales Order,Sales Order Date,Prodejní objednávky Datum
DocType: Sales Invoice Item,Delivered Qty,Dodává Množství
DocType: Assessment Plan,Assessment Plan,Plan Assessment
DocType: Travel Request,Fully Sponsored,Plně sponzorováno
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Zadání reverzního deníku
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Vytvořit pracovní kartu
DocType: Quotation,Referral Sales Partner,Prodejní partner pro doporučení
DocType: Quality Procedure Process,Process Description,Popis procesu
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Zákazník {0} je vytvořen.
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,V současné době žádné skladové zásoby nejsou k dispozici
,Payment Period Based On Invoice Date,Platební období na základě data vystavení faktury
DocType: Sample Collection,No. of print,Počet tisku
apps/erpnext/erpnext/education/doctype/question/question.py,No correct answer is set for {0},Pro {0} není nastavena žádná správná odpověď
DocType: Issue,Response By,Odpověď od
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Birthday Reminder,Připomenutí narozenin
DocType: Chart of Accounts Importer,Chart Of Accounts Importer,Dovozce grafů účtů
DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,Položka rezervace pokojů v hotelu
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Missing Currency Exchange Rates for {0},Chybí Směnárna Kurzy pro {0}
DocType: Employee Health Insurance,Health Insurance Name,Název zdravotního pojištění
DocType: Assessment Plan,Examiner,Zkoušející
DocType: Student,Siblings,sourozenci
DocType: Journal Entry,Stock Entry,Skladový pohyb
DocType: Payment Entry,Payment References,Platební Reference
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 intervalové pole, např. Pokud je interval &quot;Dny&quot; a počet fakturačních intervalů je 3, budou faktury generovány každých 3 dny"
DocType: Clinical Procedure Template,Allow Stock Consumption,Povolit skladovou spotřebu
DocType: Asset,Insurance Details,pojištění Podrobnosti
DocType: Account,Payable,Splatný
DocType: Share Balance,Share Type,Typ sdílení
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter Repayment Periods,"Prosím, zadejte dobu splácení"
apps/erpnext/erpnext/shopping_cart/cart.py,Debtors ({0}),Dlužníci ({0})
DocType: Pricing Rule,Margin,Marže
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,New Customers,Noví zákazníci
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Gross Profit %,Hrubý Zisk %
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Appointment {0} and Sales Invoice {1} cancelled,Přihláška {0} a prodejní faktura {1} byla zrušena
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Opportunities by lead source,Možnosti podle zdroje olova
DocType: Appraisal Goal,Weightage (%),Weightage (%)
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Change POS Profile,Změňte profil POS
DocType: Bank Reconciliation Detail,Clearance Date,Výprodej Datum
DocType: Delivery Settings,Dispatch Notification Template,Šablona oznámení o odeslání
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Report,Zpráva o hodnocení
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Get Employees,Získejte zaměstnance
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Add your review,Přidejte svůj názor
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Gross Purchase Amount is mandatory,Gross Částka nákupu je povinná
apps/erpnext/erpnext/setup/doctype/company/company.js,Company name not same,Název společnosti není stejný
DocType: Sales Partner,Address Desc,Popis adresy
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party is mandatory,Party je povinná
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.py,Please set account heads in GST Settings for Compnay {0},Nastavte prosím hlavičky účtu v Nastavení GST pro Compnay {0}
DocType: Course Topic,Topic Name,Název tématu
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Approval Notification in HR Settings.,Prosím nastavte výchozí šablonu pro Notification Notification při nastavení HR.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Atleast one of the Selling or Buying must be selected,Aspoň jeden z prodeje nebo koupě musí být zvolena
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Select an employee to get the employee advance.,"Vyberte zaměstnance, chcete-li zaměstnance předem."
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please select a valid Date,Vyberte prosím platný datum
apps/erpnext/erpnext/public/js/setup_wizard.js,Select the nature of your business.,Vyberte podstatu svého podnikání.
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.","Single pro výsledky, které vyžadují pouze jeden vstup, výsledek UOM a normální hodnota <br> Sloučenina pro výsledky, které vyžadují více vstupních polí s odpovídajícími názvy událostí, výsledky UOM a normální hodnoty <br> Popisné pro testy, které mají více komponent výsledků a odpovídající pole pro vyplnění výsledků. <br> Seskupeny pro testovací šablony, které jsou skupinou dalších zkušebních šablon. <br> Žádný výsledek pro testy bez výsledků. Také není vytvořen žádný laboratorní test. např. Podtřídy pro seskupené výsledky."
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Duplicate entry in References {1} {2},Řádek # {0}: Duplicitní záznam v odkazu {1} {2}
apps/erpnext/erpnext/config/manufacturing.py,Where manufacturing operations are carried.,"Tam, kde jsou výrobní operace prováděny."
apps/erpnext/erpnext/education/doctype/instructor/instructor.js,As Examiner,Jako zkoušející
DocType: Company,Default Expense Claim Payable Account,Splatný účet s předběžným výdajovým nárokem
DocType: Appointment Type,Default Duration,Výchozí doba trvání
DocType: BOM Explosion Item,Source Warehouse,Zdroj Warehouse
DocType: Installation Note,Installation Date,Datum instalace
apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js,Share Ledger,Sdílet knihu
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Sales Invoice {0} created,Byla vytvořena prodejní faktura {0}
DocType: Employee,Confirmation Date,Potvrzení Datum
DocType: Inpatient Occupancy,Check Out,Překontrolovat
DocType: C-Form,Total Invoiced Amount,Celkem Fakturovaná částka
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Min Qty can not be greater than Max Qty,Min množství nemůže být větší než Max Množství
DocType: Soil Texture,Silty Clay,Silty Clay
DocType: Account,Accumulated Depreciation,oprávky
DocType: Supplier Scorecard Scoring Standing,Standing Name,Stálé jméno
DocType: Stock Entry,Customer or Supplier Details,Zákazníka nebo dodavatele Podrobnosti
DocType: Payment Entry,ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-
DocType: Asset Value Adjustment,Current Asset Value,Aktuální hodnota aktiv
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM recursion: {0} cannot be parent or child of {1},Rekurze kusovníku: {0} nemůže být rodič nebo dítě {1}
DocType: QuickBooks Migrator,Quickbooks Company ID,Identifikační čísla společnosti Quickbooks
DocType: Travel Request,Travel Funding,Financování cest
DocType: Employee Skill,Proficiency,Znalost
DocType: Loan Application,Required by Date,Vyžadováno podle data
DocType: Purchase Invoice Item,Purchase Receipt Detail,Detail dokladu o nákupu
DocType: Crop Cycle,A link to all the Locations in which the Crop is growing,"Odkaz na všechna místa, ve kterých rostou rostliny"
DocType: Lead,Lead Owner,Majitel leadu
DocType: Bin,Requested Quantity,Požadované množství
DocType: Pricing Rule,Party Information,Informace o večírku
DocType: Fees,EDU-FEE-.YYYY.-,EDU-FEE-.RRRR.-
DocType: Patient,Marital Status,Rodinný stav
DocType: Stock Settings,Auto Material Request,Auto materiálu Poptávka
DocType: Woocommerce Settings,API consumer secret,API spotřebitelské tajemství
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,K dispozici šarže Množství na Od Warehouse
,Received Qty Amount,Přijatá částka Množství
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Hrubé mzdy - Total dedukce - splátky
DocType: Bank Account,Last Integration Date,Datum poslední integrace
DocType: Expense Claim,Expense Taxes and Charges,Nákladové daně a poplatky
DocType: Bank Account,IBAN,IBAN
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Current BOM and New BOM can not be same,Aktuální BOM a nový BOM nemůže být stejný
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py,Salary Slip ID,Plat Slip ID
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 spojování"
apps/erpnext/erpnext/stock/doctype/item/item.js,Multiple Variants,Více variant
DocType: Sales Invoice,Against Income Account,Proti účet příjmů
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Delivered,{0}% dodáno
DocType: Subscription,Trial Period Start Date,Datum zahájení zkušebního období
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 nižší než minimální Objednané množství {2} (definované v bodu).
DocType: Certification Application,Certified,Certifikováno
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Měsíční Distribution Procento
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Party can only be one of ,Strana může být pouze jedním z
apps/erpnext/erpnext/regional/india/utils.py,Please mention Basic and HRA component in Company,Uveďte prosím součást Basic a HRA ve společnosti
DocType: Daily Work Summary Group User,Daily Work Summary Group User,Denní uživatel shrnutí skupiny práce
DocType: Territory,Territory Targets,Území Cíle
DocType: Soil Analysis,Ca/Mg,Ca / Mg
DocType: Sales Invoice,Transporter Info,Transporter Info
apps/erpnext/erpnext/accounts/utils.py,Please set default {0} in Company {1},Prosím nastavit výchozí {0} ve firmě {1}
DocType: Cheque Print Template,Starting position from top edge,Výchozí poloha od horního okraje
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Same supplier has been entered multiple times,Stejný dodavatel byl zadán vícekrát
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py,Gross Profit / Loss,Hrubý zisk / ztráta
,Warehouse wise Item Balance Age and Value,Warehouse wise Item Balance věk a hodnota
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Achieved ({}),Dosažené ({})
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Dodané položky vydané objednávky
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Name cannot be Company,Název společnosti nemůže být Company
apps/erpnext/erpnext/support/doctype/issue/issue.py,{0} parameter is invalid,{0} parametr je neplatný
apps/erpnext/erpnext/config/settings.py,Letter Heads for print templates.,Hlavičkové listy pro tisk šablon.
apps/erpnext/erpnext/config/settings.py,Titles for print templates e.g. Proforma Invoice.,"Tituly na tiskových šablon, např zálohové faktury."
DocType: Program Enrollment,Walking,Chůze
DocType: Student Guardian,Student Guardian,Student Guardian
DocType: Member,Member Name,Jméno člena
DocType: Stock Settings,Use Naming Series,Používejte sérii pojmenování
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,No Action,Žádná akce
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Valuation type charges can not marked as Inclusive,Poplatky typu ocenění může není označen jako Inclusive
DocType: POS Profile,Update Stock,Aktualizace skladem
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é UOM položky povede k nesprávné (celkem) Čistá hmotnost hodnoty. Ujistěte se, že čistá hmotnost každé položky je ve stejném nerozpuštěných."
DocType: Certification Application,Payment Details,Platební údaje
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM Rate
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Čtení nahraného souboru
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Zastavená pracovní objednávka nemůže být zrušena, zrušte její zrušení"
DocType: Coupon Code,Coupon Code,Kód kupónu
DocType: Asset,Journal Entry for Scrap,Zápis do deníku do šrotu
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,"Prosím, vytáhněte položky z dodací list"
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}
apps/erpnext/erpnext/accounts/utils.py,Journal Entries {0} are un-linked,Zápisů {0} jsou un-spojený
apps/erpnext/erpnext/accounts/utils.py,{0} Number {1} already used in account {2},{0} Číslo {1} již použité v účtu {2}
apps/erpnext/erpnext/config/crm.py,"Record of all communications of type email, phone, chat, visit, etc.","Záznam všech sdělení typu e-mail, telefon, chat, návštěvy, atd"
DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Hodnocení skóre dodavatele skóre
DocType: Manufacturer,Manufacturers used in Items,Výrobci používané v bodech
apps/erpnext/erpnext/accounts/general_ledger.py,Please mention Round Off Cost Center in Company,"Prosím, uveďte zaokrouhlit nákladové středisko ve společnosti"
DocType: Purchase Invoice,Terms,Podmínky
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Select Days,Vyberte dny
DocType: Academic Term,Term Name,termín Name
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the correct code on Mode of Payment {1},Řádek {0}: Nastavte prosím správný kód v platebním režimu {1}
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Credit ({0}),Úvěr ({0})
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Creating Salary Slips...,Vytváření salicích ...
apps/erpnext/erpnext/hr/doctype/department/department.js,You cannot edit root node.,Nelze upravit kořenový uzel.
DocType: Buying Settings,Purchase Order Required,Vydaná objednávka je vyžadována
apps/erpnext/erpnext/public/js/projects/timer.js,Timer,Časovač
,Item-wise Sales History,Item-moudrý Sales History
DocType: Expense Claim,Total Sanctioned Amount,Celková částka potrestána
,Purchase Analytics,Nákup Analytika
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 pružné výhody {0} by neměla být menší než maximální dávka {1}
DocType: Sales Invoice Item,Delivery Note Item,Delivery Note Item
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Current invoice {0} is missing,Aktuální faktura {0} chybí
apps/erpnext/erpnext/controllers/accounts_controller.py,Row {0}: user has not applied the rule {1} on the item {2},Řádek {0}: uživatel na položku {2} neuplatnil pravidlo {1}
DocType: Asset Maintenance Log,Task,Úkol
DocType: Purchase Taxes and Charges,Reference Row #,Referenční Row #
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/setup/doctype/sales_person/sales_person.js,This is a root sales person and cannot be edited.,To je kořen prodejní člověk a nelze upravovat.
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 zadaná nebo vypočtená v této složce nepřispívá k výnosům nebo odpočtem. Nicméně, jeho hodnota může být odkazováno na jiné komponenty, které mohou být přidány nebo odečteny."
,Stock Ledger,Reklamní Ledger
DocType: Company,Exchange Gain / Loss Account,Exchange Zisk / ztráty
DocType: Amazon MWS Settings,MWS Credentials,MWS pověření
apps/erpnext/erpnext/config/selling.py,Blanket Orders from Costumers.,Přikládané objednávky od zákazníků.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Purpose must be one of {0},Cíl musí být jedním z {0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Fill the form and save it,Vyplňte formulář a uložte jej
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Community Forum,Forum Community
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Actual qty in stock,Aktuální množství na skladě
DocType: Homepage,"URL for ""All Products""",URL pro &quot;všechny produkty&quot;
DocType: Leave Application,Leave Balance Before Application,Stav absencí před požadavkem
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Send SMS,Pošlete SMS
DocType: Supplier Scorecard Criteria,Max Score,Maximální skóre
DocType: Cheque Print Template,Width of amount in word,Šířka částky ve slově
DocType: Purchase Order,Get Items from Open Material Requests,Položka získaná z žádostí Otevřít Materiál
DocType: Hotel Room Amenity,Billable,Zúčtovatelná
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Ordered Qty: Quantity ordered for purchase, but not received.","Objednáno Množství: Objednané množství pro nákup, ale nedostali."
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Chart of Accounts and Parties,Tabulka zpracování účtů a stran
DocType: Lab Test Template,Standard Selling Rate,Standardní prodejní cena
DocType: Account,Rate at which this tax is applied,"Sazba, při které se používá tato daň"
DocType: Cash Flow Mapper,Section Name,Název oddílu
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Reorder Qty,Změna pořadí Množství
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Odpisová řada {0}: Očekávaná hodnota po uplynutí životnosti musí být větší nebo rovna {1}
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Current Job Openings,Aktuální pracovní příležitosti
DocType: Company,Stock Adjustment Account,Reklamní Nastavení účtu
apps/erpnext/erpnext/public/js/payment/pos_payment.html,Write Off,Odepsat
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}.
DocType: Healthcare Service Unit,Allow Overlap,Povolit překrytí
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Operation ID,Provoz ID
DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","System User (login) ID. Pokud je nastaveno, stane se výchozí pro všechny formy HR."
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Enter depreciation details,Zadejte podrobnosti o odpisu
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,{0}: From {1},{0}: Z {1}
DocType: Bank Transaction Mapping,Column in Bank File,Sloupec v bankovním souboru
apps/erpnext/erpnext/education/doctype/student_leave_application/student_leave_application.py,Leave application {0} already exists against the student {1},Ponechat aplikaci {0} již proti studentovi {1}
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.,Naladil se na aktualizaci nejnovější ceny ve všech kusovnících. Může to trvat několik minut.
DocType: Pick List,Get Item Locations,Získejte umístění položky
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: Prosím, vytvářet účty pro zákazníky a dodavateli"
DocType: POS Profile,Display Items In Stock,Zobrazit položky na skladě
apps/erpnext/erpnext/config/settings.py,Country wise default Address Templates,Země moudrý výchozí adresa Templates
DocType: Payment Order,Payment Order Reference,Odkaz na platební příkaz
DocType: Water Analysis,Appearance,Vzhled
DocType: HR Settings,Leave Status Notification Template,Ponechat šablonu oznamování stavu
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Avg. Buying Price List Rate,Průměrné Nákupní cena ceníku
DocType: Sales Order Item,Supplier delivers to Customer,Dodavatel doručí zákazníkovi
apps/erpnext/erpnext/config/non_profit.py,Member information.,Členové informace.
DocType: Identification Document Type,Identification Document Type,Identifikační typ dokumentu
apps/erpnext/erpnext/utilities/bot.py,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / Položka / {0}) není na skladě
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Maintenance,Údržba majetku
,Sales Payment Summary,Přehled plateb prodeje
DocType: Restaurant,Restaurant,Restaurace
DocType: Woocommerce Settings,API consumer key,API spotřebitelský klíč
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,Je požadováno „datum“
apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Vzhledem / Referenční datum nemůže být po {0}
apps/erpnext/erpnext/config/settings.py,Data Import and Export,Import dat a export
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Litujeme, platnost kódu kupónu vypršela"
DocType: Bank Account,Account Details,Údaje o účtu
DocType: Crop,Materials Required,Potřebné materiály
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Žádní studenti Nalezené
DocType: Employee Tax Exemption Declaration,Monthly HRA Exemption,Měsíční výjimka HRA
DocType: Clinical Procedure,Medical Department,Lékařské oddělení
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Early Exits,Celkový předčasný odchod
DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Kritéria hodnocení skóre dodavatele skóre
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,Invoice Posting Date,Faktura Datum zveřejnění
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Sell,Prodat
DocType: Purchase Invoice,Rounded Total,Celkem zaokrouhleno
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: Product Bundle,List items that form the package.,"Seznam položek, které tvoří balíček."
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Target Location is required while transferring Asset {0},Při převodu aktiva je vyžadováno cílové umístění {0}
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Not permitted. Please disable the Test Template,Nepovoleno. Vypněte testovací šablonu
DocType: Sales Invoice,Distance (in km),Vzdálenost (v km)
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py,Percentage Allocation should be equal to 100%,Podíl alokace by měla být ve výši 100%
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select Posting Date before selecting Party,"Prosím, vyberte Datum zveřejnění před výběrem Party"
apps/erpnext/erpnext/config/accounts.py,Payment Terms based on conditions,Platební podmínky na základě podmínek
DocType: Program Enrollment,School House,School House
DocType: Serial No,Out of AMC,Out of AMC
DocType: Opportunity,Opportunity Amount,Částka příležitostí
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Your Profile,Tvůj profil
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Počet Odpisy rezervováno nemůže být větší než celkový počet Odpisy
DocType: Purchase Order,Order Confirmation Date,Datum potvrzení objednávky
DocType: Driver,HR-DRI-.YYYY.-,HR-DRI-.YYYY.-
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py,All Products,Všechny produkty
DocType: Employee Transfer,Employee Transfer Details,Podrobnosti o převodu zaměstnanců
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Please contact to the user who have Sales Master Manager {0} role,"Prosím, kontaktujte pro uživatele, kteří mají obchodní manažer ve skupině Master {0} roli"
DocType: Company,Default Cash Account,Výchozí Peněžní účet
DocType: Issue,Ongoing,Pokračující
apps/erpnext/erpnext/config/accounts.py,Company (not Customer or Supplier) master.,Company (nikoliv zákazník nebo dodavatel) master.
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
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,No Students in,Žádné studenty v
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Add more items or open full form,Přidat další položky nebo otevřené plné formě
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Dodací listy {0} musí být zrušena před zrušením této prodejní objednávky
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Uhrazená částka + odepsaná částka nesmí být větší než celková částka
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á Šarže pro Položku {1}
apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Zadejte prosím platný kuponový kód !!
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Poznámka: Není k dispozici dostatek zůstatek dovolené dovolená za kalendářní typ {0}
DocType: Task,Task Description,Popis ulohy
DocType: Training Event,Seminar,Seminář
DocType: Program Enrollment Fee,Program Enrollment Fee,Program zápisné
DocType: Item,Supplier Items,Dodavatele položky
DocType: Material Request,MAT-MR-.YYYY.-,MAT-MR-.YYYY.-
DocType: Opportunity,Opportunity Type,Typ Příležitosti
DocType: Asset Movement Item,To Employee,Zaměstnanci
DocType: Employee Transfer,New Company,Nová společnost
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py,Transactions can only be deleted by the creator of the Company,Transakce mohou být vymazány pouze tvůrce Společnosti
apps/erpnext/erpnext/accounts/general_ledger.py,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Nesprávný počet hlavní knihy záznamů nalezen. Pravděpodobně jste zvolili nesprávný účet v transakci.
DocType: Employee,Prefered Contact Email,Preferovaný Kontaktní e-mail
DocType: Cheque Print Template,Cheque Width,Šek Šířka
DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Ověření prodejní ceny položky proti nákupní ceně nebo ocenění
DocType: Fee Schedule,Fee Schedule,poplatek Plán
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Column Labels : ,Štítky sloupců:
DocType: Bank Transaction,Settled,Usadil se
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Disbursement Date cannot be after Loan Repayment Start Date,Datum výplaty nesmí být po datu zahájení splácení úvěru
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Cess,Cess
DocType: Quality Feedback,Parameters,Parametry
DocType: Company,Create Chart Of Accounts Based On,Vytvořte účtový rozvrh založený na
apps/erpnext/erpnext/education/doctype/student/student.py,Date of Birth cannot be greater than today.,Datum narození nemůže být větší než dnes.
,Stock Ageing,Reklamní Stárnutí
DocType: Travel Request,"Partially Sponsored, Require Partial Funding","Částečně sponzorované, vyžadují částečné financování"
apps/erpnext/erpnext/education/doctype/student/student.py,Student {0} exist against student applicant {1},Existují Student {0} proti uchazeč student {1}
DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Úprava zaokrouhlení (měna společnosti)
apps/erpnext/erpnext/projects/doctype/task/task.js,Timesheet,Rozvrh hodin
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Batch: ,Dávka:
DocType: Volunteer,Afternoon,Odpoledne
DocType: Loyalty Program,Loyalty Program Help,Nápověda věrnostního programu
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} '{1}' is disabled,{0} '{1}' je vypnuté
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Open,Nastavit jako Otevřít
DocType: Cheque Print Template,Scanned Cheque,skenovaných Šek
DocType: Timesheet,Total Billable Amount,Celková částka Zúčtovatelná
DocType: Customer,Credit Limit and Payment Terms,Úvěrový limit a platební podmínky
DocType: Loyalty Program,Collection Rules,Pravidla výběru
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 3,Položka 3
apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js,Order Entry,Zadání objednávky
DocType: Purchase Order,Customer Contact Email,Zákazník Kontaktní e-mail
DocType: Warranty Claim,Item and Warranty Details,Položka a Záruka Podrobnosti
DocType: Chapter,Chapter Members,Členové kapitoly
DocType: Sales Team,Contribution (%),Příspěvek (%)
apps/erpnext/erpnext/controllers/accounts_controller.py,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Poznámka: Položka Platba nebude vytvořili, protože ""v hotovosti nebo bankovním účtu"" nebyl zadán"
DocType: Clinical Procedure,Nursing User,Ošetřujícího uživatele
DocType: Employee Benefit Application,Payroll Period,Mzdové období
DocType: Plant Analysis,Plant Analysis Criterias,Kritéria analýzy rostlin
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 skupiny Batch {1}
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Your email address...,Vaše emailová adresa...
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Responsibilities,Odpovědnost
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Validity period of this quotation has ended.,Platnost této nabídky skončila.
DocType: Expense Claim Account,Expense Claim Account,Náklady na pojistná Account
DocType: Account,Capital Work in Progress,Kapitálová práce probíhá
DocType: Accounts Settings,Allow Stale Exchange Rates,Povolit stávající kurzy měn
DocType: Sales Person,Sales Person Name,Prodej Osoba Name
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,Please enter atleast 1 invoice in the table,Zadejte prosím aspoň 1 fakturu v tabulce
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,No Lab Test created,Nebyl vytvořen žádný laboratorní test
DocType: POS Item Group,Item Group,Skupina položek
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Student Group: ,Studentská skupina:
DocType: Depreciation Schedule,Finance Book Id,Identifikační číslo finanční knihy
DocType: Item,Safety Stock,Bezpečné skladové množství
DocType: Healthcare Settings,Healthcare Settings,Nastavení zdravotní péče
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Total Allocated Leaves,Celkové přidělené listy
apps/erpnext/erpnext/projects/doctype/task/task.py,Progress % for a task cannot be more than 100.,Pokrok% za úkol nemůže být více než 100.
DocType: Stock Reconciliation Item,Before reconciliation,Před smíření
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,To {0},Chcete-li {0}
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Daně a poplatky Přidal (Company měna)
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 Tax Row {0} musí mít účet typu daní či výnosů nebo nákladů, nebo Vyměřovací"
DocType: Sales Order,Partly Billed,Částečně Účtovaný
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} must be a Fixed Asset Item,Item {0} musí být dlouhodobá aktiva položka
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,HSN,HSN
DocType: Item,Default BOM,Výchozí BOM
DocType: Project,Total Billed Amount (via Sales Invoices),Celková fakturační částka (prostřednictvím prodejních faktur)
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Debit Note Amount,Částka pro debetní poznámku
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čítanou částkou"
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,You are not present all day(s) between compensatory leave request days,Nejste přítomni celý den (dní) mezi dny žádosti o náhradní dovolenou
apps/erpnext/erpnext/setup/doctype/company/company.js,Please re-type company name to confirm,Prosím re-typ název společnosti na potvrzení
DocType: Journal Entry,Printing Settings,Tisk Nastavení
DocType: Payment Order,Payment Order Type,Typ platebního příkazu
DocType: Employee Advance,Advance Account,Advance účet
DocType: Job Offer,Job Offer Terms,Podmínky nabídky práce
DocType: Sales Invoice,Include Payment (POS),Zahrnují platby (POS)
DocType: Shopify Settings,eg: frappe.myshopify.com,např .: frappe.myshopify.com
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement tracking is not enabled.,Sledování dohody o úrovni služeb není povoleno.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Total Debit must be equal to Total Credit. The difference is {0},Celkové inkaso musí rovnat do celkového kreditu. Rozdíl je {0}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Automotive,Automobilový
DocType: Vehicle,Insurance Company,Pojišťovna
DocType: Asset Category Account,Fixed Asset Account,Fixed Asset Account
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Variable,Proměnná
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/selling/doctype/installation_note/installation_note.js,From Delivery Note,Z Dodacího Listu
DocType: Chapter,Members,Členové
DocType: Student,Student Email Address,Student E-mailová adresa
DocType: Item,Hub Warehouse,Hub Warehouse
DocType: Appointment Booking Slots,From Time,Času od
DocType: Hotel Settings,Hotel Settings,Nastavení hotelu
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html,In Stock: ,Na skladě:
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Investment Banking,Investiční bankovnictví
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Cash or Bank Account is mandatory for making payment entry,V hotovosti nebo bankovním účtu je povinný pro výrobu zadání platebního
DocType: Education Settings,LMS Settings,Nastavení LMS
DocType: Company,Discount Allowed Account,Diskontní povolený účet
DocType: Loyalty Program,Multiple Tier Program,Vícevrstvý program
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Address,Studentská adresa
DocType: Purchase Invoice,Price List Exchange Rate,Katalogová cena Exchange Rate
apps/erpnext/erpnext/patches/v11_0/rename_supplier_type_to_supplier_group.py,All Supplier Groups,Všechny skupiny dodavatelů
DocType: Employee Boarding Activity,Required for Employee Creation,Požadováno pro vytváření zaměstnanců
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dodavatel&gt; Typ dodavatele
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account Number {0} already used in account {1},Číslo účtu {0} již použito v účtu {1}
DocType: GoCardless Mandate,Mandate,Mandát
DocType: Hotel Room Reservation,Booked,Rezervováno
DocType: Detected Disease,Tasks Created,Úkoly byly vytvořeny
DocType: Purchase Invoice Item,Rate,Cena
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Intern,Internovat
DocType: Coupon Code,"e.g. ""Summer Holiday 2019 Offer 20""","např. „Letní dovolená 2019, nabídka 20“"
DocType: Delivery Stop,Address Name,adresa Jméno
DocType: Stock Entry,From BOM,Od BOM
DocType: Assessment Code,Assessment Code,Kód Assessment
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Basic,Základní
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock transactions before {0} are frozen,Fotky transakce před {0} jsou zmrazeny
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule',"Prosím, klikněte na ""Generovat Schedule"""
DocType: Job Card,Current Time,Aktuální čas
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 k rozhodnému dni"
DocType: Bank Reconciliation Detail,Payment Document,platba Document
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py,Error evaluating the criteria formula,Chyba při vyhodnocování vzorce kritéria
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date of Joining must be greater than Date of Birth,Datum přistoupení musí být větší než Datum narození
DocType: Subscription,Plans,Plány
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,Opening Balance,Počáteční zůstatek
DocType: Salary Slip,Salary Structure,Plat struktura
DocType: Account,Bank,Banka
DocType: Job Card,Job Started,Úloha byla zahájena
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Airline,Letecká linka
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Issue Material,Vydání Material
apps/erpnext/erpnext/config/integrations.py,Connect Shopify with ERPNext,Connect Shopify s ERPNext
DocType: Production Plan,For Warehouse,Pro Sklad
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,Delivery Notes {0} updated,Dodací poznámky {0} byly aktualizovány
DocType: Employee,Offer Date,Nabídka Date
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Quotations,Citace
DocType: Purchase Order,Inter Company Order Reference,Inter Company Reference reference
apps/erpnext/erpnext/accounts/page/pos/pos.js,You are in offline mode. You will not be able to reload until you have network.,"Jste v režimu offline. Nebudete moci obnovit stránku, dokud nebudete na síťi."
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Qty increased by 1,Řádek # {0}: Množství se zvýšilo o 1
DocType: Account,Include in gross,Zahrňte do hrubého
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js,Grant,Grant
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,No Student Groups created.,Žádné studentské skupiny vytvořen.
DocType: Purchase Invoice Item,Serial No,Výrobní číslo
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Monthly Repayment Amount cannot be greater than Loan Amount,Měsíční splátka částka nemůže být větší než Výše úvěru
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please enter Maintaince Details first,"Prosím, zadejte první maintaince Podrobnosti"
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 dodání nemůže být před datem objednávky
DocType: Purchase Invoice,Print Language,Tisk Language
DocType: Salary Slip,Total Working Hours,Celkové pracovní doby
DocType: Sales Invoice,Customer PO Details,Podrobnosti PO zákazníka
apps/erpnext/erpnext/education/utils.py,You are not enrolled in program {0},Nejste přihlášeni do programu {0}
DocType: Stock Entry,Including items for sub assemblies,Včetně položek pro podsestav
DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Účet dočasného zahájení
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods In Transit,Zboží v tranzitu
apps/erpnext/erpnext/accounts/page/pos/pos.js,Enter value must be positive,Zadejte hodnota musí být kladná
DocType: Asset,Finance Books,Finanční knihy
DocType: Employee Tax Exemption Declaration Category,Employee Tax Exemption Declaration Category,Vyhláška o osvobození od daně z příjmů zaměstnanců
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py,All Territories,Všechny území
DocType: Lost Reason Detail,Lost Reason Detail,Detail ztraceného důvodu
apps/erpnext/erpnext/hr/utils.py,Please set leave policy for employee {0} in Employee / Grade record,Pro zaměstnance {0} nastavte v kalendáři zaměstnance / plat
apps/erpnext/erpnext/public/js/controllers/transaction.js,Invalid Blanket Order for the selected Customer and Item,Neplatná objednávka prázdné objednávky pro vybraného zákazníka a položku
apps/erpnext/erpnext/projects/doctype/task/task_tree.js,Add Multiple Tasks,Přidat více úkolů
DocType: Purchase Invoice,Items,Položky
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/education/doctype/course_enrollment/course_enrollment.py,Student is already enrolled.,Student je již zapsáno.
DocType: Fiscal Year,Year Name,Jméno roku
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,There are more holidays than working days this month.,Existují další svátky než pracovních dnů tento měsíc.
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 položka {1}. Můžete je povolit jako {1} položku z jeho položky Master
DocType: Production Plan Item,Product Bundle Item,Product Bundle Item
DocType: Sales Partner,Sales Partner Name,Sales Partner Name
apps/erpnext/erpnext/hooks.py,Request for Quotations,Žádost o citátů
DocType: Payment Reconciliation,Maximum Invoice Amount,Maximální částka faktury
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() failed for empty IBAN,BankAccount.validate_iban () selhala pro prázdný IBAN
DocType: Normal Test Items,Normal Test Items,Normální testovací položky
DocType: QuickBooks Migrator,Company Settings,Nastavení firmy
DocType: Additional Salary,Overwrite Salary Structure Amount,Přepsat částku struktury platu
DocType: Leave Ledger Entry,Leaves,Listy
DocType: Student Language,Student Language,Student Language
DocType: Cash Flow Mapping,Is Working Capital,Je pracovní kapitál
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js,Submit Proof,Odeslat důkaz
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order/Quot %,Objednávka / kvóta%
apps/erpnext/erpnext/config/healthcare.py,Record Patient Vitals,Zaznamenejte vitál pacientů
DocType: Fee Schedule,Institution,Instituce
DocType: Asset,Partially Depreciated,částečně odepisována
DocType: Issue,Opening Time,Otevírací doba
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,From and To dates required,Data OD a DO jsou vyžadována
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Securities & Commodity Exchanges,Cenné papíry a komoditních burzách
apps/erpnext/erpnext/templates/pages/search_help.py,Docs Search,Vyhledávání dokumentů
apps/erpnext/erpnext/stock/doctype/item/item.py,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Výchozí měrná jednotka varianty &#39;{0}&#39; musí být stejný jako v Template &#39;{1}&#39;
DocType: Shipping Rule,Calculate Based On,Vypočítat založené na
DocType: Contract,Unfulfilled,Nesplněno
DocType: Delivery Note Item,From Warehouse,Ze skladu
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,No employees for the mentioned criteria,Žádní zaměstnanci nesplnili uvedená kritéria
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials to Manufacture,Žádné položky s Billem materiálů k výrobě
DocType: Shopify Settings,Default Customer,Výchozí zákazník
DocType: Sales Stage,Stage Name,Pseudonym
apps/erpnext/erpnext/config/getting_started.py,Data Import and Settings,Import a nastavení dat
DocType: Warranty Claim,SER-WRN-.YYYY.-,SER-WRN-.YYYY.-
DocType: Assessment Plan,Supervisor Name,Jméno Supervisor
DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,"Nepotvrzujte, zda je událost vytvořena ve stejný den"
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Ship To State,Loď do státu
DocType: Program Enrollment Course,Program Enrollment Course,Program pro zápis do programu
DocType: Invoice Discounting,Bank Charges,Bankovní poplatky
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 zdravotnickému lékaři {1}
DocType: Purchase Taxes and Charges,Valuation and Total,Oceňování a Total
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Negotiation/Review,Vyjednávání / přezkum
DocType: Leave Encashment,Encashment Amount,Část inkasa
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py,Scorecards,Scorecards
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Expired Batches,Zaniklé dávky
DocType: Employee,This will restrict user access to other employee records,To bude omezovat přístup uživatelů k dalším záznamům zaměstnanců
DocType: Tax Rule,Shipping City,Dodací město
apps/erpnext/erpnext/regional/india/utils.py,GST HSN Code does not exist for one or more items,Kód GST HSN neexistuje pro jednu nebo více položek
DocType: Quality Procedure Table,Step,Krok
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Variance ({}),Variance ({})
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Rate or Discount is required for the price discount.,Pro slevu z ceny je požadována sazba nebo sleva.
DocType: Purchase Invoice,Import Of Service,Import služeb
DocType: Education Settings,LMS Title,Název LMS
DocType: Sales Invoice,Ship,Loď
DocType: Staffing Plan Detail,Current Openings,Aktuální místa
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Operations,Cash flow z provozních činností
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CGST Amount,CGST částka
apps/erpnext/erpnext/utilities/activation.py,Create Student,Vytvořit studenta
DocType: Asset Movement Item,Asset Movement Item,Pohyb položky
DocType: Purchase Invoice,Shipping Rule,Pravidlo dopravy
DocType: Patient Relation,Spouse,Manželka
DocType: Lab Test Groups,Add Test,Přidat test
DocType: Manufacturer,Limited to 12 characters,Omezeno na 12 znaků
DocType: Journal Entry,Print Heading,Tisk záhlaví
DocType: Quality Action Table,Quality Action Table,Tabulka akcí kvality
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Total cannot be zero,Celkem nemůže být nula
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,'Days Since Last Order' must be greater than or equal to zero,"""Dnů od poslední objednávky"" musí být větší nebo rovno nule"
DocType: Plant Analysis Criteria,Maximum Permissible Value,Maximální přípustná hodnota
apps/erpnext/erpnext/selling/report/item_wise_sales_history/item_wise_sales_history.py,Delivered Quantity,Dodané množství
DocType: Journal Entry Account,Employee Advance,Zaměstnanec Advance
DocType: Payroll Entry,Payroll Frequency,Mzdové frekvence
DocType: Plaid Settings,Plaid Client ID,Plaid Client ID
DocType: Lab Test Template,Sensitivity,Citlivost
DocType: Plaid Settings,Plaid Settings,Plaid Settings
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ě deaktivována, protože byly překročeny maximální počet opakování"
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Raw Material,Surovina
DocType: Leave Application,Follow via Email,Sledovat e-mailem
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Plants and Machineries,Rostliny a strojní vybavení
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Částka daně po slevě Částka
DocType: Patient,Inpatient Status,Stavy hospitalizace
DocType: Asset Finance Book,In Percentage,V procentech
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 kontrolovat nákupní a prodejní pole.
apps/erpnext/erpnext/controllers/buying_controller.py,Please enter Reqd by Date,Zadejte Reqd podle data
DocType: Payment Entry,Internal Transfer,vnitřní Převod
DocType: Asset Maintenance,Maintenance Tasks,Úkoly údržby
apps/erpnext/erpnext/setup/doctype/territory/territory.py,Either target qty or target amount is mandatory,Buď cílové množství nebo cílová částka je povinná
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Please select Posting Date first,"Prosím, vyberte nejprve Datum zveřejnění"
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date should be before Closing Date,Datum zahájení by měla být před uzávěrky
DocType: Travel Itinerary,Flight,Let
apps/erpnext/erpnext/public/js/hub/pages/NotFound.vue,Back to home,Zpátky domů
DocType: Leave Control Panel,Carry Forward,Převádět
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 se stávajícími transakcemi nelze převést na hlavní účetní knihy
DocType: Budget,Applicable on booking actual expenses,Platí pro rezervaci skutečných nákladů
DocType: Department,Days for which Holidays are blocked for this department.,"Dnů, po které Prázdniny jsou blokovány pro toto oddělení."
DocType: Amazon MWS Settings,ERPNext Integrations,ERPNext Integrace
DocType: Crop Cycle,Detected Disease,Zjištěná nemoc
,Produced,Produkoval
apps/erpnext/erpnext/stock/report/stock_and_account_value_comparison/stock_and_account_value_comparison.py,Stock Ledger ID,ID hlavní knihy
DocType: Issue,Raised By (Email),Vznesené (e-mail)
DocType: Issue,Service Level Agreement,Dohoda o úrovni služeb
DocType: Training Event,Trainer Name,Jméno trenér
DocType: Mode of Payment,General,Obecný
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication,Poslední komunikace
,TDS Payable Monthly,TDS splatné měsíčně
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Naléhá na výměnu kusovníku. Může to trvat několik minut.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Nelze odečíst, pokud kategorie je určena pro ""ocenění"" nebo ""oceňování a celkový"""
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Celkové platby
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serial Nos Požadováno pro serializovaném bodu {0}
apps/erpnext/erpnext/config/accounts.py,Match Payments with Invoices,Zápas platby fakturami
DocType: Payment Entry,Get Outstanding Invoice,Získejte vynikající fakturu
DocType: Journal Entry,Bank Entry,Bank Entry
apps/erpnext/erpnext/stock/doctype/item/item.py,Updating Variants...,Aktualizace variant ...
DocType: Authorization Rule,Applicable To (Designation),Vztahující se na (označení)
,Profitability Analysis,Analýza ziskovost
DocType: Fees,Student Email,Studentský e-mail
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Disburse Loan,Výplata půjčky
DocType: Supplier,Prevent POs,Zabránit organizacím výrobců
DocType: Patient,"Allergies, Medical and Surgical History","Alergie, lékařská a chirurgická historie"
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Add to Cart,Přidat do košíku
apps/erpnext/erpnext/config/accounts.py,Enable / disable currencies.,Povolit / zakázat měny.
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Could not submit some Salary Slips,Nelze odeslat některé výplatní pásky
DocType: Project Template,Project Template,Šablona projektu
DocType: Exchange Rate Revaluation,Get Entries,Získejte položky
DocType: Production Plan,Get Material Request,Získat Materiál Request
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/selling/doctype/pos_closing_voucher/closing_voucher_details.html,Sales Summary,Přehled o prodeji
apps/erpnext/erpnext/controllers/trends.py,Total(Amt),Total (Amt)
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please identify/create Account (Group) for type - {0},Určete / vytvořte účet (skupinu) pro typ - {0}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Entertainment & Leisure,Entertainment & Leisure
,Item Variant Details,Podrobnosti o variantě položky
DocType: Quality Inspection,Item Serial No,Položka Výrobní číslo
DocType: Payment Request,Is a Subscription,Je předplatné
apps/erpnext/erpnext/utilities/activation.py,Create Employee Records,Vytvořit Zaměstnanecké záznamů
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Present,Celkem Present
DocType: Work Order,MFG-WO-.YYYY.-,MFG-WO-YYYY.-
DocType: Drug Prescription,Hour,Hodina
DocType: Restaurant Order Entry,Last Sales Invoice,Poslední prodejní faktura
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select Qty against item {0},Zvolte prosím množství v položce {0}
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Latest Age,Pozdní fáze
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py,Scheduled and Admitted dates can not be less than today,Plánovaná a přijatá data nemohou být menší než dnes
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Transfer Material to Supplier,Přeneste materiál Dodavateli
apps/erpnext/erpnext/hr/report/loan_repayment/loan_repayment.py,EMI,EMI
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é seriové číslo nemůže mít záznam skladu. Sklad musí být nastaven přes skladovou kartu nebo nákupní doklad
DocType: Lead,Lead Type,Typ leadu
apps/erpnext/erpnext/utilities/activation.py,Create Quotation,Vytvořit Citace
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 listí na bloku Termíny
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} Request for {1},{0} Žádost o {1}
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
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,No outstanding invoices found for the {0} {1} which qualify the filters you have specified.,"Za {0} {1} nebyly nalezeny žádné nezaplacené faktury, které by odpovídaly zadaným filtrům."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Set New Release Date,Nastavte nový datum vydání
DocType: Company,Monthly Sales Target,Měsíční prodejní cíl
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,No outstanding invoices found,Nebyly nalezeny žádné nezaplacené faktury
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Can be approved by {0},Může být schválena {0}
DocType: Hotel Room,Hotel Room Type,Typ pokoje typu Hotel
DocType: Customer,Account Manager,Správce účtu
DocType: Issue,Resolution By Variance,Rozlišení podle variace
DocType: Leave Allocation,Leave Period,Opustit období
DocType: Item,Default Material Request Type,Výchozí typ požadavku na zásobování
DocType: Supplier Scorecard,Evaluation Period,Hodnocené období
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js,Unknown,Neznámý
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order not created,Pracovní příkaz nebyl vytvořen
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}","Část {0} již byla nárokována pro složku {1}, \ nastavte částku rovnající se nebo větší než {2}"
DocType: Shipping Rule,Shipping Rule Conditions,Přepravní Článek Podmínky
DocType: Salary Slip Loan,Salary Slip Loan,Úvěrový půjček
DocType: BOM Update Tool,The new BOM after replacement,Nový BOM po změně
,Point of Sale,Místo Prodeje
DocType: Payment Entry,Received Amount,přijaté Částka
DocType: Patient,Widow,Vdova
DocType: GST Settings,GSTIN Email Sent On,GSTIN E-mail odeslán na
DocType: Program Enrollment,Pick/Drop by Guardian,Pick / Drop od Guardian
DocType: Bank Account,SWIFT number,Číslo SWIFT
DocType: Payment Entry,Party Name,Jméno Party
DocType: POS Closing Voucher,Total Collected Amount,Celková shromážděná částka
DocType: Employee Benefit Application,Benefits Applied,Využité výhody
DocType: Crop,Planting UOM,Výsadba UOM
DocType: Account,Tax,Daň
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Not Marked,neoznačený
DocType: Service Level Priority,Response Time Period,Doba odezvy
DocType: Contract,Signed,Podepsaný
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices Summary,Otevření souhrnu faktur
DocType: Member,NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-
DocType: Education Settings,Education Manager,Správce vzdělávání
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inter-State Supplies,Mezistátní dodávky
DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Minimální délka mezi jednotlivými rostlinami v terénu pro optimální růst
DocType: Quality Inspection,Report Date,Datum Reportu
DocType: BOM,Routing,Směrování
DocType: Serial No,Asset Details,Podrobnosti o majetku
DocType: Employee Tax Exemption Declaration Category,Declared Amount,Deklarovaná částka
DocType: Bank Statement Transaction Payment Item,Invoices,Faktury
DocType: Water Analysis,Type of Sample,Typ vzorku
DocType: Batch,Source Document Name,Název zdrojového dokumentu
DocType: Production Plan,Get Raw Materials For Production,Získejte suroviny pro výrobu
DocType: Job Opening,Job Title,Název pozice
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Budoucí platba Ref
DocType: Quotation,Additional Discount and Coupon Code,Další slevový a kuponový kód
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} znamená, že {1} neposkytne citát, ale byly citovány všechny položky \. Aktualizace stavu nabídky RFQ."
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í vzorky - {0} již byly zadány v dávce {1} a položce {2} v dávce {3}.
DocType: Manufacturing Settings,Update BOM Cost Automatically,Aktualizovat cenu BOM automaticky
DocType: Lab Test,Test Name,Testovací jméno
DocType: Healthcare Settings,Clinical Procedure Consumable Item,Klinický postup Spotřební materiál
apps/erpnext/erpnext/utilities/activation.py,Create Users,Vytvořit uživatele
DocType: Employee Tax Exemption Category,Max Exemption Amount,Maximální částka pro výjimku
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,Subscriptions,Předplatné
DocType: Quality Review Table,Objective,Objektivní
DocType: Supplier Scorecard,Per Month,Za měsíc
DocType: Education Settings,Make Academic Term Mandatory,Uveďte povinnost akademického termínu
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Quantity to Manufacture must be greater than 0.,"Množství, které má výroba musí být větší než 0 ° C."
apps/erpnext/erpnext/config/crm.py,Visit report for maintenance call.,Navštivte zprávu pro volání údržby.
DocType: Stock Entry,Update Rate and Availability,Obnovovací rychlost a dostupnost
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 máte možnost přijímat nebo dodávat více proti objednaného množství. Například: Pokud jste si objednali 100 kusů. a váš příspěvek je 10%, pak máte možnost získat 110 jednotek."
DocType: Shopping Cart Settings,Show Contact Us Button,Tlačítko Zobrazit kontakt
DocType: Loyalty Program,Customer Group,Zákazník Group
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch ID (Optional),Nové číslo dávky (volitelné)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Expense account is mandatory for item {0},Účtet nákladů je povinný pro položku {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Release date must be in the future,Datum vydání musí být v budoucnosti
DocType: BOM,Website Description,Popis webu
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Equity,Čistá změna ve vlastním kapitálu
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py,Not permitted. Please disable the Service Unit Type,Nepovoleno. Zakažte typ servisní jednotky
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}"
DocType: Serial No,AMC Expiry Date,AMC Datum vypršení platnosti
DocType: Asset,Receipt,Příjem
,Sales Register,Sales Register
DocType: Daily Work Summary Group,Send Emails At,Posílat e-maily At
DocType: Quotation Lost Reason,Quotation Lost Reason,Důvod ztráty nabídky
apps/erpnext/erpnext/accounts/doctype/sales_invoice/regional/india_list.js,Generate e-Way Bill JSON,Vygenerujte e-Way Bill JSON
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Transaction reference no {0} dated {1},Referenční transakce no {0} ze dne {1}
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js,There is nothing to edit.,Není nic upravovat.
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Form View,Zobrazení formuláře
DocType: HR Settings,Expense Approver Mandatory In Expense Claim,Povinnost pojistitele výdajů v nárocích na výdaje
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Summary for this month and pending activities,Shrnutí pro tento měsíc a probíhajícím činnostem
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,Please set Unrealized Exchange Gain/Loss Account in Company {0},Prosím nastavte Unrealized Exchange Gain / Loss účet ve společnosti {0}
DocType: Customer Group,Customer Group Name,Zákazník Group Name
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}: Quantity not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Řádek {0}: Množství není k dispozici pro {4} ve skladu {1} v době zveřejnění záznamu ({2} {3})
apps/erpnext/erpnext/public/js/pos/pos.html,No Customers yet!,Zatím žádné zákazníky!
DocType: Quality Procedure Process,Link existing Quality Procedure.,Propojte stávající postup kvality.
apps/erpnext/erpnext/config/hr.py,Loans,Půjčky
DocType: Healthcare Service Unit,Healthcare Service Unit,Jednotka zdravotnických služeb
,Customer-wise Item Price,Cena předmětu podle přání zákazníka
apps/erpnext/erpnext/public/js/financial_statements.js,Cash Flow Statement,Přehled o peněžních tocích
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No material request created,Žádná materiálová žádost nebyla vytvořena
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.py,Loan Amount cannot exceed Maximum Loan Amount of {0},Výše úvěru nesmí být vyšší než Maximální výše úvěru částku {0}
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,License,Licence
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please remove this Invoice {0} from C-Form {1},Odeberte Tato faktura {0} z C-Form {1}
DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,"Prosím, vyberte převádět pokud chcete také zahrnout uplynulý fiskální rok bilance listy tohoto fiskálního roku"
DocType: GL Entry,Against Voucher Type,Proti poukazu typu
DocType: Healthcare Practitioner,Phone (R),Telefon (R)
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid {0} for Inter Company Transaction.,Neplatné pro transakci mezi společnostmi {0}.
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Time slots added,Byly přidány časové úseky
DocType: Products Settings,Attributes,Atributy
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Enable Template,Povolit šablonu
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please enter Write Off Account,"Prosím, zadejte odepsat účet"
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Last Order Date,Datum poslední objednávky
DocType: Accounts Settings,Unlink Advance Payment on Cancelation of Order,Odpojte zálohy na zrušení objednávky
DocType: Salary Component,Is Payable,Je splatné
DocType: Inpatient Record,B Negative,B Negativní
DocType: Pricing Rule,Price Discount Scheme,Schéma slevy
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í
DocType: Amazon MWS Settings,US,NÁS
DocType: Holiday List,Add Weekly Holidays,Přidat týdenní prázdniny
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Report Item,Položka sestavy
DocType: Staffing Plan Detail,Vacancies,Volná místa
DocType: Hotel Room,Hotel Room,Hotelový pokoj
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} does not belongs to company {1},Účet {0} nepatří společnosti {1}
DocType: Homepage Section,Use this field to render any custom HTML in the section.,Toto pole použijte k vykreslení vlastního HTML v sekci.
DocType: Leave Type,Rounding,Zaokrouhlení
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í poznámce k doručení
DocType: Employee Benefit Application,Dispensed Amount (Pro-rated),Vyčerpaná částka (pro-hodnocena)
DocType: Student,Guardian Details,Guardian Podrobnosti
DocType: C-Form,C-Form,C-Form
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 měly odpovídat číslu státu {0}.
DocType: Agriculture Task,Start Day,Den zahájení
DocType: Vehicle,Chassis No,podvozek Žádné
DocType: Payment Entry,Initiated,Zahájil
DocType: Production Plan Item,Planned Start Date,Plánované datum zahájení
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select a BOM,Vyberte kusovníku
DocType: Purchase Invoice,Availed ITC Integrated Tax,Využil integrovanou daň z ITC
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Repayment Entry,Vytvořit položku pro vrácení
DocType: Purchase Order Item,Blanket Order Rate,Dekorační objednávka
,Customer Ledger Summary,Shrnutí účetní knihy zákazníka
apps/erpnext/erpnext/hooks.py,Certification,Osvědčení
DocType: Bank Guarantee,Clauses and Conditions,Doložky a podmínky
DocType: Serial No,Creation Document Type,Tvorba Typ dokumentu
DocType: Amazon MWS Settings,ES,ES
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invoices,Získejte faktury
apps/erpnext/erpnext/accounts/general_ledger.py,Make Journal Entry,Proveďte položka deníku
DocType: Leave Allocation,New Leaves Allocated,Nové Listy Přidělené
apps/erpnext/erpnext/controllers/trends.py,Project-wise data is not available for Quotation,Data dle projektu nejsou k dispozici pro nabídku
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,End on,Ukončete
DocType: Project,Expected End Date,Očekávané datum ukončení
DocType: Budget Account,Budget Amount,rozpočet Částka
DocType: Donor,Donor Name,Jméno dárce
DocType: Journal Entry,Inter Company Journal Entry Reference,Referenční položka Inter Company Journal Entry
DocType: Course,Topics,Témata
DocType: Tally Migration,Is Day Book Data Processed,Zpracovávají se údaje o denní knize
DocType: Appraisal Template,Appraisal Template Title,Posouzení Template Název
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Commercial,Obchodní
DocType: Patient,Alcohol Current Use,Alkohol Současné použití
DocType: Employee Tax Exemption Proof Submission,House Rent Payment Amount,Dům Pronájem Částka Platba
DocType: Student Admission Program,Student Admission Program,Studentský přijímací program
DocType: Employee Tax Exemption Sub Category,Tax Exemption Category,Kategorie osvobození od daně
DocType: Payment Entry,Account Paid To,Účet Věnována
DocType: Subscription Settings,Grace Period,Doba odkladu
DocType: Item Alternative,Alternative Item Name,Název alternativní položky
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py,Parent Item {0} must not be a Stock Item,Parent Item {0} nesmí být skladem
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Cannot create a Delivery Trip from Draft documents.,Z koncepčních dokumentů nelze vytvořit výjezd.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Website Listing,Seznam webových stránek
apps/erpnext/erpnext/config/buying.py,All Products or Services.,Všechny výrobky nebo služby.
DocType: Email Digest,Open Quotations,Otevřené nabídky
apps/erpnext/erpnext/www/all-products/item_row.html,More Details,Další podrobnosti
DocType: Supplier Quotation,Supplier Address,Dodavatel Address
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}. To bude přesahovat o {5}
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Creating bank entries...,Vytváření bankovních záznamů ...
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Out Qty,Out Množství
apps/erpnext/erpnext/buying/doctype/supplier/supplier.py,Series is mandatory,Série je povinné
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Financial Services,Finanční služby
DocType: Student Sibling,Student ID,Student ID
apps/erpnext/erpnext/config/projects.py,Types of activities for Time Logs,Typy činností pro Time Záznamy
DocType: Opening Invoice Creation Tool,Sales,Prodej
DocType: Stock Entry Detail,Basic Amount,Základní částka
DocType: Training Event,Exam,Zkouška
DocType: Email Campaign,Email Campaign,E-mailová kampaň
apps/erpnext/erpnext/public/js/hub/hub_call.js,Marketplace Error,Chyba trhu
DocType: Complaint,Complaint,Stížnost
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Warehouse required for stock Item {0},Sklad je vyžadován pro skladovou položku {0}
DocType: Leave Allocation,Unused leaves,Nepoužité listy
apps/erpnext/erpnext/patches/v11_0/create_department_records_for_each_company.py,All Departments,Všechny oddělení
DocType: Healthcare Service Unit,Vacant,Volný
DocType: Patient,Alcohol Past Use,Alkohol v minulosti
DocType: Fertilizer Content,Fertilizer Content,Obsah hnojiv
apps/erpnext/erpnext/public/js/hub/pages/Seller.vue,No description,Bez popisu
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Cr,Cr
DocType: Tax Rule,Billing State,Fakturace State
DocType: Quality Goal,Monitoring Frequency,Frekvence monitorování
DocType: Share Transfer,Transfer,Převod
DocType: Quality Action,Quality Feedback,Zpětná vazba kvality
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Work Order {0} must be cancelled before cancelling this Sales Order,Objednávka práce {0} musí být zrušena před zrušením této objednávky
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Fetch exploded BOM (including sub-assemblies),Fetch explodovala kusovníku (včetně montážních podskupin)
DocType: Authorization Rule,Applicable To (Employee),Vztahující se na (Employee)
apps/erpnext/erpnext/controllers/accounts_controller.py,Due Date is mandatory,Datum splatnosti je povinné
apps/erpnext/erpnext/controllers/accounts_controller.py,Cannot set quantity less than received quantity,Nelze nastavit množství menší než přijaté množství
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: Employee Benefit Claim,Benefit Type and Amount,Typ příspěvku a částka
DocType: Delivery Stop,Visited,Navštíveno
apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py,Rooms Booked,Pokoje objednané
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 dalšího kontaktu.
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batch Entries,Dávkové položky
DocType: Journal Entry,Pay To / Recd From,Platit K / Recd Z
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Unpublish Item,Zrušit publikování položky
DocType: Naming Series,Setup Series,Nastavení číselných řad
DocType: Payment Reconciliation,To Invoice Date,Chcete-li data vystavení faktury
DocType: Bank Account,Contact HTML,Kontakt HTML
DocType: Support Settings,Support Portal,Portál podpory
apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py,Registration fee can not be Zero,Registrační poplatek nesmí být nula
DocType: Disease,Treatment Period,Doba léčby
DocType: Travel Itinerary,Travel Itinerary,Cestovní itinerář
apps/erpnext/erpnext/education/api.py,Result already Submitted,Výsledek již byl odeslán
apps/erpnext/erpnext/controllers/buying_controller.py,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Rezervovaný sklad je povinný pro položku {0} v dodávaných surovinách
,Inactive Customers,neaktivní zákazníci
DocType: Student Admission Program,Maximum Age,Maximální věk
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Please wait 3 days before resending the reminder.,Počkejte 3 dny před odesláním připomínek.
DocType: Landed Cost Voucher,Purchase Receipts,Příjmky
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,"Upload a bank statement, link or reconcile a bank account","Nahrajte bankovní výpis, propojte nebo sjednejte bankovní účet"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,How Pricing Rule is applied?,Jak je pravidlo platby aplikováno?
DocType: Stock Entry,Delivery Note No,Dodacího listu
DocType: Cheque Print Template,Message to show,Zpráva ukázat
apps/erpnext/erpnext/public/js/setup_wizard.js,Retail,Maloobchodní
DocType: Student Attendance,Absent,Nepřítomný
DocType: Staffing Plan,Staffing Plan Detail,Personální plán detailu
DocType: Employee Promotion,Promotion Date,Datum propagace
apps/erpnext/erpnext/hr/doctype/leave_ledger_entry/leave_ledger_entry.py,Leave allocation %s is linked with leave application %s,Přidělení dovolené% s je spojeno s aplikací dovolená% s
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Product Bundle,Bundle Product
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 stojící skóre pokrývající 0 až 100
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Invalid reference {1},Řádek {0}: Neplatná reference {1}
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Please set valid GSTIN No. in Company Address for company {0},Zadejte prosím platné číslo GSTIN do firemní adresy společnosti {0}
apps/erpnext/erpnext/assets/doctype/location/location_tree.js,New Location,Nová poloha
DocType: Purchase Invoice,Purchase Taxes and Charges Template,Kupte Daně a poplatky šablony
DocType: Additional Salary,Date on which this component is applied,Datum použití této komponenty
DocType: Subscription,Current Invoice Start Date,Aktuální datum zahájení faktury
DocType: Designation Skill,Designation Skill,Označení Dovednost
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of goods,Dovoz zboží
DocType: Timesheet,TS-,TS-
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: buď debetní nebo kreditní částku je nutné pro {2}
DocType: GL Entry,Remarks,Poznámky
DocType: Support Settings,Track Service Level Agreement,Smlouva o úrovni služeb sledování
DocType: Hotel Room Amenity,Hotel Room Amenity,Hotel Room Amenity
apps/erpnext/erpnext/erpnext_integrations/connectors/woocommerce_connection.py,woocommerce - {0},woocommerce - {0}
DocType: Budget,Action if Annual Budget Exceeded on MR,Opatření v případě překročení ročního rozpočtu na MR
DocType: Course Enrollment,Course Enrollment,Zápis do kurzu
DocType: Payment Entry,Account Paid From,Účet jsou placeni z prostředků
DocType: Purchase Order Item Supplied,Raw Material Item Code,Surovina Kód položky
DocType: Task,Parent Task,Rodičovská úloha
DocType: Project,From Template,Ze šablony
DocType: Journal Entry,Write Off Based On,Odepsat založené na
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í
DocType: Stock Settings,Show Barcode Field,Show čárového kódu Field
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Send Supplier Emails,Poslat Dodavatel e-maily
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ž zpracovány pro období mezi {0} a {1}, ponechte dobu použitelnosti nemůže být mezi tomto časovém období."
DocType: Fiscal Year,Auto Created,Automaticky vytvořeno
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,Submit this to create the Employee record,"Chcete-li vytvořit záznam zaměstnance, odešlete jej"
DocType: Item Default,Item Default,Položka Výchozí
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Intra-State Supplies,Vnitrostátní zásoby
DocType: Chapter Member,Leave Reason,Nechte důvod
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py,IBAN is not valid,IBAN není platný
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Invoice {0} no longer exists,Faktura {0} již neexistuje
DocType: Guardian Interest,Guardian Interest,Guardian Zájem
DocType: Volunteer,Availability,Dostupnost
apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.py,Leave application is linked with leave allocations {0}. Leave application cannot be set as leave without pay,Opustit aplikaci je spojena s alokacemi dovolené {0}. Žádost o dovolenou nelze nastavit jako dovolenou bez odměny
apps/erpnext/erpnext/config/retail.py,Setup default values for POS Invoices,Nastavení výchozích hodnot pro POS faktury
DocType: Employee Training,Training,Výcvik
DocType: Project,Time to send,Čas odeslání
apps/erpnext/erpnext/public/js/hub/pages/Selling.vue,This page keeps track of your items in which buyers have showed some interest.,"Tato stránka sleduje vaše položky, o které kupující projevili určitý zájem."
DocType: Timesheet,Employee Detail,Detail zaměstnanec
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.py,Set warehouse for Procedure {0} ,Nastavte sklad pro postup {0}
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Email ID,ID e-mailu Guardian1
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Error: {0} is mandatory field,Chyba: {0} je povinné pole
DocType: Import Supplier Invoice,Invoice Series,Fakturační řada
DocType: Lab Prescription,Test Code,Testovací kód
apps/erpnext/erpnext/config/website.py,Settings for website homepage,Nastavení titulní stránce webu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} je podržen do {1}
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},RFQs nejsou povoleny pro {0} kvůli stavu scorecard {1}
apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Proveďte nákupní faktury
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Použité listy
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Použitý kupón je {1}. Povolené množství je vyčerpáno
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Chcete odeslat materiální žádost
DocType: Job Offer,Awaiting Response,Čeká odpověď
DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Above,Výše
DocType: Support Search Source,Link Options,Možnosti odkazu
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Total Amount {0},Celková částka {0}
apps/erpnext/erpnext/controllers/item_variant.py,Invalid attribute {0} {1},Neplatný atribut {0} {1}
DocType: Supplier,Mention if non-standard payable account,Uvedete-li neštandardní splatný účet
DocType: Employee,Emergency Contact Name,kontaktní jméno v případě nouze
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ž skupinu Všechny skupiny
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 požadováno nákladové středisko.
DocType: Training Event Employee,Optional,Volitelný
DocType: Salary Slip,Earning & Deduction,Výdělek a dedukce
DocType: Agriculture Analysis Criteria,Water Analysis,Analýza vody
DocType: Sales Order,Skip Delivery Note,Přeskočit dodací list
DocType: Price List,Price Not UOM Dependent,Cena není závislá na UOM
apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,Vytvořeny varianty {0}.
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: Quality Objective,Quality Objective,Cíl kvality
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 k filtrování v různých transakcí.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Negative Valuation Rate is not allowed,Negativní ocenění není povoleno
DocType: Holiday List,Weekly Off,Týdenní Off
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js,Reload Linked Analysis,Znovu načtení propojené analýzy
DocType: Fiscal Year,"For e.g. 2012, 2012-13","Pro např 2012, 2012-13"
DocType: Purchase Order,Purchase Order Pricing Rule,Pravidlo pro stanovení ceny objednávky
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Provisional Profit / Loss (Credit),Prozatímní Zisk / ztráta (Credit)
DocType: Sales Invoice,Return Against Sales Invoice,Návrat proti prodejní faktuře
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 5,Bod 5
DocType: Serial No,Creation Time,Čas vytvoření
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Total Revenue,Celkový příjem
DocType: Patient,Other Risk Factors,Další rizikové faktory
DocType: Sales Invoice,Product Bundle Help,Product Bundle Help
,Monthly Attendance Sheet,Měsíční Účast Sheet
DocType: Homepage Section Card,Subtitle,Titulky
apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py,No record found,Nebyl nalezen žádný záznam
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Scrapped Asset,Náklady na sešrotována aktiv
DocType: Employee Checkin,OUT,VEN
apps/erpnext/erpnext/controllers/stock_controller.py,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Nákladové středisko je povinný údaj pro položku {2}
DocType: Vehicle,Policy No,Ne politika
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get Items from Product Bundle,Položka získaná ze souboru výrobků
DocType: Asset,Straight Line,Přímka
DocType: Project User,Project User,projekt Uživatel
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split,Rozdělit
DocType: Tally Migration,Master Data,Hlavní data
DocType: Employee Transfer,Re-allocate Leaves,Přidělit listy
DocType: GL Entry,Is Advance,Je Zálohová
DocType: Job Offer,Applicant Email Address,E-mailová adresa žadatele
apps/erpnext/erpnext/config/hr.py,Employee Lifecycle,Životní cyklus zaměstnanců
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Attendance From Date and Attendance To Date is mandatory,Účast Datum od a docházky do dnešního dne je povinná
apps/erpnext/erpnext/controllers/buying_controller.py,Please enter 'Is Subcontracted' as Yes or No,"Prosím, zadejte ""subdodavatelům"" jako Ano nebo Ne"
DocType: Item,Default Purchase Unit of Measure,Výchozí nákupní měrná jednotka
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication Date,Poslední datum komunikace
DocType: Clinical Procedure Item,Clinical Procedure Item,Položka klinické procedury
DocType: Coupon Code,unique e.g. SAVE20  To be used to get discount,jedinečný např. SAVE20 Slouží k získání slevy
DocType: Sales Team,Contact No.,Kontakt Číslo
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Billing Address is same as Shipping Address,Fakturační adresa je stejná jako dodací adresa
DocType: Bank Reconciliation,Payment Entries,Platební Příspěvky
DocType: Location,Latitude,Zeměpisná šířka
DocType: Work Order,Scrap Warehouse,šrot Warehouse
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}","Chcete-li požadovat sklad v řádku č. {0}, nastavte výchozí sklad pro položku {1} pro firmu {2}"
DocType: Work Order,Check if material transfer entry is not required,"Zkontrolujte, zda není požadováno zadání materiálu"
DocType: Program Enrollment Tool,Get Students From,Získat studenty z
apps/erpnext/erpnext/config/help.py,Publish Items on Website,Publikovat položky na webových stránkách
apps/erpnext/erpnext/utilities/activation.py,Group your students in batches,Skupina vaši studenti v dávkách
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be greater than unadjusted amount,Přidělená částka nemůže být větší než neupravená částka
DocType: Authorization Rule,Authorization Rule,Autorizační pravidlo
apps/erpnext/erpnext/projects/doctype/project/project.py,Status must be Cancelled or Completed,Stav musí být zrušen nebo dokončen
DocType: Sales Invoice,Terms and Conditions Details,Podmínky podrobnosti
DocType: Sales Invoice,Sales Taxes and Charges Template,Prodej Daně a poplatky šablony
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Total (Credit),Celkový (Credit)
DocType: Repayment Schedule,Payment Date,Datum splatnosti
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch Qty,Nové dávkové množství
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Apparel & Accessories,Oblečení a doplňky
apps/erpnext/erpnext/controllers/accounts_controller.py,Item quantity can not be zero,Množství položky nemůže být nula
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Could not solve weighted score function. Make sure the formula is valid.,"Nelze vyřešit funkci váženého skóre. Zkontrolujte, zda je vzorec platný."
DocType: Invoice Discounting,Loan Period (Days),Výpůjční doba (dny)
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Purchase Order Items not received on time,Položky objednávky nebyly přijaty včas
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Number of Order,Číslo objednávky
DocType: Item Group,HTML / Banner that will show on the top of product list.,"HTML / Banner, který se zobrazí nahoře v produktovém listu."
DocType: Shipping Rule,Specify conditions to calculate shipping amount,Stanovení podmínek pro vypočítat výši poštovného
DocType: Program Enrollment,Institute's Bus,Autobus ústavu
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Role povoleno nastavit zmrazené účty a upravit Mražené Příspěvky
DocType: Supplier Scorecard Scoring Variable,Path,Cesta
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ého střediska na knihy, protože má podřízené uzly"
DocType: Production Plan,Total Planned Qty,Celkový plánovaný počet
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Transactions already retreived from the statement,Transakce již byly z výkazu odebrány
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Opening Value,otevření Value
DocType: Salary Component,Formula,Vzorec
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Serial #,Serial #
DocType: Material Request Plan Item,Required Quantity,Požadované množství
DocType: Lab Test Template,Lab Test Template,Šablona zkušebního laboratoře
apps/erpnext/erpnext/accounts/doctype/accounting_period/accounting_period.py,Accounting Period overlaps with {0},Účetní období se překrývá s {0}
apps/erpnext/erpnext/setup/doctype/company/company.py,Sales Account,Prodejní účet
DocType: Purchase Invoice Item,Total Weight,Celková váha
DocType: Pick List Item,Pick List Item,Vyberte položku seznamu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Commission on Sales,Provize z prodeje
DocType: Job Offer Term,Value / Description,Hodnota / Popis
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Řádek # {0}: Asset {1} nemůže být předložen, je již {2}"
DocType: Tax Rule,Billing Country,Fakturace Země
DocType: Purchase Order Item,Expected Delivery Date,Očekávané datum dodání
DocType: Restaurant Order Entry,Restaurant Order Entry,Vstup do objednávky restaurace
apps/erpnext/erpnext/accounts/general_ledger.py,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debetní a kreditní nerovná za {0} # {1}. Rozdíl je v tom {2}.
DocType: Clinical Procedure Item,Invoice Separately as Consumables,Faktury samostatně jako spotřební materiál
DocType: Budget,Control Action,Kontrolní akce
DocType: Asset Maintenance Task,Assign To Name,Přiřaďte k názvu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Entertainment Expenses,Výdaje na reprezentaci
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open Item {0},Otevřít položku {0}
DocType: Asset Finance Book,Written Down Value,Psaná hodnota dolů
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Prodejní faktury {0} musí být zrušena před zrušením této prodejní objednávky
DocType: Clinical Procedure,Age,Věk
DocType: Sales Invoice Timesheet,Billing Amount,Fakturace Částka
DocType: Cash Flow Mapping,Select Maximum Of 1,Vyberte možnost Maximálně 1
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Neplatný množství uvedené na položku {0}. Množství by mělo být větší než 0.
DocType: Company,Default Employee Advance Account,Výchozí účet předplatného pro zaměstnance
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Search Item (Ctrl + i),Položka vyhledávání (Ctrl + i)
DocType: C-Form,ACC-CF-.YYYY.-,ACC-CF-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction can not be deleted,Účet s transakcemi nemůže být smazán
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Why do think this Item should be removed?,"Proč si myslíte, že by tato položka měla být odstraněna?"
DocType: Vehicle,Last Carbon Check,Poslední Carbon Check
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Výdaje na právní služby
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Vyberte množství v řadě
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Pracovní objednávka {0}: pracovní list nebyl nalezen pro operaci {1}
DocType: Purchase Invoice,Posting Time,Čas zadání
DocType: Timesheet,% Amount Billed,% Fakturované částky
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefonní Náklady
DocType: Sales Partner,Logo,Logo
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, pokud chcete, aby uživateli vybrat sérii před uložením. Tam bude žádná výchozí nastavení, pokud jste zkontrolovat."
apps/erpnext/erpnext/stock/get_item_details.py,No Item with Serial No {0},No Položka s Serial č {0}
DocType: Email Digest,Open Notifications,Otevřené Oznámení
DocType: Payment Entry,Difference Amount (Company Currency),Rozdíl Částka (Company měna)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Expenses,Přímé náklady
DocType: Pricing Rule Detail,Child Docname,Název dítěte
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,New Customer Revenue,Nový zákazník Příjmy
apps/erpnext/erpnext/config/support.py,Service Level.,Úroveň služby.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Travel Expenses,Cestovní výdaje
DocType: Maintenance Visit,Breakdown,Rozbor
DocType: Travel Itinerary,Vegetarian,Vegetariánský
DocType: Patient Encounter,Encounter Date,Datum setkání
DocType: Work Order,Update Consumed Material Cost In Project,Aktualizujte spotřebované materiálové náklady v projektu
apps/erpnext/erpnext/controllers/accounts_controller.py,Account: {0} with currency: {1} can not be selected,Účet: {0} s měnou: {1} nelze vybrat
DocType: Bank Statement Transaction Settings Item,Bank Data,Bankovní údaje
DocType: Purchase Receipt Item,Sample Quantity,Množství vzorku
DocType: Bank Guarantee,Name of Beneficiary,Název příjemce
DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Aktualizujte náklady na BOM automaticky pomocí programu Plánovač, založený na nejnovější hodnotící sazbě / ceníku / posledním nákupu surovin."
DocType: Supplier,SUP-.YYYY.-,SUP-.YYYY.-
,BOM Items and Scraps,Položky a kousky kusovníku
DocType: Bank Reconciliation Detail,Cheque Date,Šek Datum
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} does not belong to company: {2},Účet {0}: Nadřazený účet {1} nepatří ke společnosti: {2}
apps/erpnext/erpnext/setup/doctype/company/company.js,Successfully deleted all transactions related to this company!,Úspěšně vypouští všechny transakce související s tímto společnosti!
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,As on Date,Stejně jako u Date
DocType: Additional Salary,HR,HR
DocType: Course Enrollment,Enrollment Date,zápis Datum
DocType: Healthcare Settings,Out Patient SMS Alerts,Upozornění na upozornění pacienta
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Probation,Zkouška
DocType: Company,Sales Settings,Nastavení prodeje
DocType: Program Enrollment Tool,New Academic Year,Nový akademický rok
DocType: Supplier Scorecard,Load All Criteria,Načíst všechna kritéria
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Return / Credit Note,Return / dobropis
DocType: Stock Settings,Auto insert Price List rate if missing,"Auto vložka Ceník sazba, pokud chybí"
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Total Paid Amount,Celkem uhrazené částky
DocType: GST Settings,B2C Limit,B2C Limit
DocType: Job Card,Transferred Qty,Přenesená Množství
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,The selected payment entry should be linked with a creditor bank transaction,Vybraný platební záznam by měl být spojen s transakcí věřitelské banky
DocType: POS Closing Voucher,Amount in Custody,Částka ve vazbě
apps/erpnext/erpnext/config/help.py,Navigating,Navigace
apps/erpnext/erpnext/hr/doctype/hr_settings/hr_settings.js,Password policy cannot contain spaces or simultaneous hyphens. The format will be restructured automatically,Zásady hesla nemohou obsahovat mezery ani souběžné spojovníky. Formát bude automaticky restrukturalizován
DocType: Quotation Item,Planning,Plánování
DocType: Salary Component,Depends on Payment Days,Závisí na platebních dnech
DocType: Contract,Signee,Signee
DocType: Share Balance,Issued,Vydáno
DocType: Loan,Repayment Start Date,Datum zahájení splacení
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Student Activity,Studentská aktivita
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Supplier Id,Dodavatel Id
DocType: Payment Request,Payment Gateway Details,Platební brána Podrobnosti
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity should be greater than 0,Množství by měla být větší než 0
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Price or product discount slabs are required,Vyžadovány jsou desky s cenou nebo cenou produktu
DocType: Journal Entry,Cash Entry,Cash Entry
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,Child nodes can be only created under 'Group' type nodes,Podřízené uzly mohou být vytvořeny pouze na základě typu uzly &quot;skupina&quot;
DocType: Attendance Request,Half Day Date,Half Day Date
DocType: Academic Year,Academic Year Name,Akademický rok Jméno
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} not allowed to transact with {1}. Please change the Company.,{0} není povoleno transakce s {1}. Změňte prosím společnost.
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í nemůže být vyšší než maximální částka osvobození {0} kategorie osvobození od daně {1}
DocType: Sales Partner,Contact Desc,Kontakt Popis
DocType: Email Digest,Send regular summary reports via Email.,Zasílat pravidelné souhrnné zprávy e-mailem.
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Please set default account in Expense Claim Type {0},Prosím nastavit výchozí účet v Expense reklamační typu {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Available Leaves,Dostupné listy
DocType: Assessment Result,Student Name,Jméno studenta
DocType: Hub Tracked Item,Item Manager,Manažer Položka
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Payroll Payable,Mzdové Splatné
DocType: GSTR 3B Report,April,duben
apps/erpnext/erpnext/config/crm.py,Helps you manage appointments with your leads,Pomáhá spravovat schůzky s vašimi potenciálními zákazníky
DocType: Plant Analysis,Collection Datetime,Čas odběru
DocType: Asset Repair,ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-
DocType: Work Order,Total Operating Cost,Celkové provozní náklady
apps/erpnext/erpnext/controllers/selling_controller.py,Note: Item {0} entered multiple times,Poznámka: Položka {0} vstoupil vícekrát
apps/erpnext/erpnext/config/buying.py,All Contacts.,Všechny kontakty.
DocType: Accounting Period,Closed Documents,Uzavřené dokumenty
DocType: Healthcare Settings,Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Správa faktury při odeslání a automatické zrušení faktury pro setkání pacienta
apps/erpnext/erpnext/config/website.py,Add cards or custom sections on homepage,Přidejte karty nebo vlastní sekce na domovskou stránku
DocType: Patient Appointment,Referring Practitioner,Odvolávající se praktikant
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html,Training Event:,Školení:
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation,Zkratka Company
apps/erpnext/erpnext/hr/doctype/employee/employee.py,User {0} does not exist,Uživatel: {0} neexistuje
DocType: Payment Term,Day(s) after invoice date,Den (dní) po datu faktury
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: Contract,Signed On,Přihlášeno
DocType: Bank Account,Party Type,Typ Party
DocType: Discounted Invoice,Discounted Invoice,Zvýhodněná faktura
DocType: Payment Schedule,Payment Schedule,Platební kalendář
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,No Employee found for the given employee field value. '{}': {},Pro danou hodnotu pole zaměstnance nebyl nalezen žádný zaměstnanec. &#39;{}&#39;: {}
DocType: Item Attribute Value,Abbreviation,Zkratka
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry already exists,Platba Entry již existuje
DocType: Course Content,Quiz,Kviz
DocType: Subscription,Trial Period End Date,Datum ukončení zkušebního období
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Not authroized since {0} exceeds limits,Není authroized od {0} překročí limity
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Start entering data from here : ,Začněte zadávat data odtud:
DocType: Serial No,Asset Status,Stav majetku
DocType: Sales Invoice,Over Dimensional Cargo (ODC),Rozměrný náklad (ODC)
DocType: Restaurant Order Entry,Restaurant Table,Restaurace Tabulka
DocType: Hotel Room,Hotel Manager,Hotelový manažer
apps/erpnext/erpnext/utilities/activation.py,Create Student Batch,Vytvořit studentskou dávku
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Set Tax Rule for shopping cart,Sada Daňové Pravidlo pro nákupního košíku
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.py,There are no vacancies under staffing plan {0},V rámci personálního plánu nejsou žádná volná místa {0}
DocType: Purchase Invoice,Taxes and Charges Added,Daně a poplatky přidané
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Odpisový řádek {0}: Další datum odpisování nemůže být před datem k dispozici
,Sales Funnel,Prodej Nálevka
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Zkratka je povinná
DocType: Project,Task Progress,Pokrok úkol
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Vozík
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.py,Bank account {0} already exists and could not be created again,Bankovní účet {0} již existuje a nelze jej znovu vytvořit
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Missed,Volání zmeškané
DocType: Certified Consultant,GitHub ID,GitHub ID
DocType: Staffing Plan,Total Estimated Budget,Celkový odhadovaný rozpočet
,Qty to Transfer,Množství pro přenos
apps/erpnext/erpnext/config/selling.py,Quotes to Leads or Customers.,Nabídka pro Lead nebo pro Zákazníka
DocType: Stock Settings,Role Allowed to edit frozen stock,Role povoleno upravovat zmrazené zásoby
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Customer Groups,Všechny skupiny zákazníků
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Accumulated Monthly,nahromaděné za měsíc
DocType: Attendance Request,On Duty,Ve službě
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 směnného kurzu pro {1} na {2}.
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}
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Template is mandatory.,Daňová šablona je povinné.
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}
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Last Issue,Poslední vydání
apps/erpnext/erpnext/regional/doctype/import_supplier_invoice/import_supplier_invoice.py,XML Files Processed,Soubory XML byly zpracovány
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} does not exist,Účet {0}: Nadřazený účet {1} neexistuje
DocType: Bank Account,Mask,Maska
DocType: POS Closing Voucher,Period Start Date,Datum zahájení období
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Ceník Rate (Company měny)
DocType: Products Settings,Products Settings,Nastavení Produkty
,Item Price Stock,Položka Cena Sklad
apps/erpnext/erpnext/config/retail.py,To make Customer based incentive schemes.,Vytvoření pobídkových schémat založených na zákazníkovi.
DocType: Lab Prescription,Test Created,Test byl vytvořen
DocType: Healthcare Settings,Custom Signature in Print,Vlastní podpis v tisku
DocType: Account,Temporary,Dočasný
DocType: Material Request Plan Item,Customer Provided,Poskytováno zákazníkem
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Customer LPO No.,Zákaznické číslo LPO
DocType: Amazon MWS Settings,Market Place Account Group,Skupina účtů na trhu
DocType: Program,Courses,předměty
DocType: Monthly Distribution Percentage,Percentage Allocation,Procento přidělení
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Secretary,Sekretářka
apps/erpnext/erpnext/regional/india/utils.py,House rented dates required for exemption calculation,"Dny pronajaté v domě, které jsou zapotřebí k výpočtu výjimky"
DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Pokud zakázat, &quot;ve slovech&quot; poli nebude viditelný v jakékoli transakce"
DocType: Quality Review Table,Quality Review Table,Tabulka pro kontrolu kvality
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 zrušit tento odběr?
DocType: Serial No,Distinct unit of an Item,Samostatnou jednotku z položky
DocType: Supplier Scorecard Criteria,Criteria Name,Název kritéria
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.js,Please set Company,Nastavte společnost
DocType: Procedure Prescription,Procedure Created,Postup byl vytvořen
DocType: Pricing Rule,Buying,Nákupy
apps/erpnext/erpnext/config/agriculture.py,Diseases & Fertilizers,Nemoci a hnojiva
DocType: HR Settings,Employee Records to be created by,"Zaměstnanec Záznamy, které vytvořil"
DocType: Inpatient Record,AB Negative,AB Negativní
DocType: POS Profile,Apply Discount On,Použít Sleva na
DocType: Member,Membership Type,Typ členství
,Reqd By Date,Př p Podle data
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Creditors,Věřitelé
DocType: Assessment Plan,Assessment Name,Název Assessment
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No is mandatory,Řádek # {0}: Výrobní číslo je povinné
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Položka Wise Tax Detail
DocType: Employee Onboarding,Job Offer,Nabídka práce
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Abbreviation,institut Zkratka
,Item-wise Price List Rate,Item-moudrý Ceník Rate
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Supplier Quotation,Dodavatel Nabídka
apps/erpnext/erpnext/crm/doctype/appointment_booking_settings/appointment_booking_settings.py,The difference between from time and To Time must be a multiple of Appointment,Rozdíl mezi časem a časem musí být násobkem schůzky
apps/erpnext/erpnext/config/support.py,Issue Priority.,Priorita vydání.
DocType: Quotation,In Words will be visible once you save the Quotation.,"Ve slovech budou viditelné, jakmile uložíte nabídku."
apps/erpnext/erpnext/utilities/transaction_base.py,Quantity ({0}) cannot be a fraction in row {1},Množství ({0}) nemůže být zlomek v řádku {1}
DocType: Contract,Unsigned,Nepodepsaný
DocType: Selling Settings,Each Transaction,Každé Transakce
apps/erpnext/erpnext/stock/doctype/item/item.py,Barcode {0} already used in Item {1},Čárový kód {0} již použit u položky {1}
DocType: Shift Type,The time before the shift end time when check-out is considered as early (in minutes).,"Čas před koncem směny, kdy je check-out považován za časný (v minutách)."
apps/erpnext/erpnext/config/selling.py,Rules for adding shipping costs.,Pravidla pro přidávání náklady na dopravu.
DocType: Hotel Room,Extra Bed Capacity,Kapacita přistýlek
apps/erpnext/erpnext/config/hr.py,Performance,Výkon
DocType: Import Supplier Invoice,Click on Import Invoices button once the zip file has been attached to the document. Any errors related to processing will be shown in the Error Log.,Po připojení zip souboru k dokumentu klikněte na tlačítko Importovat faktury. Veškeré chyby související se zpracováním se zobrazí v protokolu chyb.
DocType: Item,Opening Stock,Počáteční stav zásob
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Customer is required,Je nutná zákazník
DocType: Lab Test,Result Date,Datum výsledku
DocType: Purchase Order,To Receive,Obdržet
DocType: Leave Period,Holiday List for Optional Leave,Dovolená seznam pro nepovinné dovolené
DocType: Item Tax Template,Tax Rates,Daňová sazba
DocType: Asset,Asset Owner,Majitel majetku
DocType: Item,Website Content,Obsah webových stránek
DocType: Bank Account,Integration ID,ID integrace
DocType: Purchase Invoice,Reason For Putting On Hold,Důvod pro pozdržení
DocType: Employee,Personal Email,Osobní e-mail
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Variance,Celkový rozptyl
DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Pokud je povoleno, bude systém odesílat účetní položky k zásobám automaticky."
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() accepted invalid IBAN {},BankAccount.validate_iban () přijal neplatný IBAN {}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Brokerage,Makléřská
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Attendance for employee {0} is already marked for this day,Účast na zaměstnance {0} je již označen pro tento den
DocType: Work Order Operation,"in Minutes
Updated via 'Time Log'","v minutách 
 aktualizovat přes ""Time Log"""
DocType: Customer,From Lead,Od Leadu
DocType: Amazon MWS Settings,Synch Orders,Synchronizace objednávek
apps/erpnext/erpnext/config/manufacturing.py,Orders released for production.,Objednávky uvolněna pro výrobu.
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Fiscal Year...,Vyberte fiskálního roku ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,"POS Profile požadováno, aby POS Vstup"
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 výdajů (prostřednictvím faktury k prodeji) na základě zmíněného faktoru sběru.
DocType: Program Enrollment Tool,Enroll Students,zapsat studenti
DocType: Pricing Rule,Coupon Code Based,Kód založený na kupónu
DocType: Company,HRA Settings,Nastavení HRA
DocType: Homepage,Hero Section,Hero Section
DocType: Employee Transfer,Transfer Date,Datum přenosu
DocType: Lab Test,Approved Date,Datum schválení
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Selling,Standardní prodejní
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Atleast one warehouse is mandatory,Alespoň jeden sklad je povinný
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.","Konfigurovat pole položek jako UOM, skupina položek, popis a počet hodin."
DocType: Certification Application,Certification Status,Stav certifikace
apps/erpnext/erpnext/public/js/hub/marketplace.js,Marketplace,Trh
DocType: Travel Itinerary,Travel Advance Required,Vyžaduje se cestovní záloha
DocType: Subscriber,Subscriber Name,Jméno účastníka
DocType: Serial No,Out of Warranty,Out of záruky
DocType: Bank Statement Transaction Settings Item,Mapped Data Type,Mapovaný typ dat
DocType: BOM Update Tool,Replace,Vyměnit
apps/erpnext/erpnext/templates/includes/product_list.js,No products found.,Nenašli se žádné produkty.
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,Publish More Items,Publikovat více položek
apps/erpnext/erpnext/support/doctype/issue/issue.py,This Service Level Agreement is specific to Customer {0},Tato smlouva o úrovni služeb je specifická pro zákazníka {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Invoice {1},{0} proti vystavené faktuře {1}
DocType: Antibiotic,Laboratory User,Laboratorní uživatel
DocType: Request for Quotation Item,Project Name,Název projektu
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Customer Address,Nastavte prosím zákaznickou adresu
DocType: Customer,Mention if non-standard receivable account,Zmínka v případě nestandardní pohledávky účet
DocType: Bank,Plaid Access Token,Plaid Access Token
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 zbývající výhody {0} do kterékoli existující komponenty
DocType: Journal Entry Account,If Income or Expense,Pokud je výnos nebo náklad
DocType: Course Topic,Course Topic,Téma kurzu
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/pos_closing_voucher.py,POS Closing Voucher alreday exists for {0} between date {1} and {2},POS Uzavírací kupón alreday existuje pro {0} mezi datem {1} a {2}
DocType: Bank Statement Transaction Entry,Matching Invoices,Shoda faktur
DocType: Work Order,Required Items,Povinné předměty
DocType: Stock Ledger Entry,Stock Value Difference,Reklamní Value Rozdíl
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 nad tabulkou {1}
apps/erpnext/erpnext/config/help.py,Human Resource,Lidské Zdroje
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Platba Odsouhlasení Platba
DocType: Disease,Treatment Task,Úloha léčby
DocType: Payment Order Reference,Bank Account Details,Detaily bankovního účtu
DocType: Purchase Order Item,Blanket Order,Dekorační objednávka
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.py,Repayment Amount must be greater than ,Částka splacení musí být vyšší než
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Tax Assets,Daňové Aktiva
DocType: BOM Item,BOM No,Číslo kusovníku
apps/erpnext/erpnext/public/js/hub/components/edit_details_dialog.js,Update Details,Aktualizujte podrobnosti
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Journal Entry {0} does not have account {1} or already matched against other voucher,Zápis do deníku {0} nemá účet {1} nebo již uzavřeno proti ostatním poukaz
DocType: Item,Moving Average,Klouzavý průměr
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Benefit,Výhoda
DocType: BOM Update Tool,The BOM which will be replaced,"BOM, který bude nahrazen"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Electronic Equipments,elektronická zařízení
DocType: Asset,Maintenance Required,Nutná údržba
DocType: Account,Debit,Debet
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leaves must be allocated in multiples of 0.5,"Dovolené musí být přiděleny v násobcích 0,5"
DocType: Work Order,Operation Cost,Provozní náklady
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Identifying Decision Makers,Identifikace rozhodovacích orgánů
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Outstanding Amt,Vynikající Amt
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Nastavit cíle Item Group-moudrý pro tento prodeje osobě.
DocType: Stock Settings,Freeze Stocks Older Than [Days],Freeze Zásoby Starší než [dny]
DocType: Payment Entry,Payment Ordered,Objednané platby
DocType: Asset Maintenance Team,Maintenance Team Name,Název týmu údržby
DocType: Driving License Category,Driver licence class,Třída řidičského průkazu
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 dva nebo více pravidla pro tvorbu cen se nacházejí na základě výše uvedených podmínek, priorita je aplikována. Priorita je číslo od 0 do 20, zatímco výchozí hodnota je nula (prázdný). Vyšší číslo znamená, že bude mít přednost, pokud existuje více pravidla pro tvorbu cen se za stejných podmínek."
apps/erpnext/erpnext/controllers/trends.py,Fiscal Year: {0} does not exists,Fiskální rok: {0} neexistuje
DocType: Currency Exchange,To Currency,Chcete-li měny
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Nechte následující uživatelé schválit Žádost o dovolenou.
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Lifecycle,Životní cyklus
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Payment Document Type,Typ platebního dokladu
apps/erpnext/erpnext/controllers/selling_controller.py,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Prodejní cena pro položku {0} je nižší než její {1}. Míra prodeje by měla být nejméně {2}
DocType: Designation Skill,Skill,Dovednost
DocType: Subscription,Taxes,Daně
DocType: Purchase Invoice Item,Weight Per Unit,Hmotnost na jednotku
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Paid and Not Delivered,Uhrazené a nedoručené
DocType: QuickBooks Migrator,Default Cost Center,Výchozí Center Náklady
apps/erpnext/erpnext/www/all-products/index.html,Toggle Filters,Přepnout filtry
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in company {1},Set {0} ve společnosti {1}
apps/erpnext/erpnext/config/stock.py,Stock Transactions,Sklad Transakce
DocType: Budget,Budget Accounts,rozpočtové účty
DocType: Employee,Internal Work History,Vnitřní práce History
DocType: Bank Statement Transaction Entry,New Transactions,Nové transakce
DocType: Depreciation Schedule,Accumulated Depreciation Amount,Oprávky Částka
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Private Equity,Private Equity
DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Variabilní ukazatel ukazatele dodavatele
DocType: Shift Type,Working Hours Threshold for Half Day,Práh pracovní doby na půl dne
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please create purchase receipt or purchase invoice for the item {0},Pro položku {0} vytvořte potvrzení o nákupu nebo nákupní fakturu.
DocType: Job Card,Material Transferred,Převedený materiál
DocType: Employee Advance,Due Advance Amount,Splatná částka předem
DocType: Maintenance Visit,Customer Feedback,Zpětná vazba od zákazníků
DocType: Account,Expense,Výdaj
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js,Score cannot be greater than Maximum Score,Skóre nemůže být větší než maximum bodů
DocType: Support Search Source,Source Type,Typ zdroje
DocType: Course Content,Course Content,Obsah kurzu
DocType: Item Attribute,From Range,Od Rozsah
DocType: BOM,Set rate of sub-assembly item based on BOM,Nastavte ocenění položky podsestavy na základě kusovníku
DocType: Inpatient Occupancy,Invoiced,Fakturováno
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,WooCommerce Products,Produkty WooCommerce
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in formula or condition: {0},syntaktická chyba ve vzorci nebo stavu: {0}
apps/erpnext/erpnext/stock/utils.py,Item {0} ignored since it is not a stock item,"Položka {0} ignorována, protože to není skladem"
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.","Nechcete-li použít Ceník článek v dané transakce, by měly být všechny platné pravidla pro tvorbu cen zakázáno."
DocType: Payment Term,Day(s) after the end of the invoice month,Den (den) po skončení měsíce faktury
DocType: Assessment Group,Parent Assessment Group,Mateřská skupina Assessment
DocType: Employee Checkin,Shift Actual End,Shift Skutečný konec
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Jobs,Jobs
,Sales Order Trends,Prodejní objednávky Trendy
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.,&quot;Z balíčku č.&quot; pole nesmí být prázdné ani jeho hodnota menší než 1.
DocType: Employee,Held On,Které se konalo dne
DocType: Job Card,Production Item,Výrobní položka
,Employee Information,Informace o zaměstnanci
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Healthcare Practitioner not available on {0},Lékař není k dispozici na {0}
DocType: Stock Entry Detail,Additional Cost,Dodatečné náklady
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ě poukazu ne, pokud seskupeny podle poukazu"
DocType: Quality Inspection,Incoming,Přicházející
apps/erpnext/erpnext/setup/doctype/company/company.js,Default tax templates for sales and purchase are created.,Výchozí daňové šablony pro prodej a nákup jsou vytvořeny.
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py,Assessment Result record {0} already exists.,Výsledky hodnocení {0} již existuje.
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. #####. Je-li nastavena řada a v transakcích není uvedena šarže, pak se na základě této série vytvoří automatické číslo šarže. Pokud chcete výslovně uvést číslo dávky pro tuto položku, ponechte prázdné místo. Poznámka: Toto nastavení bude mít přednost před předčíslí série Naming v nastavení akcí."
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Outward taxable supplies(zero rated),Dodávky podléhající zdanění (s nulovým hodnocením)
DocType: BOM,Materials Required (Exploded),Potřebný materiál (Rozložený)
apps/erpnext/erpnext/buying/report/purchase_analytics/purchase_analytics.js,based_on,na základě
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Submit Review,Odeslat recenzi
DocType: Contract,Party User,Party Uživatel
apps/erpnext/erpnext/controllers/buying_controller.py,Assets not created for <b>{0}</b>. You will have to create asset manually.,Aktiva nebyla vytvořena pro <b>{0}</b> . Budete muset vytvořit dílo ručně.
apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',"Nastavte filtr společnosti prázdný, pokud je Skupina By je &#39;Company&#39;"
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Vysílání datum nemůže být budoucí datum
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Řádek # {0}: Výrobní číslo {1} neodpovídá {2} {3}
DocType: Stock Entry,Target Warehouse Address,Cílová adresa skladu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Casual Leave
DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"Čas před začátkem směny, během kterého je za účast považováno přihlášení zaměstnanců."
DocType: Agriculture Task,End Day,Den konce
DocType: Batch,Batch ID,Šarže ID
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Note: {0},Poznámka: {0}
DocType: Stock Settings,Action if Quality inspection is not submitted,"Akce, pokud není předložena kontrola kvality"
,Delivery Note Trends,Dodací list Trendy
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,This Week's Summary,Tento týden Shrnutí
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,In Stock Qty,Na skladě Množství
,Daily Work Summary Replies,Denní shrnutí odpovědí
DocType: Delivery Trip,Calculate Estimated Arrival Times,Vypočítat odhadované časy příjezdu
apps/erpnext/erpnext/accounts/general_ledger.py,Account: {0} can only be updated via Stock Transactions,Účet: {0} lze aktualizovat pouze prostřednictvím Skladových Transakcí
DocType: Student Group Creation Tool,Get Courses,Získat kurzy
DocType: Tally Migration,ERPNext Company,ERPDext Company
DocType: Shopify Settings,Webhooks,Webhooks
DocType: Bank Account,Party,Strana
DocType: Healthcare Settings,Patient Name,Jméno pacienta
DocType: Variant Field,Variant Field,Pole variant
DocType: Asset Movement Item,Target Location,Cílová lokace
DocType: Sales Order,Delivery Date,Dodávka Datum
DocType: Opportunity,Opportunity Date,Příležitost Datum
DocType: Employee,Health Insurance Provider,Poskytovatel zdravotního pojištění
DocType: Service Level,Holiday List (ignored during SLA calculation),Seznam svátků (ignorován během výpočtu SLA)
DocType: Products Settings,Show Availability Status,Zobrazit stav dostupnosti
DocType: Purchase Receipt,Return Against Purchase Receipt,Návrat Proti doklad o koupi
DocType: Water Analysis,Person Responsible,Zodpovědná osoba
DocType: Request for Quotation Item,Request for Quotation Item,Žádost o cenovou nabídku výtisku
DocType: Purchase Order,To Bill,Billa
DocType: Material Request,% Ordered,% objednáno
DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",Pro kurzovou studentskou skupinu bude kurz pro každého studenta ověřen z přihlášených kurzů při zápisu do programu.
DocType: Employee Grade,Employee Grade,Pracovní zařazení
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Úkolová práce
DocType: GSTR 3B Report,June,červen
DocType: Share Balance,From No,Od č
DocType: Shift Type,Early Exit Grace Period,Časné ukončení odkladu
DocType: Task,Actual Time (in Hours),Skutečná doba (v hodinách)
DocType: Employee,History In Company,Historie ve Společnosti
DocType: Customer,Customer Primary Address,Primární adresa zákazníka
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Connected,Hovor připojen
apps/erpnext/erpnext/config/crm.py,Newsletters,Zpravodaje
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Reference No.,Referenční číslo
DocType: Drug Prescription,Description/Strength,Popis / Pevnost
apps/erpnext/erpnext/config/hr.py,Energy Point Leaderboard,Energy Point Leaderboard
DocType: Bank Statement Transaction Entry,Create New Payment/Journal Entry,Vytvořit novou položku platby / deník
DocType: Certification Application,Certification Application,Certifikační aplikace
DocType: Leave Type,Is Optional Leave,Je volitelné volno
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Declare Lost,Prohlásit prohry
DocType: Share Balance,Is Company,Je společnost
DocType: Pricing Rule,Same Item,Stejná položka
DocType: Stock Ledger Entry,Stock Ledger Entry,Reklamní Ledger Entry
DocType: Quality Action Resolution,Quality Action Resolution,Kvalitní akční rozlišení
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Half day Leave on {1},{0} v půldenní dovolené na {1}
DocType: Department,Leave Block List,Nechte Block List
DocType: Purchase Invoice,Tax ID,DIČ
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í nastavení pro Serial č. Sloupec musí být prázdný
apps/erpnext/erpnext/regional/india/utils.py,Either GST Transporter ID or Vehicle No is required if Mode of Transport is Road,"Je-li způsob dopravy silniční, vyžaduje se ID dopravce GST nebo číslo vozidla"
DocType: Accounts Settings,Accounts Settings,Nastavení účtu
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Approve,Schvalovat
DocType: Loyalty Program,Customer Territory,Zákaznické území
DocType: Email Digest,Sales Orders to Deliver,Prodejní objednávky k dodání
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 bude do názvu účtu zahrnuto jako předčíslí
DocType: Maintenance Team Member,Team Member,Člen týmu
DocType: GSTR 3B Report,Invoices with no Place Of Supply,Faktury bez místa dodání
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,No Result to submit,Žádný výsledek k odeslání
DocType: Customer,Sales Partner and Commission,Prodej Partner a Komise
DocType: Loan,Rate of Interest (%) / Year,Úroková sazba (%) / rok
,Project Quantity,projekt Množství
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'","Celkem {0} pro všechny položky je nula, může být byste měli změnit &quot;Rozdělte poplatků založený na&quot;"
apps/erpnext/erpnext/hr/utils.py,To date can not be less than from date,K dnešnímu dni nemůže být méně než od data
DocType: Opportunity,To Discuss,K projednání
apps/erpnext/erpnext/stock/stock_ledger.py,{0} units of {1} needed in {2} to complete this transaction.,{0} jednotek {1} zapotřebí {2} pro dokončení této transakce.
DocType: Loan Type,Rate of Interest (%) Yearly,Úroková sazba (%) Roční
apps/erpnext/erpnext/config/quality_management.py,Quality Goal.,Kvalitní cíl.
DocType: Support Settings,Forum URL,Adresa URL fóra
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Accounts,Dočasné Účty
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Source Location is required for the asset {0},Místo zdroje je požadováno pro daný účet {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Black,Černá
DocType: BOM Explosion Item,BOM Explosion Item,BOM Explosion Item
DocType: Shareholder,Contact List,Seznam kontaktů
DocType: Account,Auditor,Auditor
DocType: Project,Frequency To Collect Progress,Frekvence pro shromažďování pokroku
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items produced,{0} předměty vyrobené
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} is not added in the table,{0} není přidáno do tabulky
DocType: Payment Entry,Party Bank Account,Bankovní účet strany
DocType: Cheque Print Template,Distance from top edge,Vzdálenost od horního okraje
DocType: POS Closing Voucher Invoices,Quantity of Items,Množství položek
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py,Price List {0} is disabled or does not exist,Ceníková cena {0} je zakázáno nebo neexistuje
DocType: Purchase Invoice,Return,Zpáteční
DocType: Account,Disable,Zakázat
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Mode of payment is required to make a payment,Způsob platby je povinen provést platbu
DocType: Task,Pending Review,Čeká Review
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,"Edit in full page for more options like assets, serial nos, batches etc.","Upravte celou stránku pro další možnosti, jako jsou majetek, sériový nos, šarže atd."
DocType: Leave Type,Maximum Continuous Days Applicable,Maximální počet nepřetržitých dnů
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 4,Rozsah stárnutí 4
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Batch {2},{0} - {1} není zapsána v dávce {2}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,"Asset {0} cannot be scrapped, as it is already {1}","Aktiva {0} nemůže být vyhozen, jak je tomu již {1}"
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Cheques Required,Potřebné kontroly
DocType: Task,Total Expense Claim (via Expense Claim),Total Expense Claim (via Expense nároku)
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Absent,Mark Absent
DocType: Job Applicant Source,Job Applicant Source,Zdroj žádosti o zaměstnání
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,IGST Amount,IGST částka
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup company,Nepodařilo se nastavit firmu
DocType: Asset Repair,Asset Repair,Opravy aktiv
DocType: Warehouse,Warehouse Type,Typ skladu
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 BOM # {1} by se měla rovnat vybrané měně {2}
DocType: Journal Entry Account,Exchange Rate,Exchange Rate
DocType: Patient,Additional information regarding the patient,Další informace týkající se pacienta
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Sales Order {0} is not submitted,Prodejní objednávky {0} není předložena
DocType: Homepage,Tag Line,tag linka
DocType: Fee Component,Fee Component,poplatek Component
apps/erpnext/erpnext/config/hr.py,Fleet Management,Fleet management
apps/erpnext/erpnext/config/agriculture.py,Crops & Lands,Plodiny a půdy
DocType: Shift Type,Enable Exit Grace Period,Povolit ukončení doby odkladu
DocType: Cheque Print Template,Regular,Pravidelný
DocType: Fertilizer,Density (if liquid),Hustota (pokud je kapalina)
apps/erpnext/erpnext/education/doctype/course/course.py,Total Weightage of all Assessment Criteria must be 100%,Celková weightage všech hodnotících kritérií musí být 100%
DocType: Purchase Order Item,Last Purchase Rate,Poslední nákupní sazba
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,"Asset {0} cannot be received at a location and \
							given to employee in a single movement",Aktivum {0} nemůže být přijato na místě a \ dáno zaměstnanci v jediném pohybu
DocType: GSTR 3B Report,August,srpen
DocType: Account,Asset,Majetek
DocType: Quality Goal,Revised On,Revidováno dne
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 k bodu {0}, protože má varianty"
DocType: Healthcare Practitioner,Mobile,"mobilní, pohybliví"
DocType: Issue,Reset Service Level Agreement,Obnovit dohodu o úrovni služeb
,Sales Person-wise Transaction Summary,Prodej Person-moudrý Shrnutí transakce
DocType: Training Event,Contact Number,Kontaktní číslo
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} does not exist,Sklad {0} neexistuje
DocType: Cashier Closing,Custody,Péče
DocType: Employee Tax Exemption Proof Submission Detail,Employee Tax Exemption Proof Submission Detail,Podrobnosti o předložení dokladu o osvobození od daně z provozu zaměstnanců
DocType: Monthly Distribution,Monthly Distribution Percentages,Měsíční Distribuční Procenta
apps/erpnext/erpnext/stock/doctype/batch/batch.py,The selected item cannot have Batch,Vybraná položka nemůže mít dávku
DocType: Delivery Note,% of materials delivered against this Delivery Note,% Materiálů doručeno proti tomuto dodacímu listu
DocType: Asset Maintenance Log,Has Certificate,Má certifikát
DocType: Appointment,Customer Details,Podrobnosti zákazníků
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.js,Print IRS 1099 Forms,Tisk IRS 1099 formulářů
DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,"Zkontrolujte, zda majetek vyžaduje preventivní údržbu nebo kalibraci"
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation cannot have more than 5 characters,Společnost Zkratka nesmí mít více než 5 znaků
DocType: Employee,Reports to,Zprávy
,Unpaid Expense Claim,Neplacené Náklady na pojistná
DocType: Payment Entry,Paid Amount,Uhrazené částky
DocType: Assessment Plan,Supervisor,Dozorce
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Retention Stock Entry,Retention Stock Entry
,Available Stock for Packing Items,K dispozici skladem pro balení položek
DocType: Item Variant,Item Variant,Položka Variant
DocType: Employee Skill Map,Trainings,Školení
,Work Order Stock Report,Zpráva o stavu pracovní smlouvy
DocType: Purchase Receipt,Auto Repeat Detail,Auto opakovat detail
DocType: Assessment Result Tool,Assessment Result Tool,Assessment Tool Výsledek
apps/erpnext/erpnext/education/doctype/instructor/instructor.js,As Supervisor,Jako školitel
DocType: Leave Policy Detail,Leave Policy Detail,Ponechte detaily zásad
DocType: BOM Scrap Item,BOM Scrap Item,BOM Scrap Item
apps/erpnext/erpnext/accounts/page/pos/pos.js,Submitted orders can not be deleted,Předložené objednávky nelze smazat
DocType: Leave Control Panel,Department (optional),Oddělení (volitelné)
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 na účtu již v inkasa, není dovoleno stanovit ""Balance musí být"" jako ""úvěru"""
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> , na položku se použije schéma <b>{3}</b> ."
DocType: Customer Feedback,Quality Management,Řízení kvality
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} has been disabled,Item {0} byl zakázán
DocType: Project,Total Billable Amount (via Timesheets),Celková fakturační částka (prostřednictvím časových lístků)
DocType: Agriculture Task,Previous Business Day,Předchozí pracovní den
DocType: Loan,Repay Fixed Amount per Period,Splatit pevná částka na období
DocType: Employee,Health Insurance No,Zdravotní pojištění č
DocType: Employee Tax Exemption Proof Submission,Tax Exemption Proofs,Osvědčení o osvobození od daně
apps/erpnext/erpnext/buying/utils.py,Please enter quantity for Item {0},"Zadejte prosím množství produktů, bod {0}"
DocType: Quality Procedure,Processes,Procesy
DocType: Shift Type,First Check-in and Last Check-out,První check-in a poslední check-out
apps/erpnext/erpnext/regional/report/hsn_wise_summary_of_outward_supplies/hsn_wise_summary_of_outward_supplies.py,Total Taxable Amount,Celková zdanitelná částka
DocType: Employee External Work History,Employee External Work History,Zaměstnanec vnější práce History
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Job card {0} created,Byla vytvořena karta {0}
DocType: Opening Invoice Creation Tool,Purchase,Nákup
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Balance Qty,Zůstatek Množství
DocType: Pricing Rule,Conditions will be applied on all the selected items combined. ,Na všechny vybrané položky budou použity podmínky společně.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Goals cannot be empty,Cíle nemůže být prázdný
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js,Enrolling students,Přijímání studentů
DocType: Item Group,Parent Item Group,Parent Item Group
DocType: Appointment Type,Appointment Type,Typ schůzky
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,{0} for {1},{0} pro {1}
DocType: Healthcare Settings,Valid number of days,Platný počet dnů
apps/erpnext/erpnext/setup/doctype/company/company.js,Cost Centers,Nákladové středisko
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Restart Subscription,Restartujte předplatné
DocType: Linked Plant Analysis,Linked Plant Analysis,Analýza propojených rostlin
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Transporter ID,ID přepravce
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Value Proposition,Návrh hodnoty
DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,"Sazba, za kterou dodavatel měny je převeden na společnosti základní měny"
DocType: Purchase Invoice Item,Service End Date,Datum ukončení služby
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,Row #{0}: Timings conflicts with row {1},Row # {0}: časování v rozporu s řadou {1}
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Povolit nulovou míru oceňování
DocType: Bank Guarantee,Receiving,Příjem
DocType: Training Event Employee,Invited,Pozván
apps/erpnext/erpnext/config/accounts.py,Setup Gateway accounts.,Nastavení brány účty.
apps/erpnext/erpnext/config/integrations.py,Connect your bank accounts to ERPNext,Propojte své bankovní účty s ERPNext
DocType: Employee,Employment Type,Typ zaměstnání
apps/erpnext/erpnext/config/projects.py,Make project from a template.,Vytvořte projekt ze šablony.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Fixed Assets,Dlouhodobý majetek
DocType: Payment Entry,Set Exchange Gain / Loss,Set Exchange zisk / ztráta
,GST Purchase Register,GST Nákupní registr
,Cash Flow,Tok peněz
DocType: Shareholder,ACC-SH-.YYYY.-,ACC-SH-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,Combined invoice portion must equal 100%,Kombinovaná část faktury se musí rovnat 100%
DocType: Item Default,Default Expense Account,Výchozí výdajový účet
DocType: GST Account,CGST Account,CGST účet
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Email ID,Student ID e-mailu
DocType: Employee,Notice (days),Oznámení (dny)
DocType: POS Closing Voucher Invoices,POS Closing Voucher Invoices,Pokladní doklady POS
DocType: Tax Rule,Sales Tax Template,Daň z prodeje Template
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Download JSON,Stáhněte si JSON
DocType: Employee Benefit Application Detail,Pay Against Benefit Claim,Platba proti nároku na dávku
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Update Cost Center Number,Aktualizovat číslo nákladového střediska
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select items to save the invoice,"Vyberte položky, které chcete uložit fakturu"
DocType: Employee,Encashment Date,Inkaso Datum
DocType: Training Event,Internet,Internet
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Seller Information,Informace o prodávajícím
DocType: Special Test Template,Special Test Template,Speciální zkušební šablona
DocType: Account,Stock Adjustment,Reklamní Nastavení
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,Default Activity Cost exists for Activity Type - {0},Existuje Náklady Výchozí aktivity pro Typ aktivity - {0}
DocType: Work Order,Planned Operating Cost,Plánované provozní náklady
DocType: Academic Term,Term Start Date,Termín Datum zahájení
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Authentication Failed,Ověření se nezdařilo
apps/erpnext/erpnext/config/accounts.py,List of all share transactions,Seznam všech transakcí s akciemi
DocType: Supplier,Is Transporter,Je Transporter
DocType: Shopify Settings,Import Sales Invoice from Shopify if Payment is marked,"Import faktury z Shopify, pokud je platba označena"
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp Count,Opp Count
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Both Trial Period Start Date and Trial Period End Date must be set,Musí být nastaven datum zahájení zkušebního období a datum ukončení zkušebního období
apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py,Average Rate,Průměrné hodnocení
apps/erpnext/erpnext/controllers/accounts_controller.py,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Celková částka platby v rozpisu plateb se musí rovnat hodnotě Grand / Rounded Total
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot have Valuation Rate",„Položka poskytovaná zákazníkem“ nemůže mít sazbu ocenění
DocType: Subscription Plan Detail,Plan,Plán
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Bank Statement balance as per General Ledger,Výpis z bankovního účtu zůstatek podle hlavní knihy
DocType: Job Applicant,Applicant Name,Žadatel Název
DocType: Authorization Rule,Customer / Item Name,Zákazník / Název zboží
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","Souhrnný skupina ** položek ** do jiného ** Položka **. To je užitečné, pokud se svazování některé položky ** ** do balíku a budete udržovat zásoby balených ** Položky ** a ne agregát ** položky **. Balíček ** Položka ** bude mít &quot;Je skladem,&quot; jako &quot;Ne&quot; a &quot;Je prodeje Item&quot; jako &quot;Yes&quot;. Například: Pokud prodáváte notebooky a batohy odděleně a mají speciální cenu, pokud zákazník koupí oba, pak Laptop + Backpack bude nový Bundle Product Item. Poznámka: BOM = Kusovník"
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Serial No is mandatory for Item {0},Pořadové číslo je povinná k bodu {0}
DocType: Website Attribute,Attribute,Atribut
DocType: Staffing Plan Detail,Current Count,Aktuální počet
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Please specify from/to range,Uveďte prosím z / do rozmezí
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Opening {0} Invoice created,Otevření {0} Fakturu vytvořena
DocType: Serial No,Under AMC,Podle AMC
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Item valuation rate is recalculated considering landed cost voucher amount,Bod míra ocenění je přepočítána zvažuje přistál nákladů částku poukazu
apps/erpnext/erpnext/config/selling.py,Default settings for selling transactions.,Výchozí nastavení pro prodejní transakce.
DocType: Guardian,Guardian Of ,strážce
DocType: Grading Scale Interval,Threshold,Práh
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Filter Employees By (Optional),Filtrovat zaměstnance podle (volitelné)
DocType: BOM Update Tool,Current BOM,Aktuální BOM
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Balance (Dr - Cr),Bilance (Dr - Cr)
DocType: Pick List,Qty of Finished Goods Item,Množství hotového zboží
apps/erpnext/erpnext/public/js/utils.js,Add Serial No,Přidat Sériové číslo
DocType: Work Order Item,Available Qty at Source Warehouse,Dostupné množství v zdrojovém skladu
apps/erpnext/erpnext/config/support.py,Warranty,Záruka
DocType: Purchase Invoice,Debit Note Issued,Vydání dluhopisu
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, šarže nebo čárového kódu"
DocType: Work Order,Warehouses,Sklady
DocType: Shift Type,Last Sync of Checkin,Poslední synchronizace Checkin
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Add a new address,přidat novou adresu
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,{0} asset cannot be transferred,{0} aktivum nemůže být převedeno
DocType: Hotel Room Pricing,Hotel Room Pricing,Ceny pokojů v hotelu
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py,"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Nelze označit Vyprázdněný záznam pacienta, existují nevyfakturované faktury {0}"
DocType: Subscription,Days Until Due,Dny do splatnosti
apps/erpnext/erpnext/stock/doctype/item/item.js,This Item is a Variant of {0} (Template).,Tato položka je variantou {0} (šablony).
DocType: Workstation,per hour,za hodinu
DocType: Blanket Order,Purchasing,Nákup
DocType: Announcement,Announcement,Oznámení
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Customer LPO,Zákazník LPO
DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",Pro dávkovou studentskou skupinu bude studentská dávka ověřena pro každého studenta ze zápisu do programu.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Warehouse nelze vypustit, neboť existuje zásob, kniha pro tento sklad."
apps/erpnext/erpnext/public/js/setup_wizard.js,Distribution,Distribuce
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 „Vlevo“, protože následující zaměstnanci v současné době hlásí tomuto zaměstnanci:"
DocType: Journal Entry Account,Loan,Půjčka
DocType: Expense Claim Advance,Expense Claim Advance,Nároky na úhradu nákladů
DocType: Lab Test,Report Preference,Předvolba reportu
apps/erpnext/erpnext/config/non_profit.py,Volunteer information.,Informace o dobrovolnictví.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Project Manager,Project Manager
,Quoted Item Comparison,Citoval Položka Porovnání
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Overlap in scoring between {0} and {1},Překrývající bodování mezi {0} a {1}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Dispatch,Odeslání
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Max discount allowed for item: {0} is {1}%,Max sleva povoleno položku: {0} {1}%
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Net Asset value as on,Čistá hodnota aktiv i na
DocType: Crop,Produce,Vyrobit
DocType: Hotel Settings,Default Taxes and Charges,Výchozí Daně a poplatky
DocType: Account,Receivable,Pohledávky
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í povoleno měnit dodavatele, objednávky již existuje"
DocType: Stock Entry,Material Consumption for Manufacture,Spotřeba materiálu pro výrobu
DocType: Item Alternative,Alternative Item Code,Alternativní kód položky
DocType: Appointment Booking Settings,Notify Via Email,Upozornit e-mailem
DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,"Role, která se nechá podat transakcí, které přesahují úvěrové limity."
DocType: Production Plan,Select Items to Manufacture,Vyberte položky do Výroba
DocType: Delivery Stop,Delivery Stop,Zastávka doručení
apps/erpnext/erpnext/accounts/page/pos/pos.js,"Master data syncing, it might take some time","Kmenová data synchronizace, může to trvat nějaký čas"
DocType: Material Request Plan Item,Material Issue,Material Issue
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,Free item not set in the pricing rule {0},Bezplatná položka není nastavena v cenovém pravidle {0}
DocType: Employee Education,Qualification,Kvalifikace
DocType: Item Price,Item Price,Položka Cena
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Soap & Detergent,Soap & Detergent
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Employee {0} does not belongs to the company {1},Zaměstnanec {0} nepatří do společnosti {1}
DocType: BOM,Show Items,Zobrazit položky
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é přiznání {0} za období {1}
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py,From Time cannot be greater than To Time.,Od doby nemůže být větší než na čas.
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: Subscription Plan,Billing Interval,Interval fakturace
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Motion Picture & Video,Motion Picture & Video
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js,Ordered,Objednáno
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Resume,Životopis
DocType: Salary Detail,Component,Komponent
DocType: Video,YouTube,Youtube
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
DocType: Assessment Criteria,Assessment Criteria Group,Hodnotící kritéria Group
DocType: Healthcare Settings,Patient Name By,Jméno pacienta
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 deníku pro platy od {0} do {1}
DocType: Sales Invoice Item,Enable Deferred Revenue,Aktivovat odložené výnosy
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Opening Accumulated Depreciation must be less than equal to {0},Otevření Oprávky musí být menší než rovná {0}
DocType: Appointment Booking Settings,Appointment Details,Podrobnosti schůzky
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Finished Product,Dokončený produkt
DocType: Warehouse,Warehouse Name,Název Skladu
DocType: Naming Series,Select Transaction,Vybrat Transaction
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Zadejte Schvalování role nebo Schvalování Uživatel
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Dohoda o úrovni služeb s typem entity {0} a entitou {1} již existuje.
DocType: Journal Entry,Write Off Entry,Odepsat Vstup
DocType: BOM,Rate Of Materials Based On,Ocenění materiálů na bázi
DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Je-li zapnuto, pole Akademický termín bude povinné v nástroji pro zápis programu."
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 nemateriálních vstupních dodávek"
apps/erpnext/erpnext/regional/report/datev/datev.py,<b>Company</b> is a mandatory filter.,<b>Společnost</b> je povinný filtr.
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Uncheck all,Zrušte všechny
DocType: Purchase Taxes and Charges,On Item Quantity,Množství položky
DocType: POS Profile,Terms and Conditions,Podmínky
DocType: Asset,Booked Fixed Asset,Rezervovaný majetek
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,To Date should be within the Fiscal Year. Assuming To Date = {0},"Chcete-li data by měla být v rámci fiskálního roku. Za předpokladu, že To Date = {0}"
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Zde můžete upravovat svou výšku, váhu, alergie, zdravotní problémy atd"
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Creating Accounts...,Vytváření účtů ...
DocType: Leave Block List,Applies to Company,Platí pro firmy
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Cannot cancel because submitted Stock Entry {0} exists,"Nelze zrušit, protože existuje skladový záznam {0}"
DocType: Loan,Disbursement Date,výplata Datum
DocType: Service Level Agreement,Agreement Details,Podrobnosti dohody
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 zahájení dohody nesmí být větší nebo rovno Datum ukončení.
DocType: BOM Update Tool,Update latest price in all BOMs,Aktualizujte nejnovější cenu všech kusovníků
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Done,Hotový
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Medical Record,Zdravotní záznam
DocType: Vehicle,Vehicle,Vozidlo
DocType: Purchase Invoice,In Words,Slovy
apps/erpnext/erpnext/hr/doctype/leave_ledger_entry/leave_ledger_entry.py,To date needs to be before from date,K dnešnímu dni musí být před datem
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the name of the bank or lending institution before submittting.,Před zasláním zadejte název banky nebo instituce poskytující úvěr.
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py,{0} must be submitted,{0} musí být odesláno
DocType: POS Profile,Item Groups,Položka Skupiny
DocType: Company,Standard Working Hours,Standardní pracovní doba
DocType: Sales Order Item,For Production,Pro Výrobu
DocType: Payment Request,payment_url,payment_url
DocType: Exchange Rate Revaluation Account,Balance In Account Currency,Zůstatek v měně účtu
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please add a Temporary Opening account in Chart of Accounts,Přidejte účet dočasného otevírání do Účtovacího plánu
DocType: Customer,Customer Primary Contact,Primární kontakt zákazníka
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp/Lead %,Opp / Olovo%
DocType: Bank Guarantee,Bank Account Info,Informace o bankovním účtu
DocType: Bank Guarantee,Bank Guarantee Type,Typ bankovní záruky
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() failed for valid IBAN {},BankAccount.validate_iban () selhala pro platný IBAN {}
DocType: Payment Schedule,Invoice Portion,Fakturační část
,Asset Depreciations and Balances,Asset Odpisy a zůstatků
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} transferred from {2} to {3},Množství {0} {1} převedena z {2} na {3}
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ých pracovníků. Přidejte jej do programu Master of Health Practitioner
DocType: Sales Invoice,Get Advances Received,Získat přijaté zálohy
DocType: Email Digest,Add/Remove Recipients,Přidat / Odebrat příjemce
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 tlačítko ""Nastavit jako výchozí"""
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Amount of TDS Deducted,Částka odečtená z TDS
DocType: Production Plan,Include Subcontracted Items,Zahrnout subdodávané položky
apps/erpnext/erpnext/projects/doctype/project/project.py,Join,Připojit
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Shortage Qty,Nedostatek Množství
DocType: Purchase Invoice,Input Service Distributor,Distributor vstupních služeb
apps/erpnext/erpnext/stock/doctype/item/item.py,Item variant {0} exists with same attributes,Bod varianta {0} existuje s stejné atributy
DocType: Loan,Repay from Salary,Splatit z platu
DocType: Exotel Settings,API Token,API Token
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Requesting payment against {0} {1} for amount {2},Požadovala vyplacení proti {0} {1} na částku {2}
DocType: Additional Salary,Salary Slip,Výplatní páska
apps/erpnext/erpnext/support/doctype/issue/issue.py,Allow Resetting Service Level Agreement from Support Settings.,Povolit resetování dohody o úrovni služeb z nastavení podpory.
apps/erpnext/erpnext/projects/doctype/task/task.py,{0} can not be greater than {1},{0} nemůže být větší než {1}
DocType: Lead,Lost Quotation,ztratil Citace
DocType: Pricing Rule,Margin Rate or Amount,Margin sazbou nebo pevnou částkou
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,'To Date' is required,"""Datum DO"" je povinné"
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Actual Qty: Quantity available in the warehouse.,Skutečné množ.: Množství k dispozici ve skladu.
DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generování balení pásky pro obaly mají být dodány. Používá se k oznámit číslo balíku, obsah balení a jeho hmotnost."
DocType: Sales Invoice Item,Sales Order Item,Prodejní objednávky Item
DocType: Salary Slip,Payment Days,Platební dny
DocType: Stock Settings,Convert Item Description to Clean HTML,Převést položku Popis k vyčištění HTML
DocType: Patient,Dormant,Spící
DocType: Payroll Entry,Deduct Tax For Unclaimed Employee Benefits,Odpočítte daň za nevyžádané zaměstnanecké výhody
DocType: Salary Slip,Total Interest Amount,Celková částka úroků
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with child nodes cannot be converted to ledger,Sklady s podřízené uzly nelze převést do hlavní účetní knihy
DocType: BOM,Manage cost of operations,Správa nákladů na provoz
DocType: Accounts Settings,Stale Days,Stale Days
DocType: Travel Itinerary,Arrival Datetime,Čas příjezdu
DocType: Tax Rule,Billing Zipcode,Fakturační PSČ
DocType: Attendance,HR-ATT-.YYYY.-,HR-ATT-.YYYY.-
DocType: Crop,Row Spacing UOM,Rozložení řádků UOM
DocType: Assessment Result Detail,Assessment Result Detail,Posuzování Detail Výsledek
DocType: Employee Education,Employee Education,Vzdělávání zaměstnanců
DocType: Service Day,Workday,Pracovní den
apps/erpnext/erpnext/setup/doctype/terms_and_conditions/terms_and_conditions.py,At least one of the Applicable Modules should be selected,Měl by být vybrán alespoň jeden z příslušných modulů
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate item group found in the item group table,Duplicitní skupinu položek uvedeny v tabulce na položku ve skupině
apps/erpnext/erpnext/config/quality_management.py,Tree of Quality Procedures.,Postupy stromové kvality.
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,"There's no Employee with Salary Structure: {0}. \
			Assign {1} to an Employee to preview Salary Slip","Neexistuje žádný zaměstnanec se strukturou platů: {0}. \ Přiřaďte {1} zaměstnanci, abyste si mohli prohlédnout náhled na plat"
apps/erpnext/erpnext/public/js/controllers/transaction.js,It is needed to fetch Item Details.,"Je třeba, aby přinesla Detaily položky."
DocType: Fertilizer,Fertilizer Name,Jméno hnojiva
DocType: Salary Slip,Net Pay,Net Pay
DocType: Cash Flow Mapping Accounts,Account,Účet
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} has already been received,Pořadové číslo {0} již obdržel
,Requested Items To Be Transferred,Požadované položky mají být převedeny
DocType: Expense Claim,Vehicle Log,jízd
DocType: Sales Invoice,Is Discounted,Je sleva
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on Actual,Akce při překročení akumulovaného měsíčního rozpočtu na skutečné
DocType: Salary Component,Create Separate Payment Entry Against Benefit Claim,Vytvoření odděleného zadání platby proti nároku na dávku
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 nebo trvalá teplota&gt; 38 ° C / 100,4 ° F)"
DocType: Customer,Sales Team Details,Podrobnosti prodejní tým
apps/erpnext/erpnext/accounts/page/pos/pos.js,Delete permanently?,Smazat trvale?
DocType: Expense Claim,Total Claimed Amount,Celkem žalované částky
apps/erpnext/erpnext/config/crm.py,Potential opportunities for selling.,Potenciální příležitosti pro prodej.
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,{} is an invalid Attendance Status.,{} je neplatný stav účasti.
DocType: Shareholder,Folio no.,Číslo folia
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,Invalid {0},Neplatný {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Sick Leave,Zdravotní dovolená
DocType: Email Digest,Email Digest,Email Digest
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 plánované množství surovin je více než požadované množství, není třeba vytvářet požadavky na materiál. Chcete-li přesto požádat o materiál, laskavě zaškrtněte políčko <b>Ignorovat existující předpokládané množství</b>"
DocType: Delivery Note,Billing Address Name,Jméno Fakturační adresy
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Department Stores,Obchodní domy
,Item Delivery Date,Datum dodání položky
DocType: Selling Settings,Sales Update Frequency,Frekvence aktualizace prodeje
DocType: Production Plan,Material Requested,Požadovaný materiál
DocType: Warehouse,PIN,KOLÍK
DocType: Bin,Reserved Qty for sub contract,Vyhrazené množství pro subdodávky
DocType: Patient Service Unit,Patinet Service Unit,Patinet Service Unit
DocType: Sales Invoice,Base Change Amount (Company Currency),Základna Změna Částka (Company měna)
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,No accounting entries for the following warehouses,Žádné účetní záznamy pro následující sklady
apps/erpnext/erpnext/shopping_cart/cart.py,Only {0} in stock for item {1},Pouze {0} skladem pro položku {1}
DocType: Account,Chargeable,Vyměřovací
DocType: Company,Change Abbreviation,Změna zkratky
DocType: Contract,Fulfilment Details,Úplné podrobnosti
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py,Pay {0} {1},Platit {0} {1}
DocType: Employee Onboarding,Activities,Aktivity
DocType: Expense Claim Detail,Expense Date,Datum výdaje
DocType: Item,No of Months,Počet měsíců
DocType: Item,Max Discount (%),Max sleva (%)
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,Credit Days cannot be a negative number,Dny úvěrů nemohou být záporné číslo
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Upload a statement,Nahrajte prohlášení
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Report this item,Nahlásit tuto položku
DocType: Purchase Invoice Item,Service Stop Date,Datum ukončení služby
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Last Order Amount,Částka poslední objednávky
DocType: Cash Flow Mapper,e.g Adjustments for:,např. Úpravy pro:
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} Zachovat vzorek je založen na dávce, zkontrolujte prosím, zda je číslo dávky zadrženo vzorku položky"
DocType: Task,Is Milestone,Je milník
DocType: Certification Application,Yet to appear,Přesto se objeví
DocType: Delivery Stop,Email Sent To,E-mailem odeslaným
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Salary Structure not found for employee {0} and date {1},Struktura platu nebyla nalezena pro zaměstnance {0} a datum {1}
DocType: Job Card Item,Job Card Item,Položka karty Job Card
DocType: Accounts Settings,Allow Cost Center In Entry of Balance Sheet Account,Umožnit nákladovému středisku při zadávání účtu bilance
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge with Existing Account,Sloučit se stávajícím účtem
DocType: Budget,Warn,Varovat
apps/erpnext/erpnext/erpnext_integrations/connectors/woocommerce_connection.py,Stores - {0},Obchody - {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 byly již převedeny pro tuto pracovní objednávku.
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Jakékoli jiné poznámky, pozoruhodné úsilí, které by měly jít v záznamech."
DocType: Bank Account,Company Account,Firemní účet
DocType: Asset Maintenance,Manufacturing User,Výroba Uživatel
DocType: Purchase Invoice,Raw Materials Supplied,Dodává suroviny
DocType: Subscription Plan,Payment Plan,Platebni plan
DocType: Bank Transaction,Series,Série
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/config/accounts.py,Subscription Management,Řízení předplatného
DocType: Appraisal,Appraisal Template,Posouzení Template
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Pin Code,K označení kódu
DocType: Soil Texture,Ternary Plot,Ternary Plot
DocType: Amazon MWS Settings,Check this to enable a scheduled Daily synchronization routine via scheduler,"Zaškrtněte toto, chcete-li zapnout naplánovaný program Denní synchronizace prostřednictvím plánovače"
DocType: Item Group,Item Classification,Položka Klasifikace
apps/erpnext/erpnext/templates/pages/home.html,Publications,Publikace
DocType: Driver,License Number,Číslo licence
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Business Development Manager,Business Development Manager
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Maintenance Visit Účel
DocType: Stock Entry,Stock Entry Type,Typ položky skladu
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Invoice Patient Registration,Fakturační registrace pacienta
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js,General Ledger,Hlavní Účetní Kniha
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,To Fiscal Year,Do fiskálního roku
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js,View Leads,Zobrazit Vodítka
DocType: Program Enrollment Tool,New Program,nový program
DocType: Item Attribute Value,Attribute Value,Hodnota atributu
DocType: POS Closing Voucher Details,Expected Amount,Očekávaná částka
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Multiple,Vytvořit více
,Itemwise Recommended Reorder Level,Itemwise Doporučené Změna pořadí Level
apps/erpnext/erpnext/hr/utils.py,Employee {0} of grade {1} have no default leave policy,Zaměstnanec {0} z platové třídy {1} nemá žádnou výchozí politiku dovolené
DocType: Salary Detail,Salary Detail,plat Detail
DocType: Email Digest,New Purchase Invoice,Nová nákupní faktura
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select {0} first,"Prosím, nejprve vyberte {0}"
apps/erpnext/erpnext/public/js/hub/marketplace.js,Added {0} users,Přidali jsme {0} uživatele
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Less Than Amount,Méně než částka
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řiděleni danému vrstvě podle svých vynaložených nákladů
DocType: Appointment Type,Physician,Lékař
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Batch {0} of Item {1} has expired.,Šarže {0} položky {1} vypršela.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py,Consultations,Konzultace
apps/erpnext/erpnext/manufacturing/report/bom_variance_report/bom_variance_report.py,Finished Good,Hotovo dobrá
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 objeví několikrát na základě Ceníku, Dodavatele / Zákazníka, Měny, Položky, UOM, Množství a Dat."
DocType: Sales Invoice,Commission,Provize
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í objednávce {3}
DocType: Certification Application,Name of Applicant,Jméno žadatele
apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Čas list pro výrobu.
DocType: Quick Stock Balance,Quick Stock Balance,Rychlá bilance zásob
apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,mezisoučet
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.,"Vlastnosti Variantu nelze změnit po transakci akcií. Budete muset vytvořit novou položku, abyste to udělali."
apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA mandát
DocType: Healthcare Practitioner,Charges,Poplatky
DocType: Production Plan,Get Items For Work Order,Získat položky pro pracovní objednávku
DocType: Salary Detail,Default Amount,Výchozí částka
DocType: Lab Test Template,Descriptive,Popisný
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Warehouse not found in the system,Sklad nebyl nalezen v systému
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,This Month's Summary,Tento měsíc je shrnutí
DocType: Quality Inspection Reading,Quality Inspection Reading,Kvalita Kontrola Reading
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py,`Freeze Stocks Older Than` should be smaller than %d days.,`Zmrazit zásoby starší než` by mělo být nižší než %d dnů.
DocType: Tax Rule,Purchase Tax Template,Spotřební daň šablony
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Earliest Age,Nejstarší věk
DocType: Quality Goal,Revision,Revize
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Healthcare Services,Zdravotnické služby
,Project wise Stock Tracking,Sledování zboží dle projektu
DocType: DATEV Settings,Regional,Regionální
apps/erpnext/erpnext/config/healthcare.py,Laboratory,Laboratoř
DocType: UOM Category,UOM Category,Kategorie UOM
DocType: Clinical Procedure Item,Actual Qty (at source/target),Skutečné množství (u zdroje/cíle)
DocType: Item Customer Detail,Ref Code,Ref Code
DocType: Accounts Settings,Address used to determine Tax Category in transactions.,Adresa použitá k určení daňové kategorie v transakcích.
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: HR Settings,Payroll Settings,Nastavení Mzdové
apps/erpnext/erpnext/config/accounts.py,Match non-linked Invoices and Payments.,Zápas Nepropojený fakturách a platbách.
DocType: POS Settings,POS Settings,Nastavení POS
apps/erpnext/erpnext/templates/pages/cart.html,Place Order,Objednat
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.js,Create Invoice,Vytvořit fakturu
DocType: Email Digest,New Purchase Orders,Nové vydané objednávky
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Root cannot have a parent cost center,Root nemůže mít rodič nákladové středisko
DocType: POS Closing Voucher,Expense Details,Podrobnosti výdaje
apps/erpnext/erpnext/public/js/stock_analytics.js,Select Brand...,Select Brand ...
apps/erpnext/erpnext/public/js/setup_wizard.js,Non Profit (beta),Neziskové (beta)
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""",Řádek č. Filtru: {0}: Název pole <b>{1}</b> musí být typu &quot;Link&quot; nebo &quot;Table MultiSelect&quot;
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Accumulated Depreciation as on,Oprávky i na
DocType: Employee Tax Exemption Category,Employee Tax Exemption Category,Kategorie osvobození od zaměstnanců
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Amount should not be less than zero.,Částka by neměla být menší než nula.
DocType: Sales Invoice,C-Form Applicable,C-Form Použitelné
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Operation Time must be greater than 0 for Operation {0},Čas operace musí být větší než 0 pro operaci {0}
DocType: Support Search Source,Post Route String,Přidat řetězec trasy
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Warehouse is mandatory,Sklad je povinné
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to create website,Nepodařilo se vytvořit webové stránky
DocType: Soil Analysis,Mg/K,Mg / K
DocType: UOM Conversion Detail,UOM Conversion Detail,UOM konverze Detail
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Admission and Enrollment,Vstup a zápis
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Retention Stock Entry already created or Sample Quantity not provided,Záznam již vytvořeného záznamu o skladování nebo neposkytnuté množství vzorku
DocType: Program,Program Abbreviation,Program Zkratka
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Voucher (Consolidated),Seskupit podle poukázky (konsolidované)
DocType: HR Settings,Encrypt Salary Slips in Emails,Zašifrujte výplatní pásky do e-mailů
DocType: Question,Multiple Correct Answer,Více správných odpovědí
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 dokladu o koupi na každou položku
DocType: Warranty Claim,Resolved By,Vyřešena
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Discharge,Plán výtoku
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Cheques and Deposits incorrectly cleared,Šeky a Vklady nesprávně vymazány
DocType: Homepage Section Card,Homepage Section Card,Karta sekce domovské stránky
,Amount To Be Billed,Částka k vyúčtování
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: You can not assign itself as parent account,Účet {0}: nelze přiřadit sebe jako nadřazený účet
DocType: Purchase Invoice Item,Price List Rate,Ceník Rate
apps/erpnext/erpnext/utilities/activation.py,Create customer quotes,Vytvořit citace zákazníků
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
DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Zobrazit ""Skladem"" nebo ""Není skladem"" na základě skladem k dispozici v tomto skladu."
apps/erpnext/erpnext/config/manufacturing.py,Bill of Materials (BOM),Bill of Materials (BOM)
DocType: Item,Average time taken by the supplier to deliver,Průměrná doba pořízena dodavatelem dodat
DocType: Travel Itinerary,Check-in Date,Datum příjezdu
DocType: Sample Collection,Collected By,Shromážděno podle
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js,Assessment Result,Hodnocení výsledků
DocType: Hotel Room Package,Hotel Room Package,Hotelový balíček
DocType: Employee Transfer,Employee Transfer,Zaměstnanecký převod
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Hours,Hodiny
apps/erpnext/erpnext/templates/emails/confirm_appointment.html,A new appointment has been created for you with {0},Byla pro vás vytvořena nová schůzka s {0}
DocType: Project,Expected Start Date,Očekávané datum zahájení
DocType: Purchase Invoice,04-Correction in Invoice,04 - oprava faktury
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order already created for all items with BOM,Pracovní zakázka již vytvořena pro všechny položky s kusovníkem
DocType: Bank Account,Party Details,Party Podrobnosti
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant Details Report,Zpráva Variant Podrobnosti
DocType: Setup Progress Action,Setup Progress Action,Pokročilé nastavení
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Price List,Nákupní ceník
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Remove item if charges is not applicable to that item,Odebrat pokud poplatků není pro tuto položku
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Cancel Subscription,Zrušit předplatné
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Please select Maintenance Status as Completed or remove Completion Date,Zvolte Stav údržby jako Dokončené nebo odeberte datum dokončení
DocType: Supplier,Default Payment Terms Template,Výchozí šablony platebních podmínek
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 platební brána měnu
DocType: Payment Entry,Receive,Příjem
DocType: Employee Benefit Application Detail,Earning Component,Zisková složka
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Items and UOMs,Zpracování položek a UOM
apps/erpnext/erpnext/regional/italy/utils.py,Please set either the Tax ID or Fiscal Code on Company '%s',Zadejte prosím daňové identifikační číslo nebo daňový kód společnosti &#39;% s&#39;
apps/erpnext/erpnext/templates/pages/rfq.html,Quotations: ,citace:
DocType: Contract,Partially Fulfilled,Částečně splněno
DocType: Maintenance Visit,Fully Completed,Plně Dokončeno
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,"Special Characters except ""-"", ""#"", ""."", ""/"", ""{"" and ""}"" not allowed in naming series","Zvláštní znaky kromě &quot;-&quot;, &quot;#&quot;, &quot;.&quot;, &quot;/&quot;, &quot;{&quot; A &quot;}&quot; nejsou v názvových řadách povoleny"
DocType: Purchase Invoice Item,Is nil rated or exempted,Není hodnocen nebo osvobozen od daně
DocType: Employee,Educational Qualification,Vzdělávací Kvalifikace
DocType: Workstation,Operating Costs,Provozní náklady
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Currency for {0} must be {1},Měna pro {0} musí být {1}
DocType: Shift Type,Mark attendance based on 'Employee Checkin' for Employees assigned to this shift.,Označte účast na základě „Kontrola zaměstnanců“ u zaměstnanců přiřazených k této změně.
DocType: Asset,Disposal Date,Likvidace Datum
DocType: Service Level,Response and Resoution Time,Doba odezvy a resoution
DocType: Employee Leave Approver,Employee Leave Approver,Zaměstnanec Leave schvalovač
apps/erpnext/erpnext/stock/doctype/item/item.py,Row {0}: An Reorder entry already exists for this warehouse {1},Row {0}: Položka Změna pořadí již pro tento sklad existuje {1}
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.js,Please enter the designation,Zadejte označení
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py,"Cannot declare as lost, because Quotation has been made.","Nelze prohlásit za ztracený, protože citace byla provedena."
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Get Outstanding Documents,Získejte vynikající dokumenty
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Items for Raw Material Request,Položky pro požadavek na suroviny
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,CWIP Account,CWIP účet
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Feedback,Trénink Feedback
apps/erpnext/erpnext/config/accounts.py,Tax Withholding rates to be applied on transactions.,"Sazby daně ze zadržených daní, které se použijí na transakce."
DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Kritéria dodavatele skóre karty
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select Start Date and End Date for Item {0},"Prosím, vyberte Počáteční datum a koncové datum pro položku {0}"
DocType: Maintenance Schedule,MAT-MSH-.YYYY.-,MAT-MSH-.YYYY.-
,Amount to Receive,Částka k přijetí
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Course is mandatory in row {0},Samozřejmě je povinné v řadě {0}
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,From date can not be greater than than To date,Od data nemůže být větší než Do dne
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,To date cannot be before from date,K dnešnímu dni nemůže být dříve od data
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non GST Inward Supplies,Spotřební materiály jiné než GST
DocType: Employee Group Table,Employee Group Table,Tabulka skupiny zaměstnanců
DocType: Packed Item,Prevdoc DocType,Prevdoc DOCTYPE
DocType: Cash Flow Mapper,Section Footer,Zápatí sekce
apps/erpnext/erpnext/stock/doctype/item/item.js,Add / Edit Prices,Přidat / Upravit ceny
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Employee Promotion cannot be submitted before Promotion Date ,Propagace zaměstnanců nelze předložit před datem propagace
DocType: Batch,Parent Batch,Nadřazená dávka
DocType: Cheque Print Template,Cheque Print Template,Šek šablony tisku
DocType: Salary Component,Is Flexible Benefit,Je flexibilní přínos
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Chart of Cost Centers,Diagram nákladových středisek
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 fakturace před zrušením předplatného nebo označením předplatného jako nezaplaceného
DocType: Clinical Procedure Template,Sample Collection,Kolekce vzorků
,Requested Items To Be Ordered,Požadované položky je třeba objednat
DocType: Price List,Price List Name,Ceník Jméno
DocType: Delivery Stop,Dispatch Information,Informace o odeslání
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill JSON can only be generated from submitted document,Účet E-Way Bill JSON lze generovat pouze z předloženého dokumentu
DocType: Blanket Order,Manufacturing,Výroba
,Ordered Items To Be Delivered,"Objednané zboží, které mají být dodány"
DocType: Account,Income,Příjem
DocType: Industry Type,Industry Type,Typ Průmyslu
apps/erpnext/erpnext/templates/includes/cart.js,Something went wrong!,Něco se pokazilo!
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Warning: Leave application contains following block dates,Upozornění: Nechte Aplikace obsahuje následující data bloku
DocType: Bank Statement Settings,Transaction Data Mapping,Mapování dat transakcí
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Sales Invoice {0} has already been submitted,Prodejní faktury {0} již byla odeslána
DocType: Salary Component,Is Tax Applicable,Je daň platná
DocType: Supplier Scorecard Scoring Criteria,Score,Skóre
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} does not exist,Fiskální rok {0} neexistuje
DocType: Asset Maintenance Log,Completion Date,Dokončení Datum
DocType: Purchase Invoice Item,Amount (Company Currency),Částka (Měna Společnosti)
DocType: Program,Is Featured,Je doporučeno
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Fetching...,Okouzlující...
DocType: Agriculture Analysis Criteria,Agriculture User,Zemědělský uživatel
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Valid till date cannot be before transaction date,Platné do data nemůže být před datem transakce
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} zapotřebí {2} o {3} {4} na {5} pro dokončení této transakce.
DocType: Fee Schedule,Student Category,Student Kategorie
DocType: Announcement,Student,Student
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,Postup uskutečnění kvantity skladování není k dispozici ve skladu. Chcete zaznamenat převod akcií
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,New {0} pricing rules are created,Vytvoří se nová {0} pravidla pro tvorbu cen
DocType: Shipping Rule,Shipping Rule Type,Typ pravidla přepravy
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: Company,Budget Detail,Detail Rozpočtu
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Please enter message before sending,"Prosím, zadejte zprávu před odesláním"
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Setting up company,Založení společnosti
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 dodávek uvedených v bodě 3.1 písm. A) výše podrobnosti o státních dodávkách uskutečněných nezapsaným osobám, osobám povinným k dani ve složení a držitelům UIN"
apps/erpnext/erpnext/regional/doctype/gst_hsn_code/gst_hsn_code.js,Item taxes updated,Daň z položek byla aktualizována
DocType: Education Settings,Enable LMS,Povolit LMS
DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUPLIKÁT PRO DODAVATELE
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Please save the report again to rebuild or update,"Sestavu znovu uložte, abyste ji mohli znovu vytvořit nebo aktualizovat"
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot delete item {1} which has already been received,"Řádek # {0}: Nelze odstranit položku {1}, která již byla přijata"
DocType: Service Level Agreement,Response and Resolution Time,Doba odezvy a rozlišení
DocType: Asset,Custodian,Depozitář
apps/erpnext/erpnext/config/retail.py,Point-of-Sale Profile,Point-of-Sale Profil
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/crm/doctype/appointment_booking_settings/appointment_booking_settings.py,<b>From Time</b> cannot be later than <b>To Time</b> for {0},<b>Od času</b> nemůže být později než <b>Do času</b> pro {0}
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Payment of {0} from {1} to {2},Platba {0} od {1} do {2}
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward supplies liable to reverse charge (other than 1 & 2 above),Dočasné dodávky podléhající zpětnému poplatku (jiné než výše uvedené výše 1 a 2)
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount(Company Currency),Částka objednávky (měna společnosti)
DocType: Chart of Accounts Importer,Import Chart of Accounts from a csv file,Importujte graf účtů ze souboru csv
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Unsecured Loans,Nezajištěných úvěrů
DocType: Cost Center,Cost Center Name,Jméno nákladového střediska
DocType: Student,B+,B +
DocType: HR Settings,Max working hours against Timesheet,Maximální pracovní doba proti časového rozvrhu
DocType: Shift Type,Strictly based on Log Type in Employee Checkin,Přísně založené na typu protokolu při kontrole zaměstnanců
DocType: Maintenance Schedule Detail,Scheduled Date,Plánované datum
apps/erpnext/erpnext/projects/doctype/task/task.py,Task's {0} End Date cannot be after Project's End Date.,Datum ukončení {0} úkolu nemůže být po datu ukončení projektu.
DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Zprávy větší než 160 znaků bude rozdělena do více zpráv
DocType: Purchase Receipt Item,Received and Accepted,Obdrženo a přijato
,GST Itemised Sales Register,GST Itemized Sales Register
DocType: Staffing Plan,Staffing Plan Details,Podrobnosti personálního plánu
DocType: Soil Texture,Silt Loam,Silt Loam
,Serial No Service Contract Expiry,Pořadové číslo Servisní smlouva vypršení platnosti
DocType: Employee Health Insurance,Employee Health Insurance,Zdravotní pojištění zaměstnanců
DocType: Appointment Booking Settings,Agent Details,Podrobnosti o agentovi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,You cannot credit and debit same account at the same time,Nemůžete dělat kreditní a debetní záznam na stejný účet ve stejnou dobu.
DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Dospělý puls je v rozmezí od 50 do 80 úderů za minutu.
DocType: Naming Series,Help HTML,Nápověda HTML
DocType: Student Group Creation Tool,Student Group Creation Tool,Student Group Tool Creation
DocType: Item,Variant Based On,Varianta založená na
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Total weightage assigned should be 100%. It is {0},Celková weightage přiřazen by měla být 100%. Je {0}
DocType: Loyalty Point Entry,Loyalty Program Tier,Věrnostní program Tier
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Cannot set as Lost as Sales Order is made.,"Nelze nastavit jako Ztraceno, protože je přijata objednávka."
DocType: Request for Quotation Item,Supplier Part No,Žádný dodavatel Part
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for hold: ,Důvod pozastavení:
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',"Nemůže odečíst, pokud kategorie je pro &quot;ocenění&quot; nebo &quot;Vaulation a Total&quot;"
apps/erpnext/erpnext/public/js/hub/components/reviews.js,Anonymous,Anonymní
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Received From,Přijaté Od
DocType: Lead,Converted,Převedené
DocType: Item,Has Serial No,Má Sériové číslo
DocType: Stock Entry Detail,PO Supplied Item,PO dodaná položka
DocType: BOM,Quality Inspection Required,Vyžaduje se kontrola kvality
DocType: Employee,Date of Issue,Datum vydání
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í, pokud je požadováno nákupní požadavek == &#39;ANO&#39;, pak pro vytvoření nákupní faktury musí uživatel nejprve vytvořit doklad o nákupu pro položku {0}"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Set Supplier for item {1},Řádek # {0}: Nastavte Dodavatel pro položku {1}
DocType: Global Defaults,Default Distance Unit,Výchozí jednotka vzdálenosti
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: Hours value must be greater than zero.,Řádek {0}: doba hodnota musí být větší než nula.
apps/erpnext/erpnext/stock/doctype/item/item.py,Website Image {0} attached to Item {1} cannot be found,Webové stránky Image {0} připojuje k bodu {1} nelze nalézt
DocType: Asset,Assets,Aktiva
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Computer,Počítač
DocType: Item,List this Item in multiple groups on the website.,Seznam tuto položku ve více skupinách na internetových stránkách.
DocType: Subscription,Current Invoice End Date,Aktuální datum ukončení faktury
DocType: Payment Term,Due Date Based On,Datum splatnosti založeno na
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 nastavení prodeje
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} does not exist,{0} {1} neexistuje
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please check Multi Currency option to allow accounts with other currency,"Prosím, zkontrolujte více měn možnost povolit účty s jinou měnu"
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Item: {0} does not exist in the system,Položka: {0} neexistuje v systému
apps/erpnext/erpnext/accounts/doctype/account/account.py,You are not authorized to set Frozen value,Nejste oprávněni stanovit hodnotu Zmražení
DocType: Payment Reconciliation,Get Unreconciled Entries,Získat smířit záznamů
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} is on Leave on {1},Zaměstnanec {0} je zapnut Nechat na {1}
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments selected for Journal Entry,Nebudou vybrány žádné splátky pro deník
DocType: Purchase Invoice,GST Category,Kategorie GST
DocType: Payment Reconciliation,From Invoice Date,Z faktury Datum
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Budgets,Rozpočty
DocType: Invoice Discounting,Disbursed,Vyčerpáno
DocType: Healthcare Settings,Laboratory Settings,Laboratorní nastavení
DocType: Clinical Procedure,Service Unit,Servisní jednotka
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Successfully Set Supplier,Úspěšně nastavit dodavatele
DocType: Leave Encashment,Leave Encashment,Nechat inkasa
apps/erpnext/erpnext/public/js/setup_wizard.js,What does it do?,Co to dělá?
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py,Tasks have been created for managing the {0} disease (on row {1}),Byly vytvořeny úkoly pro správu nemoci {0} (na řádku {1})
DocType: Crop,Byproducts,Vedlejší produkty
apps/erpnext/erpnext/stock/doctype/batch/batch.js,To Warehouse,Do skladu
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,All Student Admissions,Všechny Student Přijímací
,Average Commission Rate,Průměrná cena Komise
DocType: Share Balance,No of Shares,Počet akcií
DocType: Taxable Salary Slab,To Amount,Do výše
apps/erpnext/erpnext/stock/doctype/item/item.py,'Has Serial No' can not be 'Yes' for non-stock item,"""Má sériové číslo"", nemůže být ""Ano"" pro neskladové zboží"
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Status,Vyberte možnost Stav
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance can not be marked for future dates,Účast nemůže být označen pro budoucí data
DocType: Support Search Source,Post Description Key,Tlačítko Popis příspěvku
DocType: Pricing Rule,Pricing Rule Help,Ceny Pravidlo Help
DocType: School House,House Name,Jméno dům
DocType: Fee Schedule,Total Amount per Student,Celková částka na jednoho studenta
DocType: Opportunity,Sales Stage,Prodejní fáze
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Customer PO,Zákaznická PO
DocType: Purchase Taxes and Charges,Account Head,Účet Head
DocType: Company,HRA Component,Součást HRA
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Electrical,Elektrický
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 vaší organizace jako uživatele. Můžete také přidat pozvat zákazníky na portálu tím, že přidáním z Kontaktů"
DocType: Stock Entry,Total Value Difference (Out - In),Celková hodnota Rozdíl (Out - In)
DocType: Employee Checkin,Location / Device ID,Umístění / ID zařízení
DocType: Grant Application,Requested Amount,Požadovaná částka
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Exchange Rate is mandatory,Řádek {0}: Exchange Rate je povinné
DocType: Invoice Discounting,Bank Charges Account,Účet bankovních poplatků
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,User ID not set for Employee {0},User ID není nastavena pro zaměstnance {0}
DocType: Vehicle,Vehicle Value,Hodnota vozidla
DocType: Crop Cycle,Detected Diseases,Zjištěné nemoci
DocType: Stock Entry,Default Source Warehouse,Výchozí zdrojový sklad
DocType: Item,Customer Code,Code zákazníků
DocType: Bank,Data Import Configuration,Konfigurace importu dat
DocType: Asset Maintenance Task,Last Completion Date,Poslední datum dokončení
apps/erpnext/erpnext/accounts/report/inactive_sales_items/inactive_sales_items.js,Days Since Last Order,Počet dnů od poslední objednávky
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To account must be a Balance Sheet account,Debetní Na účet musí být účtu Rozvaha
DocType: Vital Signs,Coated,Povlečené
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 uplynutí životnosti musí být nižší než částka hrubého nákupu
apps/erpnext/erpnext/regional/italy/utils.py,Please set {0} for address {1},Zadejte prosím {0} pro adresu {1}
DocType: GoCardless Settings,GoCardless Settings,Nastavení GoCardless
apps/erpnext/erpnext/controllers/stock_controller.py,Create Quality Inspection for Item {0},Vytvořit kontrolu kvality pro položku {0}
DocType: Leave Block List,Leave Block List Name,Nechte Jméno Block List
apps/erpnext/erpnext/stock/report/stock_and_account_value_comparison/stock_and_account_value_comparison.py,Perpetual inventory required for the company {0} to view this report.,Pro zobrazení této zprávy je pro společnost vyžadován trvalý inventář {0}.
DocType: Certified Consultant,Certification Validity,Platnost certifikátu
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Insurance Start date should be less than Insurance End date,Datum pojištění startu by měla být menší než pojištění koncovým datem
DocType: Support Settings,Service Level Agreements,Dohody o úrovni služeb
DocType: Shopping Cart Settings,Display Settings,Nastavení zobrazení
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Assets,Stock Aktiva
DocType: Restaurant,Active Menu,Aktivní nabídka
DocType: Accounting Dimension Detail,Default Dimension,Výchozí dimenze
DocType: Target Detail,Target Qty,Target Množství
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Against Loan: {0},Proti půjčce: {0}
DocType: Shopping Cart Settings,Checkout Settings,Pokladna Nastavení
DocType: Student Attendance,Present,Současnost
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Delivery Note {0} must not be submitted,Delivery Note {0} nesmí být předloženy
DocType: HR Settings,"The salary slip emailed to the employee will be password protected, the password will be generated based on the password policy.","E-mail s platem zaslaný zaměstnancům bude chráněn heslem, heslo bude vygenerováno na základě hesla."
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 odpovědnosti / Equity
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Slip of employee {0} already created for time sheet {1},Výplatní pásce zaměstnance {0} již vytvořili pro časové list {1}
DocType: Vehicle Log,Odometer,Počítadlo ujetých kilometrů
DocType: Production Plan Item,Ordered Qty,Objednáno Množství
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is disabled,Položka {0} je zakázána
DocType: Stock Settings,Stock Frozen Upto,Reklamní Frozen aľ
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,BOM does not contain any stock item,BOM neobsahuje žádnou skladovou položku
DocType: Chapter,Chapter Head,Hlava kapitoly
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Search for a payment,Vyhledejte platbu
DocType: Payment Term,Month(s) after the end of the invoice month,Měsíc (měsíce) po skončení měsíce faktury
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Salary Structure should have flexible benefit component(s) to dispense benefit amount,Struktura odměňování by měla mít flexibilní složku (výhody) pro vyplácení dávky
apps/erpnext/erpnext/config/projects.py,Project activity / task.,Projektová činnost / úkol.
DocType: Vital Signs,Very Coated,Velmi povrstvená
DocType: Tax Category,Source State,Zdrojový stát
DocType: Salary Component,Only Tax Impact (Cannot Claim But Part of Taxable Income),"Pouze daňový dopad (nelze tvrdit, ale část zdanitelného příjmu)"
apps/erpnext/erpnext/www/book_appointment/index.html,Book Appointment,Kniha schůzky
DocType: Vehicle Log,Refuelling Details,Tankovací Podrobnosti
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab result datetime cannot be before testing datetime,Výsledek datového laboratoře nemůže být před datem testování
DocType: Delivery Trip,Use Google Maps Direction API to optimize route,K optimalizaci trasy použijte rozhraní Google Maps Direction API
DocType: POS Profile,Allow user to edit Discount,Umožnit uživateli upravit slevu
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Get customers from,Získejte zákazníky z
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: Purchase Invoice Item,Include Exploded Items,Zahrnout výbušné položky
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,"Buying must be checked, if Applicable For is selected as {0}","Nákup musí být zkontrolováno, v případě potřeby pro vybrán jako {0}"
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Discount must be less than 100,Sleva musí být menší než 100
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,"Start Time can't be greater than or equal to End Time \
					for {0}.",Čas zahájení nesmí být větší nebo roven času ukončení pro {0}.
DocType: Shipping Rule,Restrict to Countries,Omezte na země
DocType: Shift Type,Alternating entries as IN and OUT during the same shift,Střídavé záznamy jako IN a OUT během stejné směny
DocType: Shopify Settings,Shared secret,Sdílené tajemství
DocType: Amazon MWS Settings,Synch Taxes and Charges,Synchronizace daní a poplatků
apps/erpnext/erpnext/accounts/general_ledger.py,Please create adjustment Journal Entry for amount {0} ,Vytvořte prosím opravný zápis do deníku o částku {0}
DocType: Purchase Invoice,Write Off Amount (Company Currency),Odepsat Částka (Company měny)
DocType: Sales Invoice Timesheet,Billing Hours,Billing Hodiny
DocType: Project,Total Sales Amount (via Sales Order),Celková částka prodeje (prostřednictvím objednávky prodeje)
apps/erpnext/erpnext/controllers/taxes_and_totals.py,Row {0}: Invalid Item Tax Template for item {1},Řádek {0}: Neplatná šablona daně z položky pro položku {1}
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Default BOM for {0} not found,Výchozí BOM pro {0} nebyl nalezen
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ělo být o jeden rok dříve než datum ukončení fiskálního roku
apps/erpnext/erpnext/stock/doctype/item/item.py,Row #{0}: Please set reorder quantity,Řádek # {0}: Prosím nastavte množství objednací
apps/erpnext/erpnext/public/js/pos/pos.html,Tap items to add them here,Klepnutím na položky je můžete přidat zde
DocType: Course Enrollment,Program Enrollment,Registrace do programu
apps/erpnext/erpnext/controllers/item_variant.py,Rename Not Allowed,Přejmenovat není povoleno
DocType: Share Transfer,To Folio No,Do složky Folio č
DocType: Landed Cost Voucher,Landed Cost Voucher,Přistálo Náklady Voucher
apps/erpnext/erpnext/config/accounts.py,Tax Category for overriding tax rates.,Daňová kategorie pro převažující daňové sazby.
apps/erpnext/erpnext/public/js/queries.js,Please set {0},Prosím nastavte {0}
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} je neaktivní student
DocType: Employee,Health Details,Zdravotní Podrobnosti
DocType: Coupon Code,Coupon Type,Typ kupónu
DocType: Leave Encashment,Encashable days,Dny zapamatovatelné
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,"Chcete-li vytvořit referenční dokument žádosti o platbu, je třeba"
DocType: Soil Texture,Sandy Clay,Sandy Clay
DocType: Grant Application,Assessment  Manager,Správce hodnocení
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Allocate Payment Amount,Přidělit částku platby
DocType: Subscription Plan,Subscription Plan,Plán předplatného
DocType: Employee External Work History,Salary,Plat
DocType: Serial No,Delivery Document Type,Dodávka Typ dokumentu
DocType: Sales Order,Partly Delivered,Částečně vyhlášeno
DocType: Item Variant Settings,Do not update variants on save,Neaktualizujte varianty při ukládání
apps/erpnext/erpnext/accounts/report/sales_register/sales_register.py,Custmer Group,Custmer Group
DocType: Email Digest,Receivables,Pohledávky
DocType: Lead Source,Lead Source,Olovo Source
DocType: Customer,Additional information regarding the customer.,Další informace týkající se zákazníka.
DocType: Quality Inspection Reading,Reading 5,Čtení 5
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} je přidružena k {2}, ale účet stran je {3}"
DocType: Bank Statement Settings Item,Bank Header,Záhlaví banky
apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js,View Lab Tests,Zobrazit laboratorní testy
DocType: Hub Users,Hub Users,Uživatelé Hubu
DocType: Purchase Invoice,Y,Y
DocType: Maintenance Visit,Maintenance Date,Datum údržby
DocType: Purchase Invoice Item,Rejected Serial No,Odmítnuté sériové číslo
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,Rok datum zahájení nebo ukončení se překrývá s {0}. Aby se zabránilo nastavte firmu
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Please mention the Lead Name in Lead {0},Uvedete prosím vedoucí jméno ve vedoucím {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ěla být menší než konečné datum pro bod {0}
DocType: Shift Type,Auto Attendance Settings,Nastavení automatické účasti
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 ##### 
 Je-li série nastavuje a pořadové číslo není uvedeno v transakcích, bude vytvořen poté automaticky sériové číslo na základě této série. Pokud chcete vždy výslovně uvést pořadová čísla pro tuto položku. ponechte prázdné."
DocType: Upload Attendance,Upload Attendance,Nahrát Návštěvnost
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,BOM and Manufacturing Quantity are required,BOM a výroba množství jsou povinné
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 2,Stárnutí rozsah 2
DocType: SG Creation Tool Course,Max Strength,Max Síla
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Installing presets,Instalace předvoleb
DocType: Fee Schedule,EDU-FSH-.YYYY.-,EDU-FSH-.YYYY.-
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,No Delivery Note selected for Customer {},Pro zákazníka nebyl vybrán žádný zákazník {}
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Rows Added in {0},Řádky přidané v {0}
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Employee {0} has no maximum benefit amount,Zaměstnanec {0} nemá maximální částku prospěchu
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select Items based on Delivery Date,Vyberte položky podle data doručení
DocType: Grant Application,Has any past Grant Record,Má nějaký minulý grantový záznam
,Sales Analytics,Prodejní Analytics
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Available {0},K dispozici {0}
,Prospects Engaged But Not Converted,"Perspektivy zapojení, ale nekonverze"
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,"{2} <b>{0}</b> has submitted Assets.\
								Remove Item <b>{1}</b> from table to continue.",{2} <b>{0}</b> odeslal aktiva. \ Odebrat položku <b>{1}</b> z tabulky a pokračovat.
DocType: Manufacturing Settings,Manufacturing Settings,Výrobní nastavení
DocType: Quality Feedback Template Parameter,Quality Feedback Template Parameter,Parametr šablony zpětné vazby kvality
apps/erpnext/erpnext/config/settings.py,Setting up Email,Nastavení e-mail
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Mobile No,Guardian1 Mobile Žádné
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please enter default currency in Company Master,Zadejte prosím výchozí měnu v podniku Mistr
DocType: Stock Entry Detail,Stock Entry Detail,Detail pohybu na skladu
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Daily Reminders,Denní Upomínky
apps/erpnext/erpnext/templates/pages/help.html,See all open tickets,Podívejte se na všechny vstupenky
DocType: Brand,Brand Defaults,Výchozí hodnoty značky
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js,Healthcare Service Unit Tree,Strom jednotky zdravotnických služeb
DocType: Pricing Rule,Product,Produkt
DocType: Products Settings,Home Page is Products,Domovskou stránkou je stránka Produkty.
,Asset Depreciation Ledger,Asset Odpisy Ledger
DocType: Salary Structure,Leave Encashment Amount Per Day,Ponechte částku zaplacení za den
DocType: Loyalty Program Collection,For how much spent = 1 Loyalty Point,Kolik stráceno = 1 věrnostní bod
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Rule Conflicts with {0},Daňové Pravidlo Konflikty s {0}
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,New Account Name,Nový název účtu
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Dodává se nákladů na suroviny
DocType: Selling Settings,Settings for Selling Module,Nastavení pro prodej Module
DocType: Hotel Room Reservation,Hotel Room Reservation,Rezervace pokojů v hotelu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Customer Service,Služby zákazníkům
DocType: BOM,Thumbnail,Thumbnail
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,No contacts with email IDs found.,Nebyly nalezeny žádné kontakty s identifikátory e-mailu.
DocType: Item Customer Detail,Item Customer Detail,Položka Detail Zákazník
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/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ž dnů v období
DocType: Linked Soil Analysis,Linked Soil Analysis,Analýza propojené půdy
DocType: Pricing Rule,Percentage,Procento
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 skladem
DocType: Manufacturing Settings,Default Work In Progress Warehouse,Výchozí práci ve skladu Progress
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Plán pro překrytí {0}, chcete pokračovat po přeskočení přesahovaných slotů?"
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js,Grant Leaves,Grantové listy
DocType: Restaurant,Default Tax Template,Výchozí daňová šablona
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,{0} Students have been enrolled,{0} Studenti byli zapsáni
DocType: Fees,Student Details,Podrobnosti studenta
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žívané pro položky a prodejní objednávky. Záložní UOM je „Nos“.
DocType: Purchase Invoice Item,Stock Qty,Množství zásob
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Ctrl+Enter to submit,Ctrl + Enter pro odeslání
DocType: Contract,Requires Fulfilment,Vyžaduje plnění
DocType: QuickBooks Migrator,Default Shipping Account,Výchozí poštovní účet
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please set a Supplier against the Items to be considered in the Purchase Order.,"Nastavte prosím dodavatele na položky, které mají být zohledněny v objednávce."
DocType: Loan,Repayment Period in Months,Splácení doba v měsících
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Error: Not a valid id?,Chyba: Není platný id?
DocType: Naming Series,Update Series Number,Aktualizace Series Number
DocType: Account,Equity,Hodnota majetku
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}: ""výkaz zisků a ztrát"" typ účtu {2} není povolen do Otevírací vstup"
DocType: Job Offer,Printing Details,Tisk detailů
DocType: Task,Closing Date,Uzávěrka Datum
DocType: Sales Order Item,Produced Quantity,Produkoval Množství
DocType: Item Price,Quantity  that must be bought or sold per UOM,"Množství, které musí být zakoupeno nebo prodané podle UOM"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Engineer,Inženýr
DocType: Promotional Scheme Price Discount,Max Amount,Maximální částka
DocType: Journal Entry,Total Amount Currency,Celková částka Měna
DocType: Pricing Rule,Min Amt,Min Amt
DocType: Item,Is Customer Provided Item,Je položka poskytovaná zákazníkem
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Search Sub Assemblies,Vyhledávání Sub Assemblies
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Item Code required at Row No {0},Kód položky třeba na řádku č {0}
DocType: GST Account,SGST Account,Účet SGST
DocType: Sales Partner,Partner Type,Partner Type
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Actual,Aktuální
DocType: Appointment,Skype ID,Skype ID
DocType: Restaurant Menu,Restaurant Manager,Manažer restaurace
DocType: Call Log,Call Log,Telefonní záznam
DocType: Authorization Rule,Customerwise Discount,Sleva podle zákazníka
apps/erpnext/erpnext/config/projects.py,Timesheet for tasks.,Časového rozvrhu pro úkoly.
DocType: Purchase Invoice,Against Expense Account,Proti výdajového účtu
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: BOM,Raw Material Cost (Company Currency),Náklady na suroviny (měna společnosti)
apps/erpnext/erpnext/regional/india/utils.py,House rent paid days overlapping with {0},Nájemné za zaplacené dny se překrývá s {0}
DocType: GSTR 3B Report,October,říjen
DocType: Bank Reconciliation,Get Payment Entries,Získat Platební položky
DocType: Quotation Item,Against Docname,Proti Docname
DocType: SMS Center,All Employee (Active),Všichni zaměstnanci (Aktivní)
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Detailed Reason,Podrobný důvod
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,View Now,Zobrazit nyní
DocType: BOM,Raw Material Cost,Cena surovin
DocType: Woocommerce Settings,Woocommerce Server URL,Woocommerce URL serveru
DocType: Item Reorder,Re-Order Level,Úroveň pro znovuobjednání
DocType: Additional Salary,Deduct Full Tax on Selected Payroll Date,Odečíst plnou daň z vybraného data výplatní listiny
DocType: Shopify Tax Account,Shopify Tax/Shipping Title,Nakupujte daňový / lodní titul
apps/erpnext/erpnext/projects/doctype/project/project.js,Gantt Chart,Pruhový diagram
DocType: Crop Cycle,Cycle Type,Typ cyklu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Part-time,Part-time
DocType: Employee,Applicable Holiday List,Použitelný Seznam Svátků
DocType: Employee,Cheque,Šek
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Synchronize this account,Synchronizujte tento účet
DocType: Training Event,Employee Emails,E-maily zaměstnanců
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Series Updated,Řada Aktualizováno
apps/erpnext/erpnext/accounts/doctype/account/account.py,Report Type is mandatory,Report Type je povinné
DocType: Item,Serial Number Series,Sériové číslo Series
,Sales Partner Transaction Summary,Souhrn transakcí obchodního partnera
apps/erpnext/erpnext/buying/utils.py,Warehouse is mandatory for stock Item {0} in row {1},Sklad je povinný pro skladovou položku {0} na řádku {1}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Retail & Wholesale,Maloobchod a velkoobchod
DocType: Issue,First Responded On,Prvně odpovězeno dne
DocType: Website Item Group,Cross Listing of Item in multiple groups,Cross Výpis zboží v několika skupinách
DocType: Employee Tax Exemption Declaration,Other Incomes,Ostatní příjmy
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í a  Datum ukončení Fiskálního roku jsou již stanoveny ve fiskálním roce {0}
DocType: Projects Settings,Ignore User Time Overlap,Ignorovat překryv uživatelského času
DocType: Accounting Period,Accounting Period,Účetní období
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date updated,Světlá Datum aktualizováno
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split Batch,Split Batch
DocType: Stock Settings,Batch Identification,Identifikace šarže
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Successfully Reconciled,Úspěšně smířeni
DocType: Request for Quotation Supplier,Download PDF,Stáhnout PDF
DocType: Work Order,Planned End Date,Plánované datum ukončení
DocType: Shareholder,Hidden list maintaining the list of contacts linked to Shareholder,Skrytý seznam udržující seznam kontaktů spojených s Akcionářem
DocType: Exchange Rate Revaluation Account,Current Exchange Rate,Aktuální směnný kurz
DocType: Item,"Sales, Purchase, Accounting Defaults","Prodej, Nákup, Účetní výchozí"
DocType: Accounting Dimension Detail,Accounting Dimension Detail,Detail účetní dimenze
apps/erpnext/erpnext/config/non_profit.py,Donor Type information.,Informace o typu dárce.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Leave on {1},{0} v Nechat {1}
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available for use date is required,K dispozici je datum k dispozici pro použití
DocType: Request for Quotation,Supplier Detail,dodavatel Detail
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Error in formula or condition: {0},Chyba ve vzorci nebo stavu: {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Invoiced Amount,Fakturovaná částka
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Criteria weights must add up to 100%,Kritéria váhy musí obsahovat až 100%
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js,Attendance,Účast
apps/erpnext/erpnext/public/js/pos/pos.html,Stock Items,sklade
DocType: Sales Invoice,Update Billed Amount in Sales Order,Aktualizovat fakturovanou částku v objednávce prodeje
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Contact Seller,Kontaktovat prodejce
DocType: BOM,Materials,Materiály
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í zatrženo, seznam bude muset být přidány ke každé oddělení, kde má být použit."
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Posting date and posting time is mandatory,Datum a čas zadání je povinný
apps/erpnext/erpnext/config/accounts.py,Tax template for buying transactions.,Daňové šablona pro nákup transakcí.
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Please login as a Marketplace User to report this item.,"Chcete-li tuto položku nahlásit, přihlaste se jako uživatel Marketplace."
,Sales Partner Commission Summary,Shrnutí provize prodejního partnera
,Item Prices,Ceny Položek
DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,"Ve slovech budou viditelné, jakmile uložíte objednávce."
DocType: Holiday List,Add to Holidays,Přidat do svátků
DocType: Woocommerce Settings,Endpoint,Konečný bod
DocType: Period Closing Voucher,Period Closing Voucher,Období Uzávěrka Voucher
DocType: Patient Encounter,Review Details,Podrobné informace
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shareholder does not belong to this company,Akcionář nepatří k této společnosti
DocType: Dosage Form,Dosage Form,Dávkovací forma
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,Please set up the Campaign Schedule in the Campaign {0},Nastavte prosím v kampani rozvrh kampaně {0}
apps/erpnext/erpnext/config/buying.py,Price List master.,Ceník master.
DocType: Task,Review Date,Review Datum
apps/erpnext/erpnext/hr/doctype/attendance/attendance_list.js,Mark attendance as <b></b>,Označit účast jako <b></b>
DocType: BOM,Allow Alternative Item,Povolit alternativní položku
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Purchase Receipt doesn't have any Item for which Retain Sample is enabled.,"Potvrzení o nákupu neobsahuje žádnou položku, pro kterou je povolen Retain Sample."
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Invoice Grand Total,Faktura celkem celkem
DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Série pro odepisování aktiv (Entry Entry)
DocType: Membership,Member Since,Členem od
DocType: Purchase Invoice,Advance Payments,Zálohové platby
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Time logs are required for job card {0},Pro pracovní kartu jsou vyžadovány časové protokoly {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Healthcare Service,Vyberte prosím službu zdravotní péče
DocType: Purchase Taxes and Charges,On Net Total,On Net Celkem
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 atributu {0} musí být v rozmezí od {1} až {2} v krocích po {3} pro item {4}
DocType: Pricing Rule,Product Discount Scheme,Schéma slevy produktu
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,No issue has been raised by the caller.,Volající nenastolil žádný problém.
DocType: Restaurant Reservation,Waitlisted,Vyčkejte
DocType: Employee Tax Exemption Declaration Category,Exemption Category,Kategorie výjimek
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ěn po provedení položky pomocí jiné měně
DocType: Shipping Rule,Fixed,Pevný
DocType: Vehicle Service,Clutch Plate,Kotouč spojky
DocType: Tally Migration,Round Off Account,Zaokrouhlovací účet
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Administrative Expenses,Administrativní náklady
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consulting,Consulting
DocType: Subscription Plan,Based on price list,Na základě ceníku
DocType: Customer Group,Parent Customer Group,Parent Customer Group
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill JSON can only be generated from Sales Invoice,Účet E-Way JSON lze generovat pouze z prodejní faktury
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Maximum attempts for this quiz reached!,Bylo dosaženo maximálních pokusů o tento kvíz!
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Subscription,Předplatné
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Pending,Vytváření poplatků čeká
DocType: Project Template Task,Duration (Days),Trvání (dny)
DocType: Appraisal Goal,Score Earned,Skóre Zasloužené
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Notice Period,Výpovědní Lhůta
DocType: Asset Category,Asset Category Name,Asset název kategorie
apps/erpnext/erpnext/setup/doctype/territory/territory.js,This is a root territory and cannot be edited.,To je kořen území a nelze upravovat.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js,New Sales Person Name,Jméno Nová Sales Osoba
DocType: Packing Slip,Gross Weight UOM,Hrubá Hmotnost UOM
DocType: Employee Transfer,Create New Employee Id,Vytvořit nové číslo zaměstnance
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Set Details,Nastavte podrobnosti
apps/erpnext/erpnext/templates/pages/home.html,By {0},Do {0}
DocType: Travel Itinerary,Travel From,Cestování z
DocType: Asset Maintenance Task,Preventive Maintenance,Preventivní údržba
DocType: Delivery Note Item,Against Sales Invoice,Proti prodejní faktuře
DocType: Purchase Invoice,07-Others,07-Ostatní
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: Bin,Reserved Qty for Production,Vyhrazeno Množství pro výrobu
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,"Ponechte nekontrolované, pokud nechcete dávat pozor na dávku při sestavování kurzových skupin."
DocType: Asset,Frequency of Depreciation (Months),Frekvence odpisy (měsíce)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Credit Account,Úvěrový účet
DocType: Landed Cost Item,Landed Cost Item,Přistálo nákladovou položkou
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js,Show zero values,Ukázat nulové hodnoty
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ých množství surovin
DocType: Lab Test,Test Group,Testovací skupina
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,"Issuing cannot be done to a location. \
						Please enter employee who has issued Asset {0}","Vydání nelze provést na místo. \ Zadejte zaměstnance, který vydal aktivum {0}"
DocType: Service Level Agreement,Entity,Entity
DocType: Payment Reconciliation,Receivable / Payable Account,Pohledávky / závazky účet
DocType: Delivery Note Item,Against Sales Order Item,Proti položce přijaté objednávky
DocType: Company,Company Logo,Logo společnosti
DocType: QuickBooks Migrator,Default Warehouse,Výchozí sklad
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Budget cannot be assigned against Group Account {0},Rozpočet nemůže být přiřazena na skupinový účet {0}
DocType: Shopping Cart Settings,Show Price,Zobrazit cenu
DocType: Healthcare Settings,Patient Registration,Registrace pacienta
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Please enter parent cost center,"Prosím, zadejte nákladové středisko mateřský"
DocType: Delivery Note,Print Without Amount,Tisknout bez Částka
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py,Depreciation Date,odpisy Datum
,Work Orders in Progress,Pracovní příkazy v procesu
DocType: Issue,Support Team,Tým podpory
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expiry (In Days),Doba použitelnosti (ve dnech)
DocType: Appraisal,Total Score (Out of 5),Celkové skóre (Out of 5)
DocType: Student Attendance Tool,Batch,Šarže
DocType: Support Search Source,Query Route String,Dotaz řetězce trasy
DocType: Tally Migration,Day Book Data,Údaje o denní knize
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update rate as per last purchase,Míra aktualizace podle posledního nákupu
DocType: Donor,Donor Type,Typ dárce
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Auto repeat document updated,Dokument byl aktualizován automaticky
apps/erpnext/erpnext/stock/doctype/item/item.js,Balance,Zůstatek
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please select the Company,Vyberte prosím společnost
DocType: Employee Checkin,Skip Auto Attendance,Přeskočit automatickou účast
DocType: BOM,Job Card,Pracovní karta
DocType: Room,Seating Capacity,Počet míst k sezení
DocType: Issue,ISS-,ISS-
DocType: Item,Is Non GST,Není GST
DocType: Lab Test Groups,Lab Test Groups,Laboratorní testovací skupiny
apps/erpnext/erpnext/config/accounts.py,Profitability,Ziskovost
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,Party Type and Party is mandatory for {0} account,Typ strany a strana je povinný pro účet {0}
DocType: Project,Total Expense Claim (via Expense Claims),Total Expense Claim (via Expense nároků)
DocType: GST Settings,GST Summary,Souhrn GST
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í shrnutí skupiny práce povolte výchozí příchozí účet
DocType: Assessment Result,Total Score,Celkové skóre
DocType: Crop Cycle,ISO 8601 standard,Norma ISO 8601
DocType: Journal Entry,Debit Note,Debit Note
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,You can only redeem max {0} points in this order.,V tomto pořadí můžete uplatnit max. {0} body.
DocType: Expense Claim,HR-EXP-.YYYY.-,HR-EXP-.RRRR.-
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Secret,Zadejte zákaznické tajemství API
DocType: Stock Entry,As per Stock UOM,Podle Stock nerozpuštěných
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js,Not Expired,Neuplynula
DocType: Student Log,Achievement,Úspěch
DocType: Asset,Insurer,Pojišťovatel
DocType: Batch,Source Document Type,Zdrojový typ dokumentu
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Following course schedules were created,Byly vytvořeny následující kurzy
DocType: Employee Onboarding,Employee Onboarding,Zaměstnanec na palubě
DocType: Journal Entry,Total Debit,Celkem Debit
DocType: Travel Request Costing,Sponsored Amount,Sponzorovaná částka
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Výchozí sklad hotových výrobků
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Please select Patient,Vyberte pacienta
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Sales Person,Prodej Osoba
DocType: Hotel Room Package,Amenities,Vybavení
DocType: Accounts Settings,Automatically Fetch Payment Terms,Automaticky načíst platební podmínky
DocType: QuickBooks Migrator,Undeposited Funds Account,Účet neukladaných prostředků
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Vícenásobný výchozí způsob platby není povolen
DocType: Sales Invoice,Loyalty Points Redemption,Věrnostní body Vykoupení
,Appointment Analytics,Aplikace Analytics
DocType: Lead,Blog Subscriber,Blog Subscriber
DocType: Guardian,Alternate Number,Alternativní Number
DocType: Assessment Plan Criteria,Maximum Score,Maximální skóre
apps/erpnext/erpnext/config/settings.py,Create rules to restrict transactions based on values.,Vytvoření pravidla pro omezení transakce na základě hodnot.
DocType: Cash Flow Mapping Accounts,Cash Flow Mapping Accounts,Účty mapování peněžních toků
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py, Group Roll No,Skup
DocType: Quality Goal,Revision and Revised On,Revize a revize dne
DocType: Batch,Manufacturing Date,Datum výroby
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Failed,Vytvoření poplatku se nezdařilo
DocType: Opening Invoice Creation Tool,Create Missing Party,Vytvořit chybějící stranu
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Celkový rozpočet
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Nechte prázdné, pokud rodíte studentské skupiny ročně"
DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Pokud je zaškrtnuto, Total no. pracovních dnů bude zahrnovat dovolenou, a to sníží hodnotu platu za každý den"
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Nepodařilo se přidat doménu
apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Chcete-li povolit příjem / doručení, aktualizujte položku „Příjem / příjem“ v Nastavení skladu nebo v položce."
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 s použitím aktuálního klíče nebudou mít přístup, jste si jisti?"
DocType: Subscription Settings,Prorate,Prorate
DocType: Purchase Invoice,Total Advance,Total Advance
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Template Code,Změnit kód šablony
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.,Termínovaný Datum ukončení nesmí být starší než Počáteční datum doby platnosti. Opravte data a zkuste to znovu.
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot Count,Počet kvotů
DocType: Bank Statement Transaction Entry,Bank Statement,Výpis z bankovního účtu
DocType: Employee Benefit Claim,Max Amount Eligible,Maximální částka je způsobilá
,BOM Stock Report,BOM Sklad Zpráva
DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Pokud není přiřazen žádný časový interval, bude komunikace probíhat touto skupinou"
DocType: Stock Reconciliation Item,Quantity Difference,množství Rozdíl
DocType: Opportunity Item,Basic Rate,Basic Rate
DocType: GL Entry,Credit Amount,Výše úvěru
,Electronic Invoice Register,Elektronický fakturační registr
DocType: Cheque Print Template,Signatory Position,Signatář Position
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Set as Lost,Nastavit jako Lost
DocType: Timesheet,Total Billable Hours,Celkem zúčtovatelné hodiny
DocType: Subscription,Number of days that the subscriber has to pay invoices generated by this subscription,"Počet dní, které musí účastník platit faktury generované tímto odběrem"
apps/erpnext/erpnext/projects/doctype/project/project.py,Use a name that is different from previous project name,"Použijte název, který se liší od předchozího názvu projektu"
DocType: Employee Benefit Application Detail,Employee Benefit Application Detail,Podrobnosti o žádostech o zaměstnanecké výhody
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Payment Receipt Note,Doklad o zaplacení Note
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,This is based on transactions against this Customer. See timeline below for details,Přehled aktivity zákazníka.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Create Material Request,Vytvořit požadavek na materiál
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}","Počáteční a koncová data, která nejsou v platném výplatním období, nelze vypočítat {0}"
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 menší než nebo se rovná částce zaplacení výstavního {2}
DocType: Program Enrollment Tool,New Academic Term,Nový akademický termín
,Course wise Assessment Report,Průběžná hodnotící zpráva
DocType: Customer Feedback Template,Customer Feedback Template,Šablona zpětné vazby od zákazníka
DocType: Purchase Invoice,Availed ITC State/UT Tax,Využil daň z ITC státu / UT
DocType: Tax Rule,Tax Rule,Daňové Pravidlo
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Udržovat stejná sazba po celou dobu prodejního cyklu
apps/erpnext/erpnext/hub_node/api.py,Please login as another user to register on Marketplace,"Přihlaste se jako další uživatel, který se zaregistruje na trhu"
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Naplánujte čas protokoly mimo Workstation pracovních hodin.
apps/erpnext/erpnext/public/js/pos/pos.html,Customers in Queue,Zákazníci ve frontě
DocType: Driver,Issuing Date,Datum vydání
DocType: Procedure Prescription,Appointment Booked,Schůzka byla rezervována
DocType: Student,Nationality,Národnost
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure,Konfigurovat
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Submit this Work Order for further processing.,Předložit tuto pracovní objednávku k dalšímu zpracování.
,Items To Be Requested,Položky se budou vyžadovat
DocType: Company,Allow Account Creation Against Child Company,Povolit vytvoření účtu proti dětské společnosti
DocType: Company,Company Info,Společnost info
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select or add new customer,Vyberte nebo přidání nového zákazníka
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Cost center is required to book an expense claim,Nákladové středisko je nutné rezervovat výdajů nárok
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/hr/doctype/employee/employee_dashboard.py,This is based on the attendance of this Employee,To je založeno na účasti základu tohoto zaměstnance
DocType: Payment Request,Payment Request Type,Typ žádosti o platbu
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Mark Attendance,Označit účast
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Debit Account,Debetní účet
DocType: Fiscal Year,Year Start Date,Datum Zahájení Roku
DocType: Additional Salary,Employee Name,Jméno zaměstnance
DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Položka objednávky restaurace
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,{0} bank transaction(s) created and {1} errors,Bylo vytvořeno {0} bankovních transakcí a {1} chyb
DocType: Purchase Invoice,Rounded Total (Company Currency),Celkem zaokrouhleno (měna solečnosti)
apps/erpnext/erpnext/accounts/doctype/account/account.py,Cannot covert to Group because Account Type is selected.,"Nelze skryté do skupiny, protože je požadovaný typ účtu."
DocType: Quiz,Max Attempts,Max Pokusy
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} has been modified. Please refresh.,{0} {1} byl změněn. Prosím aktualizujte.
DocType: Leave Block List,Stop users from making Leave Applications on following days.,Přestaňte uživatelům provádět Nechat aplikací v následujících dnech.
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.",Při neomezeném uplynutí platnosti věrnostních bodů nechte dobu trvání platnosti prázdné nebo 0.
DocType: Asset Maintenance Team,Maintenance Team Members,Členové týmu údržby
DocType: Coupon Code,Validity and Usage,Platnost a použití
DocType: Loyalty Point Entry,Purchase Amount,Částka nákupu
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 doručit pořadové číslo {0} položky {1}, protože je rezervováno \ k plnění objednávky prodeje {2}"
DocType: Quotation,SAL-QTN-.YYYY.-,SAL-QTN-.YYYY.-
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Supplier Quotation {0} created,Dodavatel Cen {0} vytvořil
apps/erpnext/erpnext/accounts/report/financial_statements.py,End Year cannot be before Start Year,Konec roku nemůže být před uvedením do provozu roku
DocType: Employee Benefit Application,Employee Benefits,Zaměstnanecké benefity
apps/erpnext/erpnext/projects/report/billing_summary.py,Employee ID,ID zaměstnance
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Packed quantity must equal quantity for Item {0} in row {1},Balíčky množství se musí rovnat množství pro položku {0} v řadě {1}
DocType: Work Order,Manufactured Qty,Vyrobeno Množství
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shares don't exist with the {0},Akcie neexistují s {0}
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Select Difference Account,Vyberte rozdílový účet
DocType: Sales Partner Type,Sales Partner Type,Typ obchodního partnera
DocType: Purchase Order,Set Reserve Warehouse,Nastavit rezervní sklad
DocType: Shopify Webhook Detail,Webhook ID,Webhook ID
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Invoice Created,Faktura byla vytvořena
DocType: Asset,Out of Order,Mimo provoz
DocType: Purchase Receipt Item,Accepted Quantity,Schválené Množství
DocType: Projects Settings,Ignore Workstation Time Overlap,Ignorovat překrytí pracovní stanice
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please set a default Holiday List for Employee {0} or Company {1},Prosím nastavit výchozí Holiday List pro zaměstnance {0} nebo {1} Company
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html,Timing,Načasování
apps/erpnext/erpnext/accounts/party.py,{0}: {1} does not exists,{0}: {1} neexistuje
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch Numbers,Zvolte čísla šarží
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To GSTIN,Na GSTIN
apps/erpnext/erpnext/config/accounts.py,Bills raised to Customers.,Směnky vznesené zákazníkům.
DocType: Healthcare Settings,Invoice Appointments Automatically,Fakturační schůzky automaticky
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Id,ID projektu
DocType: Salary Component,Variable Based On Taxable Salary,Proměnná založená na zdanitelném platu
DocType: Company,Basic Component,Základní součást
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ž Čekající Částka proti Expense nároku {1}. Do doby, než množství je {2}"
DocType: Patient Service Unit,Medical Administrator,Lékařský administrátor
DocType: Assessment Plan,Schedule,Plán
DocType: Account,Parent Account,Nadřazený účet
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,Salary Structure Assignment for Employee already exists,Přiřazení struktury platu pro zaměstnance již existuje
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Available,K dispozici
DocType: Quality Inspection Reading,Reading 3,Čtení 3
DocType: Stock Entry,Source Warehouse Address,Adresa zdrojového skladu
DocType: GL Entry,Voucher Type,Voucher Type
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Future Payments,Budoucí platby
DocType: Amazon MWS Settings,Max Retry Limit,Maximální limit opakování
apps/erpnext/erpnext/accounts/page/pos/pos.js,Price List not found or disabled,Ceník nebyl nalezen nebo zakázán
DocType: Content Activity,Last Activity ,poslední aktivita
DocType: Student Applicant,Approved,Schválený
DocType: Pricing Rule,Price,Cena
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Employee relieved on {0} must be set as 'Left',"Zaměstnanec úlevu na {0} musí být nastaven jako ""Left"""
DocType: Guardian,Guardian,poručník
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 tímto se přesouvají do nového vydání
DocType: Salary Detail,Tax on additional salary,Daň z příplatku
DocType: Item Alternative,Item Alternative,Položka Alternativa
DocType: Healthcare Settings,Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,"Standardní účty příjmů, které se použijí, pokud nejsou stanoveny ve zdravotnickém lékaři ke vyúčtování poplatků za schůzku."
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Total contribution percentage should be equal to 100,Celkové procento příspěvku by se mělo rovnat 100
DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Vytvořte chybějícího zákazníka nebo dodavatele.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Appraisal {0} created for Employee {1} in the given date range,Posouzení {0} vytvořil pro zaměstnance {1} v daném časovém období
DocType: Academic Term,Education,Vzdělání
DocType: Payroll Entry,Salary Slips Created,Vytvořeny platební karty
DocType: Inpatient Record,Expected Discharge,Předpokládané uvolnění
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Del,Del
DocType: Selling Settings,Campaign Naming By,Kampaň Pojmenování By
DocType: Employee,Current Address Is,Aktuální adresa je
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html,modified,Upravené
DocType: Travel Request,Identification Document Number,identifikační číslo dokumentu
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Optional. Sets company's default currency, if not specified.","Volitelné. Nastaví výchozí měně společnosti, není-li uvedeno."
DocType: Sales Invoice,Customer GSTIN,Zákazník GSTIN
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 onemocnění zjištěných v terénu. Když je vybráno, automaticky přidá seznam úkolů, které se mají vypořádat s tímto onemocněním"
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,BOM 1,Kus 1
apps/erpnext/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py,Asset Id,ID majetku
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 základní službu zdravotnické služby a nelze ji editovat.
DocType: Asset Repair,Repair Status,Stav opravy
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žádalo o koupi, ale nenařídil."
,Subcontracted Item To Be Received,Subdodávaná položka k přijetí
apps/erpnext/erpnext/public/js/event.js,Add Sales Partners,Přidat obchodní partnery
apps/erpnext/erpnext/config/accounts.py,Accounting journal entries.,Zápisy v účetním deníku.
DocType: Travel Request,Travel Request,Žádost o cestování
DocType: Payment Reconciliation,System will fetch all the entries if limit value is zero.,"Systém načte všechny záznamy, pokud je limitní hodnota nula."
DocType: Delivery Note Item,Available Qty at From Warehouse,K dispozici Množství na Od Warehouse
apps/erpnext/erpnext/hr/doctype/department_approver/department_approver.py,Please select Employee Record first.,"Prosím, vyberte zaměstnance záznam první."
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as it is a Holiday.,"Ústřednost nebyla předložena za {0}, protože je prázdnina."
DocType: POS Profile,Account for Change Amount,Účet pro změnu Částka
DocType: QuickBooks Migrator,Connecting to QuickBooks,Připojení ke službě QuickBooks
DocType: Exchange Rate Revaluation,Total Gain/Loss,Celkový zisk / ztráta
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Pick List,Vytvořit výběrový seznam
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}: Party / Account neshoduje s {1} / {2} do {3} {4}
DocType: Employee Promotion,Employee Promotion,Propagace zaměstnanců
DocType: Maintenance Team Member,Maintenance Team Member,Člen týmu údržby
DocType: Agriculture Analysis Criteria,Soil Analysis,Analýza půd
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Course Code: ,Kód předmětu:
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please enter Expense Account,"Prosím, zadejte výdajového účtu"
DocType: Quality Action Resolution,Problem,Problém
DocType: Account,Stock,Sklad
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}: Reference Document Type musí být jedním z objednávky, faktury nebo Journal Entry"
DocType: Employee,Current Address,Aktuální adresa
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","Je-li položka je varianta další položku pak popis, obraz, oceňování, daní atd bude stanoven ze šablony, pokud není výslovně uvedeno"
DocType: Production Plan Item,Make Work Order for Sub Assembly Items,Vytvořte pracovní objednávku pro položky podsestavy
DocType: Serial No,Purchase / Manufacture Details,Nákup / Výroba Podrobnosti
DocType: Assessment Group,Assessment Group,Skupina Assessment
DocType: Stock Entry,Per Transferred,Za převedené
apps/erpnext/erpnext/config/help.py,Batch Inventory,Batch Zásoby
DocType: Sales Invoice,GST Transporter ID,GST Transporter ID
DocType: Procedure Prescription,Procedure Name,Název postupu
DocType: Employee,Contract End Date,Smlouva Datum ukončení
DocType: Amazon MWS Settings,Seller ID,ID prodávajícího
DocType: Sales Order,Track this Sales Order against any Project,Sledovat tento prodejní objednávky na jakýkoli projekt
DocType: Bank Statement Transaction Entry,Bank Statement Transaction Entry,Příkaz transakce bankovního výpisu
DocType: Sales Invoice Item,Discount and Margin,Sleva a Margin
DocType: Lab Test,Prescription,Předpis
DocType: Import Supplier Invoice,Upload XML Invoices,Nahrajte faktury XML
DocType: Company,Default Deferred Revenue Account,Výchozí účet odloženého výnosu
DocType: Project,Second Email,Druhý e-mail
DocType: Budget,Action if Annual Budget Exceeded on Actual,"Akce, pokud je roční rozpočet překročen na skutečné"
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Not Available,Není k dispozici
DocType: Pricing Rule,Min Qty,Min Množství
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Disable Template,Zakázat šablonu
DocType: Bank Statement Transaction Invoice Item,Transaction Date,Transakce Datum
DocType: Production Plan Item,Planned Qty,Plánované Množství
DocType: Project Template Task,Begin On (Days),Zahájit (dny)
DocType: Quality Action,Preventive,Preventivní
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to Unregistered Persons,Dodávky poskytované neregistrovaným osobám
DocType: Company,Date of Incorporation,Datum začlenění
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Total Tax,Total Tax
DocType: Manufacturing Settings,Default Scrap Warehouse,Výchozí sklad šrotu
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Last Purchase Price,Poslední kupní cena
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For Quantity (Manufactured Qty) is mandatory,Pro Množství (Vyrobeno ks) je povinné
DocType: Stock Entry,Default Target Warehouse,Výchozí cílový sklad
DocType: Purchase Invoice,Net Total (Company Currency),Net Total (Company Měna)
DocType: Sales Invoice,Air,Vzduch
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.,Rok Datum ukončení nesmí být starší než datum Rok Start. Opravte data a zkuste to znovu.
DocType: Purchase Order,Set Target Warehouse,Nastavit cílový sklad
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} is not in Optional Holiday List,{0} není v seznamu volitelných prázdnin
DocType: Amazon MWS Settings,JP,JP
DocType: BOM,Scrap Items,šrot položky
DocType: Work Order,Actual Start Date,Skutečné datum zahájení
DocType: Sales Order,% of materials delivered against this Sales Order,% materiálů doručeno proti této prodejní objednávce
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í přiřazení struktury mezd pro následující zaměstnance, protože záznamy o přiřazení struktury mezd již proti nim existují. {0}"
apps/erpnext/erpnext/config/manufacturing.py,Generate Material Requests (MRP) and Work Orders.,Generování žádostí o materiál (MRP) a pracovních příkazů.
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Set default mode of payment,Nastavte výchozí způsob platby
DocType: Stock Entry Detail,Against Stock Entry,Proti zadávání zásob
DocType: Grant Application,Withdrawn,uzavřený
DocType: Support Search Source,Support Search Source,Podporovaný vyhledávací zdroj
apps/erpnext/erpnext/accounts/report/account_balance/account_balance.js,Chargeble,Chargeble
DocType: Project,Gross Margin %,Hrubá Marže %
DocType: BOM,With Operations,S operacemi
DocType: Support Search Source,Post Route Key List,Přidat seznam klíčových cest
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}.,"Položky účetnictví již byly provedeny v měně, {0} pro firmu {1}. Vyberte pohledávky a závazku účet s měnou {0}."
DocType: Asset,Is Existing Asset,Je existujícímu aktivu
DocType: Salary Component,Statistical Component,Statistická složka
DocType: Warranty Claim,If different than customer address,Pokud se liší od adresy zákazníka
DocType: Purchase Invoice,Without Payment of Tax,Bez placení daně
DocType: BOM Operation,BOM Operation,BOM Operation
DocType: Purchase Taxes and Charges,On Previous Row Amount,Na předchozí řady Částka
DocType: Options,Is Correct,Je správně
DocType: Item,Has Expiry Date,Má datum vypršení platnosti
apps/erpnext/erpnext/config/support.py,Issue Type.,Typ problému.
DocType: POS Profile,POS Profile,POS Profile
DocType: Training Event,Event Name,Název události
DocType: Healthcare Practitioner,Phone (Office),Telefon (kancelář)
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,"Cannot Submit, Employees left to mark attendance","Nelze odeslat, Zaměstnanci odešli, aby označili účast"
DocType: Inpatient Record,Admission,Přijetí
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Admissions for {0},Přijímací řízení pro {0}
DocType: Shift Type,Last Known Successful Sync of Employee Checkin. Reset this only if you are sure that all Logs are synced from all the locations. Please don't modify this if you are unsure.,"Poslední známá úspěšná synchronizace kontroly zaměstnanců. Obnovte to, pouze pokud jste si jisti, že všechny protokoly jsou synchronizovány ze všech umístění. Pokud si nejste jisti, neupravujte to."
apps/erpnext/erpnext/config/accounts.py,"Seasonality for setting budgets, targets etc.","Sezónnost pro nastavení rozpočtů, cíle atd."
apps/erpnext/erpnext/www/all-products/index.html,No values,Žádné hodnoty
DocType: Supplier Scorecard Scoring Variable,Variable Name,Název proměnné
apps/erpnext/erpnext/stock/get_item_details.py,"Item {0} is a template, please select one of its variants","Položka {0} je šablona, prosím vyberte jednu z jeho variant"
DocType: Purchase Invoice Item,Deferred Expense,Odložený výdaj
apps/erpnext/erpnext/public/js/hub/pages/Messages.vue,Back to Messages,Zpět na Zprávy
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 datem vstupu do pracovního poměru {1}
DocType: Purchase Invoice Item,Asset Category,Asset Kategorie
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Net pay cannot be negative,Net plat nemůže být záporný
DocType: Purchase Order,Advance Paid,Vyplacené zálohy
DocType: Manufacturing Settings,Overproduction Percentage For Sales Order,Procento nadvýroby pro objednávku prodeje
DocType: Item Group,Item Tax,Daň Položky
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material to Supplier,Materiál Dodavateli
DocType: Soil Texture,Loamy Sand,Loamy Sand
,Lost Opportunity,Ztracená příležitost
DocType: Accounts Settings,Determine Address Tax Category From,Určete kategorii daně z adresy od
DocType: Production Plan,Material Request Planning,Plánování požadavků na materiál
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Excise Invoice,Spotřební Faktura
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Treshold {0}% appears more than once,Práh {0}% objeví více než jednou
DocType: Expense Claim,Employees Email Id,Zaměstnanci Email Id
DocType: Employee Attendance Tool,Marked Attendance,Výrazná Návštěvnost
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Current Liabilities,Krátkodobé závazky
apps/erpnext/erpnext/public/js/projects/timer.js,Timer exceeded the given hours.,Časovač překročil danou dobu.
apps/erpnext/erpnext/config/crm.py,Send mass SMS to your contacts,Posílat hromadné SMS vašim kontaktům
DocType: Inpatient Record,A Positive,Pozitivní
DocType: Program,Program Name,Název programu
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Zvažte daň či poplatek za
DocType: Driver,Driving License Category,Kategorie řidičských oprávnění
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Actual Qty is mandatory,Skutečné Množství je povinné
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} v současné době disponuje {1} hodnotící tabulkou dodavatelů a objednávky na nákup tohoto dodavatele by měly být vydány s opatrností.
DocType: Asset Maintenance Team,Asset Maintenance Team,Tým pro údržbu aktiv
apps/erpnext/erpnext/setup/default_success_action.py,{0} has been submitted successfully,{0} byla úspěšně odeslána
DocType: Loan,Loan Type,Typ úvěru
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Credit Card,Kreditní karta
DocType: Quality Goal,Quality Goal,Kvalitní cíl
DocType: BOM,Item to be manufactured or repacked,Položka k výrobě nebo zabalení
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in condition: {0},Chyba syntaxe ve stavu: {0}
DocType: Fee Structure,EDU-FST-.YYYY.-,EDU-FST-.YYYY.-
DocType: Employee Education,Major/Optional Subjects,Hlavní / Volitelné předměty
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: Sales Invoice Item,Drop Ship,Drop Loď
DocType: Driver,Suspended,Pozastaveno
DocType: Training Event,Attendees,Účastníci
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Zde si můžete udržovat rodinné detailů, jako jsou jméno a povolání rodičem, manželem a dětmi"
DocType: Academic Term,Term End Date,Termín Datum ukončení
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Daně a poplatky odečteny (Company měna)
DocType: Item Group,General Settings,Obecné nastavení
DocType: Article,Article,Článek
apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Zadejte kód kupónu !!
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Z měny a měny nemůže být stejné
DocType: Taxable Salary Slab,Percent Deduction,Procentní odpočet
DocType: GL Entry,To Rename,Přejmenovat
DocType: Stock Entry,Repack,Přebalit
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select to add Serial Number.,Vyberte pro přidání sériového čísla.
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;
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select the Company first,Nejprve vyberte společnost
DocType: Item Attribute,Numeric Values,Číselné hodnoty
apps/erpnext/erpnext/public/js/setup_wizard.js,Attach Logo,Připojit Logo
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Levels,Sklad Úrovně
DocType: Customer,Commission Rate,Výše provize
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Successfully created payment entries,Úspěšné vytvoření platebních položek
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Created {0} scorecards for {1} between: ,Vytvořili {0} skóre pro {1} mezi:
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.py,Not permitted. Please disable the Procedure Template,Nepovoleno. Zakažte šablonu procedur
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 jedním z příjem Pay a interní převod
DocType: Travel Itinerary,Preferred Area for Lodging,Preferovaná oblast pro ubytování
apps/erpnext/erpnext/config/agriculture.py,Analytics,analytika
DocType: Salary Detail,Additional Amount,Další částka
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html,Cart is Empty,Košík je prázdný
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. Serializované položky \ mohou být doručeny na základě sériového čísla
DocType: Vehicle,Model,Model
DocType: Work Order,Actual Operating Cost,Skutečné provozní náklady
DocType: Payment Entry,Cheque/Reference No,Šek / Referenční číslo
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Fetch based on FIFO,Načíst na základě FIFO
DocType: Soil Texture,Clay Loam,Clay Loam
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root cannot be edited.,Root nelze upravovat.
DocType: Item,Units of Measure,Jednotky měření
DocType: Employee Tax Exemption Declaration,Rented in Metro City,Pronajal v Metro City
DocType: Supplier,Default Tax Withholding Config,Výchozí nastavení zadržení daně
DocType: Manufacturing Settings,Allow Production on Holidays,Povolit Výrobu při dovolené
DocType: Sales Invoice,Customer's Purchase Order Date,Zákazníka Objednávka Datum
DocType: Production Plan,MFG-PP-.YYYY.-,MFG-PP-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Capital Stock,Základní kapitál
DocType: Asset,Default Finance Book,Výchozí finanční kniha
DocType: Shopping Cart Settings,Show Public Attachments,Zobrazit veřejné přílohy
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Edit Publishing Details,Upravit podrobnosti publikování
DocType: Packing Slip,Package Weight Details,Hmotnost balení Podrobnosti
DocType: Leave Type,Is Compensatory,Je kompenzační
DocType: Restaurant Reservation,Reservation Time,Čas rezervace
DocType: Payment Gateway Account,Payment Gateway Account,Platební brána účet
DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Po dokončení platby přesměrovat uživatele na vybrané stránky.
DocType: Company,Existing Company,stávající Company
DocType: Healthcare Settings,Result Emailed,Výsledkem byl emailem
DocType: Item Tax Template Detail,Item Tax Template Detail,Detail šablony položky daně
apps/erpnext/erpnext/controllers/buying_controller.py,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Daňová kategorie byla změněna na &quot;Celkem&quot;, protože všechny položky jsou položky, které nejsou skladem"
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/hr/doctype/employee_promotion/employee_promotion.js,Nothing to change,Nic se nemění
apps/erpnext/erpnext/crm/doctype/lead/lead.py,A Lead requires either a person's name or an organization's name,Vedoucí vyžaduje jméno osoby nebo jméno organizace
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please select a csv file,Vyberte soubor csv
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Error in some rows,Chyba v některých řádcích
DocType: Holiday List,Total Holidays,Celkem prázdnin
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Missing email template for dispatch. Please set one in Delivery Settings.,Chybí šablona e-mailu pro odeslání. Nastavte prosím jednu z možností Nastavení doručení.
DocType: Student Leave Application,Mark as Present,Označit jako dárek
DocType: Supplier Scorecard,Indicator Color,Barva indikátoru
DocType: Purchase Order,To Receive and Bill,Přijímat a Bill
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Reqd by Date cannot be before Transaction Date,Řádek # {0}: Reqd by Date nemůže být před datem transakce
DocType: Asset Maintenance,Select Serial No,Zvolte pořadové číslo
DocType: Pricing Rule,Is Cumulative,Je kumulativní
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Designer,Návrhář
apps/erpnext/erpnext/config/accounts.py,Terms and Conditions Template,Podmínky Template
DocType: Delivery Trip,Delivery Details,Zasílání
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 podrobnosti, abyste vygenerovali výsledek hodnocení."
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 nutné v řadě {0} na daních tabulka typu {1}
DocType: Terms and Conditions,Terms and Conditions Help,Podmínky nápovědy
,Item-wise Purchase Register,Item-wise registr nákupu
DocType: Loyalty Point Entry,Expiry Date,Datum vypršení platnosti
DocType: Healthcare Settings,Employee name and designation in print,Jméno a označení zaměstnance v tisku
apps/erpnext/erpnext/config/buying.py,Supplier Addresses and Contacts,Dodavatel Adresy a kontakty
,accounts-browser,Účty-browser
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Please select Category first,Nejdřív vyberte kategorii
apps/erpnext/erpnext/config/projects.py,Project master.,Master Project.
DocType: Contract,Contract Terms,Smluvní podmínky
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Continue Configuration,Pokračujte v konfiguraci
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Nevykazují žádný symbol jako $ atd vedle měnám.
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Maximum benefit amount of component {0} exceeds {1},Maximální částka prospěchu součásti {0} přesahuje {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py, (Half Day),(půlden)
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Master Data,Zpracování kmenových dat
DocType: Payment Term,Credit Days,Úvěrové dny
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Please select Patient to get Lab Tests,Vyberte pacienta pro získání laboratorních testů
DocType: Exotel Settings,Exotel Settings,Nastavení Exotelu
DocType: Leave Ledger Entry,Is Carry Forward,Je převádět
DocType: Shift Type,Working hours below which Absent is marked. (Zero to disable),"Pracovní doba, pod kterou je označen Absent. (Nulování zakázat)"
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Send a message,Poslat zprávu
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Get Items from BOM,Položka získaná z BOM
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Lead Time Days,Dodací lhůta dny
DocType: Cash Flow Mapping,Is Income Tax Expense,Jsou náklady na daň z příjmů
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í!
DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,"Zkontrolujte, zda student bydlí v Hostelu ústavu."
DocType: Course,Hero Image,Obrázek hrdiny
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Sales Orders in the above table,"Prosím, zadejte Prodejní objednávky v tabulce výše"
,Stock Summary,Sklad Souhrn
apps/erpnext/erpnext/config/assets.py,Transfer an asset from one warehouse to another,Převést aktiva z jednoho skladu do druhého
DocType: Vehicle,Petrol,Benzín
DocType: Employee Benefit Application,Remaining Benefits (Yearly),Zbývající přínosy (ročně)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Bill of Materials,Kusovník
DocType: Shift Type,The time after the shift start time when check-in is considered as late (in minutes).,"Čas po začátku směny, kdy se check-in považuje za pozdní (v minutách)."
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}: Typ Party Party a je nutné pro pohledávky / závazky na účtu {1}
DocType: Employee,Leave Policy,Zanechte zásady
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update Items,Aktualizovat položky
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Ref Date,Ref Datum
DocType: Employee,Reason for Leaving,Důvod Leaving
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,View call log,Zobrazit protokol hovorů
DocType: BOM Operation,Operating Cost(Company Currency),Provozní náklady (Company měna)
DocType: Loan Application,Rate of Interest,Úroková sazba
DocType: Expense Claim Detail,Sanctioned Amount,Sankcionována Částka
DocType: Item,Shelf Life In Days,Životnost v dnech
DocType: GL Entry,Is Opening,Se otevírá
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Unable to find the time slot in the next {0} days for the operation {1}.,V následujících {0} dnech operace nebylo možné najít časový úsek {1}.
DocType: Department,Expense Approvers,Odpůrci výdajů
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Debit entry can not be linked with a {1},Row {0}: záporný nemůže být spojována s {1}
DocType: Journal Entry,Subscription Section,Sekce odběru
apps/erpnext/erpnext/controllers/buying_controller.py,{0} Asset{2} Created for <b>{1}</b>,{0} Aktiva {2} Vytvořeno pro <b>{1}</b>
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0} does not exist,Účet {0} neexistuje
DocType: Training Event,Training Program,Tréninkový program
DocType: Account,Cash,V hotovosti
DocType: Sales Invoice,Unpaid and Discounted,Neplacené a zlevněné
DocType: Employee,Short biography for website and other publications.,Krátký životopis na internetové stránky a dalších publikací.
