DocType: Accounting Period,Period Name,Názov obdobia
DocType: Employee,Salary Mode,Mode Plat
apps/erpnext/erpnext/public/js/hub/marketplace.js,Register,Registrovať
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Received,Čiastočne prijaté
DocType: Patient,Divorced,Rozvedený
DocType: Support Settings,Post Route Key,Pridať kľúč trasy
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html,Event Link,Odkaz na udalosť
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,"Povoliť položky, ktoré sa pridávajú viackrát v transakcii"
DocType: Content Question,Content Question,Otázka obsahu
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,Kvalitatívna spätná väzba
apps/erpnext/erpnext/config/education.py,Assessment Reports,Hodnotiace správy
DocType: Invoice Discounting,Accounts Receivable Discounted Account,Zľavový účet pohľadávok
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting_list.js,Canceled,zrušený
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consumer Products,Zákaznícke produkty
DocType: Supplier Scorecard,Notify Supplier,Informujte dodávateľa
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 prvý"
DocType: Item,Customer Items,Zákaznícke položky
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Liabilities,záväzky
DocType: Project,Costing and Billing,Kalkulácia a fakturácia
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Advance account currency should be same as company currency {0},Advance mena účtu by mala byť rovnaká ako mena spoloč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,Nedá sa nájsť aktívne obdobie neprítomnosti
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Evaluation,ohodnotenie
DocType: Item,Default Unit of Measure,Predvolená merná jednotka
DocType: SMS Center,All Sales Partner Contact,Všechny Partneři Kontakt
DocType: Department,Leave Approvers,Schvaľovatelia priepustiek
DocType: Employee,Bio / Cover Letter,Bio / Cover Letter
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Search Items ...,Hľadať položky ...
DocType: Patient Encounter,Investigations,vyšetrovania
DocType: Restaurant Order Entry,Click Enter To Add,Kliknite na položku Zadat &#39;na pridanie
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py,"Missing value for Password, API Key or Shopify URL","Chýba hodnota hesla, kľúč API alebo URL predaja"
DocType: Employee,Rented,Pronajato
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,All Accounts,Všetky účty
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Cannot transfer Employee with status Left,Nie je možné previesť zamestnanca so stavom doľava
DocType: Vehicle Service,Mileage,Najazdené
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Do you really want to scrap this asset?,Naozaj chcete zrušiť túto pohľadávku?
DocType: Drug Prescription,Update Schedule,Aktualizovať plán
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Select Default Supplier,Vybrať Predvolené Dodávateľ
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Show Employee,Zobraziť zamestnanca
DocType: Payroll Period,Standard Tax Exemption Amount,Suma štandardného oslobodenia od dane
DocType: Exchange Rate Revaluation Account,New Exchange Rate,Nový kurz
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Currency is required for Price List {0},Mena je vyžadovaná pre Cenník {0}
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Bude vypočítané v transakcii.
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Nastavte systém pomenovávania zamestnancov v časti Ľudské zdroje&gt; Nastavenia ľudských zdrojov
DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
DocType: Purchase Order,Customer Contact,Zákaznícky kontakt
DocType: Shift Type,Enable Auto Attendance,Povoliť automatickú účasť
apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Zadajte sklad a dátum
DocType: Lost Reason Detail,Opportunity Lost Reason,Príležitosť stratila dôvod
DocType: Patient Appointment,Check availability,Skontrolovať dostupnosť
DocType: Retention Bonus,Bonus Payment Date,Dátum výplaty bonusu
DocType: Employee,Job Applicant,Job Žadatel
DocType: Job Card,Total Time in Mins,Celkový čas v minútach
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žené na transakciách proti tomuto dodávateľovi. Pozri časovú os nižšie podrobnosti
DocType: Manufacturing Settings,Overproduction Percentage For Work Order,Percento nadprodukcie pre pracovnú objednávku
DocType: Landed Cost Voucher,MAT-LCV-.YYYY.-,MAT-LCV-.YYYY.-
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Legal,Právne
DocType: Sales Invoice,Transport Receipt Date,Dátum príjmu dopravy
DocType: Shopify Settings,Sales Order Series,Séria objednávok
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álny typ daň nemôže byť zahrnutý v cene Položka v riadku {0}
DocType: Allowed To Transact With,Allowed To Transact With,Povolené na transakciu 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 financií
apps/erpnext/erpnext/assets/doctype/asset/asset.py,All the depreciations has been booked,Všetky odpisy boli zaúčtované
DocType: Purchase Order,% Billed,% Fakturovaných
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í byť rovnaká ako {0} {1} ({2})
DocType: Employee Tax Exemption Declaration,HRA Exemption,Výnimka HRA
DocType: Sales Invoice,Customer Name,Meno zákazníka
DocType: Vehicle,Natural Gas,Zemný plyn
DocType: Project,Message will sent to users to get their status on the project,Správa sa odošle používateľom s cieľom získať ich stav v projekte
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Bank account cannot be named as {0},Bankový účet nemôže byť pomenovaný {0}
DocType: Employee Tax Exemption Declaration,HRA as per Salary Structure,HRA podľa platovej štruktúry
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,Dátum ukončenia servisu nemôže byť pred dátumom začiatku servisu
DocType: Manufacturing Settings,Default 10 mins,Predvolené 10 min
DocType: Leave Type,Leave Type Name,Nechte Typ Jméno
apps/erpnext/erpnext/templates/pages/projects.js,Show open,ukázať otvorené
apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Employee ID is linked with another instructor,ID zamestnanca je prepojené s iným inštruktorom
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ásiť sa
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Non stock items,Neskladové položky
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} in row {1},{0} v riadku {1}
DocType: Asset Finance Book,Depreciation Start Date,Dátum začiatku odpisovania
DocType: Pricing Rule,Apply On,Aplikujte na
DocType: Item Price,Multiple Item prices.,Více ceny položku.
,Purchase Order Items To Be Received,Neprijaté položky odoslanej objednávky
DocType: SMS Center,All Supplier Contact,Vše Dodavatel Kontakt
DocType: Support Settings,Support Settings,nastavenie podporných
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0} is added in the child company {1},Účet {0} sa pridal do podradenej spoločnosti {1}
apps/erpnext/erpnext/erpnext_integrations/doctype/exotel_settings/exotel_settings.py,Invalid credentials,Neplatné poverenia
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Available (whether in full op part),ITC k dispozícii (či už v plnej op časti)
DocType: Amazon MWS Settings,Amazon MWS Settings,Amazon MWS Settings
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Vouchers,Spracovávajú sa poukazy
apps/erpnext/erpnext/utilities/transaction_base.py,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,"Riadok # {0}: Cena musí byť rovnaké, ako {1}: {2} ({3} / {4})"
,Batch Item Expiry Status,Batch Item Zánik Status
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,Celkový počet oneskorených zápisov
DocType: Mode of Payment Account,Mode of Payment Account,Způsob platby účtu
apps/erpnext/erpnext/config/healthcare.py,Consultation,Konzultácia
DocType: Accounts Settings,Show Payment Schedule in Print,Zobraziť plán platieb v časti Tlač
apps/erpnext/erpnext/stock/doctype/item/item.py,Item Variants updated,Varianty položiek boli aktualizované
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py,Sales and Returns,Predaje a vrátenia
apps/erpnext/erpnext/stock/doctype/item/item.js,Show Variants,Zobraziť Varianty
DocType: Academic Term,Academic Term,akademický Term
DocType: Employee Tax Exemption Sub Category,Employee Tax Exemption Sub Category,Oslobodenie od dane pre zamestnancov
apps/erpnext/erpnext/regional/italy/utils.py,Please set an Address on the Company '%s',Zadajte adresu spoloč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álny prínos zamestnanca {0} presahuje {1} sumou {2} zložky žiadosti o dávku v pomere k výške a predchádzajúce nárokovaná čiastka
DocType: Opening Invoice Creation Tool Item,Quantity,Množstvo
,Customers Without Any Sales Transactions,Zákazníci bez akýchkoľvek predajných transakcií
DocType: Manufacturing Settings,Disable Capacity Planning,Vypnite plánovanie kapacity
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Accounts table cannot be blank.,Účty tabuľka nemôže byť prázdne.
DocType: Delivery Trip,Use Google Maps Direction API to calculate estimated arrival times,Na výpočet odhadovaných časov príchodu použite rozhranie API služby Mapy Google
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,Stretnutie s časom
DocType: Staffing Plan Detail,Total Estimated Cost,Celkové odhadované náklady
DocType: Employee Education,Year of Passing,Rok Passing
DocType: Routing,Routing Name,Názov smerovania
DocType: Item,Country of Origin,Krajina pôvodu
DocType: Soil Texture,Soil Texture Criteria,Kritériá textúry 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,Priame kontaktné údaje
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Issues,otvorené problémy
DocType: Production Plan Item,Production Plan Item,Výrobní program Item
DocType: Leave Ledger Entry,Leave Ledger Entry,Opustiť zadanie 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,Pridať nový riadok
apps/erpnext/erpnext/utilities/activation.py,Create Lead,Vytvoriť potenciálneho 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),Oneskorenie s platbou (dni)
DocType: Payment Terms Template Detail,Payment Terms Template Detail,Podrobné informácie o podmienkach platieb
DocType: Hotel Room Reservation,Guest Name,Meno hosťa
DocType: Delivery Note,Issue Credit Note,Vydanie kreditnej poznámky
DocType: Lab Prescription,Lab Prescription,Lab Prescription
,Delay Days,Oneskorené dni
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} už je uvedené vo faktúre predaja: {1}
DocType: Bank Statement Transaction Invoice Item,Invoice,Faktúra
DocType: Employee Tax Exemption Declaration Category,Maximum Exempted Amount,Maximálna oslobodená suma
DocType: Purchase Invoice Item,Item Weight Details,Podrobnosti o položke hmotnosti
DocType: Asset Maintenance Log,Periodicity,Periodicita
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} is required,Fiškálny rok {0} je vyžadovaná
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py,Net Profit/Loss,Čistý zisk / strata
DocType: Employee Group Table,ERPNext User ID,ERPĎalšie ID používateľa
DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,Minimálna vzdialenosť medzi radmi rastlín pre optimálny rast
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Please select Patient to get prescribed procedure,"Ak chcete získať predpísaný postup, vyberte možnosť 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 veriteľov
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á kalkulácie Čiastka
DocType: Sales Invoice,Vehicle No,Vozidle
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select Price List,"Prosím, vyberte cenník"
DocType: Accounts Settings,Currency Exchange Settings,Nastavenia výmeny meny
DocType: Appointment Booking Slots,Appointment Booking Slots,Výherné automaty na schôdzky
DocType: Work Order Operation,Work In Progress,Work in Progress
DocType: Leave Control Panel,Branch (optional),Pobočka (voliteľné)
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Please select date,"Prosím, vyberte dátum"
DocType: Item Price,Minimum Qty ,Minimálny počet
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,BOM recursion: {0} cannot be child of {1},Rekurzia kusovníka: {0} nemôže byť dieťaťom z {1}
DocType: Finance Book,Finance Book,Finančná kniha
DocType: Patient Encounter,HLC-ENC-.YYYY.-,HLC-ENC-.YYYY.-
DocType: Appointment Booking Settings,Holiday List,Dovolená Seznam
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,The parent account {0} does not exists,Materský účet {0} neexistuje
apps/erpnext/erpnext/config/quality_management.py,Review and Action,Preskúmanie a konanie
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,This employee already has a log with the same timestamp.{0},Tento zamestnanec už má denník s rovnakou časovou pečiatkou. {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Accountant,Účtovník
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Selling Price List,Cenník predaja
DocType: Patient,Tobacco Current Use,Súčasné používanie tabaku
apps/erpnext/erpnext/selling/report/customer_wise_item_price/customer_wise_item_price.py,Selling Rate,Predajná sadzba
DocType: Cost Center,Stock User,Používateľ skladu
DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
DocType: Delivery Stop,Contact Information,Kontaktné informácie
apps/erpnext/erpnext/public/js/hub/pages/Category.vue,Search for anything ...,Vyhľadajte čokoľvek ...
,Stock and Account Value Comparison,Porovnanie hodnoty zásob a účtu
DocType: Company,Phone No,Telefónne číslo
DocType: Delivery Trip,Initial Email Notification Sent,Odoslané pôvodné oznámenie o e-maile
DocType: Bank Statement Settings,Statement Header Mapping,Hlásenie hlavičky výkazu
,Sales Partners Commission,Obchodní partneři Komise
DocType: Soil Texture,Sandy Clay Loam,Sandy Clay Loam
DocType: Purchase Invoice,Rounding Adjustment,Nastavenie zaokrúhľovania
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation cannot have more than 5 characters,Skratka nesmie mať viac ako 5 znakov
DocType: Amazon MWS Settings,AU,AU
DocType: Payment Order,Payment Request,Platba Dopyt
apps/erpnext/erpnext/config/retail.py,To view logs of Loyalty Points assigned to a Customer.,Zobrazenie denníkov vernostných bodov priradených zákazníkovi.
DocType: Asset,Value After Depreciation,Hodnota po odpisoch
DocType: Student,O+,O +
apps/erpnext/erpnext/stock/doctype/material_request/material_request_dashboard.py,Related,príbuzný
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance date can not be less than employee's joining date,Dátum návštevnosť nemôže byť nižšia ako spojovacie dáta zamestnanca
DocType: Grading Scale,Grading Scale Name,Stupnica Name
DocType: Employee Training,Training Date,Dátum školenia
apps/erpnext/erpnext/public/js/hub/marketplace.js,Add Users to Marketplace,Pridajte používateľov na trh
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 spoloč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 už nie je možné vygenerovať pre návratnosť predaja
DocType: Subscription,Subscription Start Date,Dátum začiatku odberu
DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Appointment charges.,"Predvolené pohľadávky, ktoré sa majú použiť, ak nie sú nastavené v pacientoch na účtovanie poplatkov za schôdzku."
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Pripojiť CSV súbor s dvomi stĺpci, jeden pre starý názov a jeden pre nový názov"
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ískajte podrobnosti z vyhlásenia
apps/erpnext/erpnext/accounts/utils.py,{0} {1} not in any active Fiscal Year.,{0} {1} žiadnym aktívnym fiškálny 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} nie je v materskej spoločnosti
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Trial Period End Date Cannot be before Trial Period Start Date,Dátum ukončenia skúšobného obdobia nemôže byť pred začiatkom skúšobného obdobia
DocType: Tax Withholding Category,Tax Withholding Category,Daňová kategória
apps/erpnext/erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py,Cancel the journal entry {0} first,Najskôr zrušte záznam denníka {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 nie je špecifikovaný pre subdodávateľskú položku {0} v riadku {1}
DocType: Vital Signs,Reflexes,reflexy
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,{0} Result submittted,{0} Výsledok bol odoslaný
DocType: Item Attribute,Increment,Prírastok
apps/erpnext/erpnext/templates/pages/search_help.py,Help Results for,Výsledky pomoci pre
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,Rovnaký Spoločnosť je zapísaná viac ako raz
DocType: Patient,Married,Ženatý
apps/erpnext/erpnext/accounts/party.py,Not permitted for {0},Nepovolené pre {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get items from,Získať predmety z
DocType: Stock Entry,Send to Subcontractor,Odoslať subdodávateľovi
DocType: Purchase Invoice,Apply Tax Withholding Amount,Použiť čiastku zrážkovej dane
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á čiastka bola pripísaná
apps/erpnext/erpnext/templates/generators/item_group.html,No items listed,Nie sú uvedené žiadne položky
DocType: Asset Repair,Error Description,Popis chyby
DocType: Payment Reconciliation,Reconcile,Zosúladiť
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 / strata
DocType: Crop,Perennial,trvalka
DocType: Program,Is Published,Publikované
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Delivery Notes,Zobraziť dodacie listy
apps/erpnext/erpnext/controllers/status_updater.py,"To allow over billing, update ""Over Billing Allowance"" in Accounts Settings or the Item.","Ak chcete povoliť nadmernú fakturáciu, aktualizujte položku „Príspevok na fakturáciu“ v nastaveniach účtov alebo v položke."
DocType: Patient Appointment,Procedure,procedúra
DocType: Accounts Settings,Use Custom Cash Flow Format,Použiť formát vlastného toku peňazí
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.,"** Mesačný Distribúcia ** umožňuje distribuovať Rozpočet / Target celé mesiace, ak máte sezónnosti vo vašej firme."
apps/erpnext/erpnext/accounts/page/pos/pos.js,Not items found,nenájdený položiek
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Structure Missing,Plat Štruktúra Chýbajúce
DocType: Lead,Person Name,Osoba Meno
,Supplier Ledger Summary,Zhrnutie knihy dodávateľov
DocType: Sales Invoice Item,Sales Invoice Item,Položka odoslanej faktúry
apps/erpnext/erpnext/projects/doctype/project/project.js,Duplicate project has been created,Bol vytvorený duplikát projektu
DocType: Quality Procedure Table,Quality Procedure Table,Tabuľka kvality
DocType: Account,Credit,Úver
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""",napríklad &quot;Základná škola&quot; alebo &quot;univerzita&quot;
apps/erpnext/erpnext/config/stock.py,Stock Reports,Reporty o zásobách
DocType: Warehouse,Warehouse Detail,Sklad Detail
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Last carbon check date cannot be a future date,Posledný dátum kontroly uhlíkom nemôže byť budúcim dátumom
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ý Dátum ukončenia nemôže byť neskôr ako v roku Dátum ukončenia akademického roka, ku ktorému termín je spojená (akademický rok {}). Opravte dáta a skúste to znova."
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","&quot;Je Fixed Asset&quot; nemôže byť bez povšimnutia, pretože existuje Asset záznam proti položke"
DocType: Delivery Trip,Departure Time,Čas odchodu
DocType: Vehicle Service,Brake Oil,Brake Oil
DocType: Tax Rule,Tax Type,Typ dane
,Completed Work Orders,Dokončené pracovné príkazy
DocType: Support Settings,Forum Posts,Fórum príspevky
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",Úloha bola zadaná ako práca na pozadí. V prípade akýchkoľvek problémov so spracovaním na pozadí systém pridá komentár k chybe pri tomto zúčtovaní zásob a vráti sa do fázy Koncept.
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot delete item {1} which has work order assigned to it.,"Riadok # {0}: Nie je možné odstrániť položku {1}, ktorá má priradený pracovný príkaz."
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Ľutujeme, platnosť kódu kupónu sa nezačala"
apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Zdaniteľná čiastka
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,Nechajte detaily pravidiel
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}.,Riadok # {0}: Operácia {1} nie je dokončená pre {2} množstvo hotového tovaru v objednávke {3}. Aktualizujte prevádzkový stav prostredníctvom Job Card {4}.
DocType: Work Order Operation,(Hour Rate / 60) * Actual Operation Time,(Hodina Rate / 60) * Skutočná Prevádzková doba
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Riadok # {0}: Typ referenčného dokumentu musí byť jeden z nárokov na výdaj alebo denníka
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select BOM,select BOM
DocType: SMS Log,SMS Log,SMS Log
DocType: Call Log,Ringing,zvoniaci
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Delivered Items,Náklady na dodané položky
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py,The holiday on {0} is not between From Date and To Date,Dovolenka na {0} nie je medzi Dátum od a do dnešného dňa
DocType: Inpatient Record,Admission Scheduled,Prijatie naplánované
DocType: Student Log,Student Log,študent Log
apps/erpnext/erpnext/config/buying.py,Templates of supplier standings.,Šablóny poradia dodávateľov.
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írovať z položkovej skupiny
DocType: Journal Entry,Opening Entry,Otvárací údaj
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Account Pay Only,Účet Pay Iba
DocType: Loan,Repay Over Number of Periods,Splatiť 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žstvo na výrobu nesmie byť menšie ako nula
DocType: Stock Entry,Additional Costs,Dodatoč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,Overenie dávky pre študentov v študentskej skupine
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,No leave record found for employee {0} for {1},Žiadny záznam dovolenka nájdené pre zamestnancov {0} na {1}
DocType: Company,Unrealized Exchange Gain/Loss Account,Nerealizovaný účet ziskov a strát na výmene
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter company first,"Prosím, najprv zadajte spoločnosť"
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Please select Company first,"Prosím, vyberte najprv firmu"
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.,Nastavte predvolenú šablónu pre možnosť Ohlásiť stav upozornenia v nastaveniach ľudských zdrojov.
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!,Platnosť pridelenia vypršala!
DocType: Soil Analysis,Ca/K,Ca / K
DocType: Leave Type,Maximum Carry Forwarded Leaves,Maximálny počet prepravených listov
DocType: Salary Slip,Employee Loan,Pôžička zamestnanca
DocType: Additional Salary,HR-ADS-.YY.-.MM.-,HR-ADS-.YY .-. MM.-
DocType: Fee Schedule,Send Payment Request Email,Poslať e-mail s požiadavkou na 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,"Nechajte prázdne, ak je Dodávateľ blokovaný neurčito"
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Real Estate,Nehnuteľnosť
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 dlhodobého majetku
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Future Payments,Zobraziť budúce 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 bankový účet je už synchronizovaný
DocType: Homepage,Homepage Section,Domovská stránka
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work Order has been {0},Pracovná objednávka bola {0}
DocType: Budget,Applicable on Purchase Order,Platí pre nákupnú 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,Nie je nastavená politika hesiel pre platové pásky
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate customer group found in the cutomer group table,Duplicitné skupinu zákazníkov uvedené v tabuľke na knihy zákazníkov skupiny
DocType: Location,Location Name,Názov miesta
DocType: Quality Procedure Table,Responsible Individual,Zodpovedná osoba
DocType: Naming Series,Prefix,Prefix
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html,Event Location,Umiestnenie udalosti
apps/erpnext/erpnext/selling/report/customer_wise_item_price/customer_wise_item_price.py,Available Stock,K dispozícii na sklade
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Spotrebný materiál
DocType: Student,B-,B-
DocType: Assessment Result,Grade,stupeň
DocType: Restaurant Table,No of Seats,Počet sedadiel
DocType: Sales Invoice,Overdue and Discounted,Omeškanie a zľava
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Asset {0} does not belongs to the custodian {1},Majetok {0} nepatrí do úschovy {1}
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Hovor bol odpojený
DocType: Sales Invoice Item,Delivered By Supplier,Dodáva sa podľa dodávateľa
DocType: Asset Maintenance Task,Asset Maintenance Task,Úloha údržby majetku
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ý súhrn práce
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úci spoločnosti pre vytváranie účtový rozvrh
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Expenses,Náklady na skladovanie
DocType: Appointment,Calendar Event,Udalosť kalendára
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Select Target Warehouse,Vyberte položku Target Warehouse
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Select Target Warehouse,Vyberte položku Target Warehouse
apps/erpnext/erpnext/hr/doctype/employee/employee.js,Please enter Preferred Contact Email,"Prosím, zadajte Preferred Kontaktný e-mail"
DocType: Purchase Invoice Item,Accepted Qty,Prijaté množstvo
DocType: Journal Entry,Contra Entry,Contra Entry
DocType: Journal Entry Account,Credit in Company Currency,Úverové spoločnosti v mene
DocType: Lab Test UOM,Lab Test UOM,Laboratórne testovanie UOM
DocType: Delivery Note,Installation Status,Stav instalace
DocType: BOM,Quality Inspection Template,Šablóna inšpekcie 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 aktualizovať dochádzku? <br> Súčasná: {0} \ <br> Prítomných {1}
apps/erpnext/erpnext/controllers/buying_controller.py,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Schválené + Zamietnuté množstvo sa musí rovnať Prijatému množstvu pre položku {0}
DocType: Item,Supply Raw Materials for Purchase,Dodávky suroviny pre nákup
DocType: Agriculture Analysis Criteria,Fertilizer,umelé 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.","Nie je možné zabezpečiť doručenie sériovým číslom, pretože je pridaná položka {0} s alebo bez dodávky."
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,At least one mode of payment is required for POS invoice.,pre POS faktúru je nutná aspoň jeden spôsob platby.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Batch no is required for batched item {0},Šarža č. Sa vyžaduje pre dávkovú položku {0}
DocType: Bank Statement Transaction Invoice Item,Bank Statement Transaction Invoice Item,Položka faktúry transakcie na bankový účet
DocType: Salary Detail,Tax on flexible benefit,Daň z flexibilného prínosu
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álny vek
DocType: Customer,Primary Address,Primárna adresa
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Diff Qty,Rozdielové množstvo
DocType: Production Plan,Material Request Detail,Podrobnosti o vyžiadaní materiálu
DocType: Appointment Booking Settings,Notify customer and agent via email on the day of the appointment.,V deň stretnutia informujte zákazníka a agenta e-mailom.
DocType: Selling Settings,Default Quotation Validity Days,Predvolené dni platnosti cenovej ponuky
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,Overenie účasti
DocType: Sales Invoice,Change Amount,zmena Suma
DocType: Party Tax Withholding Config,Certificate Received,Certifikát bol prijatý
DocType: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Nastavte hodnotu faktúry pre B2C. B2CL a B2CS vypočítané na základe tejto hodnoty faktúry.
DocType: BOM Update Tool,New BOM,New BOM
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Prescribed Procedures,Predpísané postupy
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show only POS,Zobraziť len POS
DocType: Supplier Group,Supplier Group Name,Názov skupiny dodávateľov
DocType: Driver,Driving License Categories,Kategórie vodičských preukazov
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please enter Delivery Date,Zadajte dátum doručenia
DocType: Depreciation Schedule,Make Depreciation Entry,Urobiť Odpisy Entry
DocType: Closed Document,Closed Document,Uzavretý dokument
DocType: HR Settings,Leave Settings,Nechajte nastavenia
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é obdobia
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),Nastavovací režim 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 dodávateľa z Predvoleného zoznamu dodávateľov z nižšie uvedených položiek.
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,Čiastka dane z položky zahrnutá v hodnote
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Membership Details,Podrobnosti o členstve
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Dodávateľ je potrebná proti zaplatení úč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íkov&gt; Územie
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Total hours: {0},Celkom hodín: {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čnej schémy
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Preference,prednosť
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward Supplies(liable to reverse charge,Dočasné dodávky (podliehajú spätnému účtovaniu
DocType: Supplier,Individual,Individuální
DocType: Academic Term,Academics User,akademici Užívateľ
DocType: Cheque Print Template,Amount In Figure,Na obrázku vyššie
DocType: Loan Application,Loan Info,pôžička Informácie
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,All Other ITC,Všetky 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,Termín dodacieho obdobia dodávateľa
DocType: Support Settings,Search APIs,API vyhľadávania
DocType: Share Transfer,Share Transfer,Prenos podielu
,Expiring Memberships,Platnosť členstva
apps/erpnext/erpnext/templates/pages/home.html,Read blog,Prečítajte si blog
DocType: POS Profile,Customer Groups,skupiny zákazníkov
apps/erpnext/erpnext/public/js/financial_statements.js,Financial Statements,Finančné výkazy
DocType: Guardian,Students,študenti
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á súhrnná skupina 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,Žiadosť 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 (%),Zľava z cenníkovej ceny (%)
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,Item Template,Šablóna položky
DocType: Job Offer,Select Terms and Conditions,Vyberte Podmienky
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Out Value,limitu
DocType: Bank Statement Settings Item,Bank Statement Settings Item,Položka Nastavenia bankového výpisu
DocType: Woocommerce Settings,Woocommerce Settings,Woocommerce Settings
DocType: Leave Ledger Entry,Transaction Name,Názov transakcie
DocType: Production Plan,Sales Orders,Predajné objednávky
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Multiple Loyalty Program found for the Customer. Please select manually.,Viacnásobný vernostný program bol nájdený pre zákazníka. Vyberte prosím ručne.
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.,Dátum skončenia platnosti je povinný pre vybratú položku.
,Purchase Order Trends,Nákupní objednávka trendy
DocType: Hotel Room Reservation,Late Checkin,Neskoro checkin
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Finding linked payments,Hľadanie prepojených platieb
apps/erpnext/erpnext/templates/emails/request_for_quotation.html,The request for quotation can be accessed by clicking on the following link,Žiadosť o cenovú ponuku je možné pristupovať kliknutím na nasledujúci odkaz
DocType: Quiz Result,Selected Option,Vybraná možnosť
DocType: SG Creation Tool Course,SG Creation Tool Course,SG nástroj pre tvorbu ihriská
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,Prosím pomenujte Series pre {0} cez Setup&gt; Settings&gt; Naming Series
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Insufficient Stock,nedostatočná Sklad
DocType: Email Digest,New Sales Orders,Nové Prodejní objednávky
DocType: Bank Account,Bank Account,Bankový účet
DocType: Travel Itinerary,Check-out Date,Dátum odchodu
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',Nemôžete odstrániť typ projektu &quot;Externé&quot;
apps/erpnext/erpnext/public/js/utils.js,Select Alternate Item,Vyberte alternatívnu položku
DocType: Employee,Create User,Vytvoriť používateľa
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 alebo dodávateľa.
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 krajiny v súbore sa nezhoduje s kódom krajiny nastaveným v systéme
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Select only one Priority as Default.,Ako predvolenú vyberte iba jednu prioritu.
apps/erpnext/erpnext/controllers/taxes_and_totals.py,Advance amount cannot be greater than {0} {1},Množstvo vopred nemôže byť väčšia ako {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 preskočil, slot {0} až {1} presahuje existujúci slot {2} na {3}"
DocType: Naming Series,Series List for this Transaction,Řada seznam pro tuto transakci
DocType: Company,Enable Perpetual Inventory,Povoliť trvalý inventár
DocType: Bank Guarantee,Charges Incurred,Poplatky vzniknuté
apps/erpnext/erpnext/public/js/education/lms/quiz.js,Something went wrong while evaluating the quiz.,Pri vyhodnocovaní testu sa niečo pokazilo.
DocType: Appointment Booking Settings,Success Settings,Nastavenia úspechu
DocType: Company,Default Payroll Payable Account,"Predvolené mzdy, splatnú Account"
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Edit Details,Upraviť podrobnosti
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Update Email Group,Aktualizácia e-Group
DocType: POS Profile,Only show Customer of these Customer Groups,Zobraziť iba zákazníka z týchto skupín zákazníkov
DocType: Sales Invoice,Is Opening Entry,Je vstupní otvor
apps/erpnext/erpnext/public/js/conf.js,Documentation,Dokumentácia
DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Ak nie je začiarknuté, položka sa nezobrazí v faktúre predaja, ale môže sa použiť pri vytváraní testov skupiny."
DocType: Customer Group,Mention if non-standard receivable account applicable,Zmienka v prípade neštandardnej pohľadávky účet použiteľná
DocType: Course Schedule,Instructor Name,inštruktor Name
DocType: Company,Arrear Component,Súčasnosť komponentu
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.py,Stock Entry has been already created against this Pick List,Položka zásob už bola vytvorená v rámci tohto zoznamu
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",Nepridelená suma Platobného vstupu {0} \ je vyššia ako nepridelená suma Bankovej transakcie
DocType: Supplier Scorecard,Criteria Setup,Nastavenie 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,Prijaté dňa
DocType: Codification Table,Medical Code,Zdravotný zákonník
apps/erpnext/erpnext/config/integrations.py,Connect Amazon with ERPNext,Pripojte Amazon s ERPNext
apps/erpnext/erpnext/templates/generators/item/item_configure.html,Contact Us,Kontaktuj 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ý peňažný tok z financovania
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full , did not save","Miestne úložisko je plná, nezachránil"
DocType: Lead,Address & Contact,Adresa a kontakt
DocType: Leave Allocation,Add unused leaves from previous allocations,Pridať nevyužité listy z predchádzajúcich prídelov
DocType: Sales Partner,Partner website,webové stránky Partner
DocType: Restaurant Order Entry,Add Item,Pridať položku
DocType: Party Tax Withholding Config,Party Tax Withholding Config,Konz
DocType: Lab Test,Custom Result,Vlastný výsledok
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 nižšie overte svoj e-mail a potvrďte schôdzku
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.js,Bank accounts added,Boli pridané bankové účty
DocType: Call Log,Contact Name,Meno kontaktu
DocType: Plaid Settings,Synchronize all accounts every hour,Synchronizujte všetky účty každú hodinu
DocType: Course Assessment Criteria,Course Assessment Criteria,Hodnotiace kritériá kurz
DocType: Pricing Rule Detail,Rule Applied,Platí pravidlo
DocType: Service Level Priority,Resolution Time Period,Časové rozlíšenie riešenia
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Tax Id: ,ID dane:
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student ID: ,Študentská karta:
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,riadkovanie za čiastku v slovách
DocType: Vehicle,Additional Details,Ďalšie podrobnosti
apps/erpnext/erpnext/templates/generators/bom.html,No description given,Bez popisu
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Načítať položky zo skladu
apps/erpnext/erpnext/config/buying.py,Request for purchase.,Žádost o koupi.
DocType: POS Closing Voucher Details,Collected Amount,Zozbieraná suma
DocType: Lab Test,Submitted Date,Dátum odoslania
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Company field is required,Pole spoloč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žené na časových výkazov vytvorených proti tomuto projektu
DocType: Item,Minimum quantity should be as per Stock UOM,Minimálne množstvo by malo byť podľa zásob UOM
DocType: Call Log,Recording URL,Nahrávacia adresa URL
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,Start Date cannot be before the current date,Dátum začiatku nemôže byť pred aktuálnym dátumom
,Open Work Orders,Otvorte pracovné príkazy
DocType: Healthcare Practitioner,Out Patient Consulting Charge Item,Zariadenie pre poplatok za konzultáciu pacienta
DocType: Payment Term,Credit Months,Kreditné mesiace
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Net Pay cannot be less than 0,Čistý Pay nemôže byť nižšia ako 0
DocType: Contract,Fulfilled,splnené
DocType: Inpatient Record,Discharge Scheduled,Plnenie je naplánované
DocType: POS Closing Voucher,Cashier,Pokladník
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Leaves per Year,Listy 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,Zisk & Strata
DocType: Task,Total Costing Amount (via Time Sheet),Celková kalkulácie Čiastka (cez Time Sheet)
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py,Please setup Students under Student Groups,Nastavte prosím študentov pod študentský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,Nechte Blokováno
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,bankový Príspevky
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)","Ak je začiarknuté políčko Auto Opt In, zákazníci budú automaticky prepojení s príslušným vernostným programom (pri ukladaní)"
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Inventúrna položka
DocType: Stock Entry,Sales Invoice No,Číslo odoslanej faktúry
DocType: Website Filter Field,Website Filter Field,Pole filtra webových stránok
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Supply Type,Typ dodávky
DocType: Material Request Item,Min Order Qty,Min Objednané množství
DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Študent Group Creation Tool ihrisko
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,Založenie záznamu vzorky 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čiatok Samozrejme Dátum
,Student Batch-Wise Attendance,Študent Batch-Wise Účasť
DocType: POS Profile,Allow user to edit Rate,Umožňujú užívateľovi upravovať Cena
DocType: Item,Publish in Hub,Publikovat v Hub
DocType: Student Admission,Student Admission,študent 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ý riadok {0}: Dátum začiatku odpisovania sa zadáva ako posledný dátum
DocType: Contract Template,Fulfilment Terms and Conditions,Zmluvné podmienky plnenia
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material Request,Požiadavka 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ík Množ
,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} nebol nájdený v &quot;suroviny dodanej&quot; tabuľky v objednávke {1}
DocType: Salary Slip,Total Principal Amount,Celková hlavná čiastka
DocType: Student Guardian,Relation,Vztah
DocType: Quiz Result,Correct,korektné
DocType: Student Guardian,Mother,matka
DocType: Restaurant Reservation,Reservation End Time,Čas ukončenia rezervácie
DocType: Crop,Biennial,dvojročný
,BOM Variance Report,Správa o odchýlkach kusovníka
apps/erpnext/erpnext/config/selling.py,Confirmed orders from Customers.,Potvrzené objednávky od zákazníků.
DocType: Purchase Receipt Item,Rejected Quantity,Zamítnuto Množství
apps/erpnext/erpnext/education/doctype/fees/fees.py,Payment request {0} created,Žiadosť o platbu {0} bola vytvorená
DocType: Inpatient Record,Admitted Datetime,Pripravený dátum
DocType: Work Order,Backflush raw materials from work-in-progress warehouse,Spätné suroviny z nedokončeného skladu
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Open Orders,Otvorené objednávky
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Unable to find Salary Component {0},Nedá sa nájsť zložka platu {0}
apps/erpnext/erpnext/healthcare/setup.py,Low Sensitivity,Nízka citlivosť
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_log/shopify_log.js,Order rescheduled for sync,Objednávka bola preplánovaná na synchronizáciu
apps/erpnext/erpnext/templates/emails/training_event.html,Please confirm once you have completed your training,"Potvrďte, prosím, po dokončení školenia"
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.,Táto spoločnosť sa použije na vytvorenie zákaziek odberateľa.
DocType: Plaid Settings,Plaid Public Key,Plaid Public Key
DocType: Payment Term,Payment Term Name,Názov platby
DocType: Healthcare Settings,Create documents for sample collection,Vytvorte dokumenty na odber vzoriek
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 byť väčšia ako dlžnej čiastky {2}
apps/erpnext/erpnext/patches/v11_0/add_healthcare_service_unit_tree_root.py,All Healthcare Service Units,Všetky jednotky zdravotnej starostlivosti
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Converting Opportunity,O konverzii príležitosti
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,Spôsob platieb
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 definovať všetky úlohy, ktoré je potrebné vykonať pre túto plodinu tu. Denné pole sa používa na uvedenie dňa, kedy je potrebné vykonať úlohu, 1 je prvý deň atď."
DocType: Student Group Student,Student Group Student,Študent Skupina Student
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Latest,Najnovšie
DocType: Packed Item,Actual Batch Quantity,Skutočné množstvo šarže
DocType: Asset Maintenance Task,2 Yearly,2 ročne
DocType: Education Settings,Education Settings,Nastavenia vzdelávania
DocType: Vehicle Service,Inspection,inšpekcia
apps/erpnext/erpnext/regional/italy/utils.py,E-Invoicing Information Missing,Chýbajú informácie o elektronickej fakturácii
DocType: Leave Allocation,HR-LAL-.YYYY.-,HR-LAL-.YYYY.-
DocType: Exchange Rate Revaluation Account,Balance In Base Currency,Zostatok v základnej mene
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.,Účasť sa nepodala za {0} ako {1} v dovolenke.
DocType: Journal Entry,Payment Order,Platobný príkaz
apps/erpnext/erpnext/www/book_appointment/verify/index.html,Verify Email,potvrdiť Email
DocType: Employee Tax Exemption Declaration,Income From Other Sources,Príjmy z iných zdrojov
DocType: Warehouse,"If blank, parent Warehouse Account or company default will be considered","Ak je prázdny, bude sa brať do úvahy predvolený účet rodičovského skladu alebo spoločnosť"
DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,"E-maily výplatnej páske, aby zamestnanci na základe prednostného e-mailu vybraného v zamestnaneckých"
DocType: Tax Rule,Shipping County,Okres dodania
DocType: Currency Exchange,For Selling,Pre predaj
apps/erpnext/erpnext/config/desktop.py,Learn,Učenie
,Trial Balance (Simple),Skúšobný zostatok (jednoduchý)
DocType: Purchase Invoice Item,Enable Deferred Expense,Povolenie odloženého výdavku
apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Kód použitého kupónu
DocType: Asset,Next Depreciation Date,Vedľa Odpisy Dátum
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Náklady na činnosť na jedného zamestnanca
DocType: Accounts Settings,Settings for Accounts,Nastavenie Účtovníctva
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice No exists in Purchase Invoice {0},Dodávateľské faktúry No existuje vo faktúre {0}
apps/erpnext/erpnext/config/crm.py,Manage Sales Person Tree.,Správa obchodník strom.
DocType: Job Applicant,Cover Letter,Sprievodný list
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Outstanding Cheques and Deposits to clear,Vynikajúci Š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,Dovozné zásielky z 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},Riadok # {0}: {1} nemôže byť negatívne na {2}
apps/erpnext/erpnext/setup/doctype/company/company.js,Wrong Password,Zlé Heslo
DocType: POS Profile,Offline POS Settings,Nastavenia POS offline
DocType: Stock Entry Detail,Reference Purchase Receipt,Referenčný doklad o nákupe
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,Obdobie 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,Kartu pre študentov
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,Zobraziť predajnú osobu
DocType: Appointment Type,Is Inpatient,Je hospitalizovaný
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Name,Meno 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,Vzdialenosť od ľavého okraja
apps/erpnext/erpnext/utilities/bot.py,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} jednotiek [{1}] (# Form / bodu / {1}) bola nájdená v [{2}] (# Form / sklad / {2})
DocType: Lead,Industry,Průmysl
DocType: BOM Item,Rate & Amount,Sadzba a množstvo
apps/erpnext/erpnext/config/website.py,Settings for website product listing,Nastavenia pre zoznam produktov webových stránok
apps/erpnext/erpnext/accounts/report/sales_register/sales_register.py,Tax Total,Daň celkom
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Amount of Integrated Tax,Výška integrovanej dane
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ázov dimenzie
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 sadzbu izby hotela na {}"
DocType: Journal Entry,Multi Currency,Viac mien
DocType: Bank Statement Transaction Invoice Item,Invoice Type,Typ faktúry
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from date must be less than valid upto date,Platné od dátumu musí byť kratšie ako platné do dátumu
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Exception occurred while reconciling {0},Počas vyrovnania došlo k výnimke {0}
DocType: Purchase Invoice,Set Accepted Warehouse,Nastaviť prijatý sklad
DocType: Employee Benefit Claim,Expense Proof,Dôkaz o nákladoch
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.py,Saving {0},Uloženie {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Delivery Note,Dodací list
DocType: Patient Encounter,Encounter Impression,Zaznamenajte zobrazenie
apps/erpnext/erpnext/config/help.py,Setting up Taxes,Nastavenie Dane
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Sold Asset,Náklady predaných aktív
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Target Location is required while receiving Asset {0} from an employee,Cieľová lokalita je vyžadovaná pri prijímaní aktíva {0} od zamestnanca
DocType: Volunteer,Morning,dopoludnia
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á študentská dávka
apps/erpnext/erpnext/accounts/doctype/item_tax_template/item_tax_template.py,{0} entered twice in Item Tax,{0} vložené dvakrát v Daňovej Položke
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Summary for this week and pending activities,Zhrnutie pre tento týždeň a prebiehajúcim činnostiam
DocType: Student Applicant,Admitted,"pripustil,"
DocType: Workstation,Rent Cost,Rent Cost
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Item listing removed,Zoznam položiek bol odstránený
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid transactions sync error,Chyba synchronizácie prehľadných transakcií
DocType: Leave Ledger Entry,Is Expired,Platnosť vypršala
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py,Amount After Depreciation,Suma po odpisoch
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Upcoming Calendar Events,Nadchádzajúce Udalosti v kalendári
apps/erpnext/erpnext/public/js/templates/item_quick_entry.html,Variant Attributes,Variantov atribúty
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,E-mail spoločnosti
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,User has not applied rule on the invoice {0},Používateľ na faktúru neuplatnil pravidlo {0}
DocType: GL Entry,Debit Amount in Account Currency,Debetné Čiastka v mene účtu
DocType: Supplier Scorecard,Scoring Standings,Skóre bodov
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Value,Hodnota objednávky
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é operácie proti osobe alebo pre interný prevod
DocType: Shipping Rule,Valid for Countries,"Platí pre krajiny,"
apps/erpnext/erpnext/hr/doctype/training_event/training_event.py,End time cannot be before start time,Čas ukončenia nemôže byť skôr ako čas začiatku
apps/erpnext/erpnext/templates/generators/item/item_configure.js,1 exact match.,1 presná zhoda.
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,Žiadosť 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,Nie je certifikovaný
DocType: Asset Value Adjustment,New Asset Value,Nová hodnota majetku
DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,"Sazba, za kterou je zákazník měny převeden na zákazníka základní měny"
DocType: Course Scheduling Tool,Course Scheduling Tool,Samozrejme Plánovanie Tool
DocType: Crop Cycle,LInked Analysis,Llnked Analysis
DocType: POS Closing Voucher,POS Closing Voucher,Uzávierka POS uzávierky
DocType: Invoice Discounting,Loan Start Date,Dátum začiatku pôžičky
DocType: Contract,Lapsed,odpadlý
DocType: Item Tax Template Detail,Tax Rate,Sadzba dane
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,Obdobie žiadosti nemôže prebiehať medzi dvoma alokačnými záznamami
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,{0} already allocated for Employee {1} for period {2} to {3},{0} už pridelené pre zamestnancov {1} na dobu {2} až {3}
DocType: Buying Settings,Backflush Raw Materials of Subcontract Based On,Backflush Suroviny subdodávateľských služieb 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í byť rovnaké, ako {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,Povoliť zaplnenie
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to non-Group,Previesť na non-Group
DocType: Exotel Settings,Account SID,SID účtu
DocType: Bank Statement Transaction Invoice Item,Invoice Date,Dátum fakturácie
DocType: GL Entry,Debit Amount,Debetné Suma
apps/erpnext/erpnext/accounts/party.py,There can only be 1 Account per Company in {0} {1},Tam môže byť len 1 účet na spoločnosti v {0} {1}
DocType: Support Search Source,Response Result Key Path,Cesta kľúča výsledku odpovede
DocType: Journal Entry,Inter Company Journal Entry,Inter company Journal Entry
apps/erpnext/erpnext/accounts/party.py,Due Date cannot be before Posting / Supplier Invoice Date,Dátum splatnosti nemôže byť skôr ako dátum zaúčtovania / fakturácie dodávateľa
DocType: Employee Training,Employee Training,Školenie zamestnancov
DocType: Quotation Item,Additional Notes,Doplňujúce Poznámky
DocType: Purchase Order,% Received,% Prijaté
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Create Student Groups,Vytvorenie skupiny študentov
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Available quantity is {0}, you need {1}","Dostupné množstvo je {0}, potrebujete {1}"
DocType: Volunteer,Weekends,víkendy
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Credit Note Amount,Výška úverovej 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},Riadok # {0}: Poradové číslo {1} nepatrí do šarže {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} nie je zapísaný do kurzu {2}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Name: ,Meno študenta:
DocType: POS Closing Voucher,Difference,Rozdiel
DocType: Delivery Settings,Delay between Delivery Stops,Oneskorenie medzi 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á sa, že je problém s konfiguráciou servera GoCardless. Nebojte sa, v prípade zlyhania bude suma vrátená do vášho účtu."
apps/erpnext/erpnext/templates/pages/demo.html,ERPNext Demo,ERPNext Demo
apps/erpnext/erpnext/public/js/utils/item_selector.js,Add Items,Pridať položky
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Položka Kontrola jakosti Parametr
DocType: Leave Application,Leave Approver Name,Meno schvaľovateľa priepustky
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,Riadok # {0}: Dátum ukončenia služby nemôže byť pred dátumom zaúčtovania faktúry
DocType: Job Offer Term,Job Offer Term,Ponuka pracovnej doby
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 pre zamestnancov {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 študentov z
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Get Students From,Povinné pole - Získajte študentov z
DocType: Program Enrollment,Enrolled courses,Zapísané kurzy
DocType: Program Enrollment,Enrolled courses,Zapísané kurzy
DocType: Currency Exchange,Currency Exchange,Zmenáreň
apps/erpnext/erpnext/support/doctype/issue/issue.js,Resetting Service Level Agreement.,Obnovenie dohody o úrovni služieb.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Item Name,Názov položky
DocType: Authorization Rule,Approving User  (above authorized value),Schválenie užívateľa (nad oprávnenej 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,Žiadosť o cenovú ponuku
DocType: Healthcare Settings,Require Lab Test Approval,Vyžadovať schválenie testu laboratória
DocType: Attendance,Working Hours,Pracovní doba
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Total Outstanding,Celkom nevybavené
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.,"Percentuálny podiel, ktorý vám umožňuje vyúčtovať viac oproti objednanej sume. Napríklad: Ak je hodnota objednávky 100 EUR pre položku a tolerancia je nastavená na 10%, potom máte povolené vyúčtovať 110 USD."
DocType: Dosage Strength,Strength,pevnosť
apps/erpnext/erpnext/public/js/controllers/transaction.js,Cannot find Item with this barcode,Položku s týmto čiarovým kódom nemožno nájsť
apps/erpnext/erpnext/accounts/page/pos/pos.js,Create a new Customer,Vytvoriť nového zákazníka
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Expiring On,Vypršanie zapnuté
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,vytvorenie objednávok
,Purchase Register,Nákup Register
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Patient not found,Pacient sa nenašiel
DocType: Landed Cost Item,Applicable Charges,Použitelné Poplatky
DocType: Workstation,Consumable Cost,Spotrebné náklady
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Response Time for {0} at index {1} can't be greater than Resolution Time.,Čas odozvy pre {0} pri indexe {1} nemôže byť dlhší ako čas riešenia.
DocType: Purchase Receipt,Vehicle Date,Dátum Vehicle
DocType: Campaign Email Schedule,Campaign Email Schedule,Časový plán e-mailu kampane
DocType: Student Log,Medical,Lékařský
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Drug,Vyberte Drug
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Lead Owner cannot be same as the Lead,Získateľ Obchodnej iniciatívy nemôže byť to isté ako Obchodná iniciatíva
DocType: Announcement,Receiver,Príjemca
DocType: Location,Area UOM,Oblasť 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,Príležitosti
DocType: Lab Test Template,Single,Slobodný/á
DocType: Compensatory Leave Request,Work From Date,Práca od dátumu
DocType: Salary Slip,Total Loan Repayment,celkové splátky
DocType: Project User,View attachments,Zobraziť prílohy
DocType: Account,Cost of Goods Sold,Náklady na predaj tovaru
DocType: Article,Publish Date,Dátum vydania
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please enter Cost Center,"Prosím, zadajte nákladové stredisko"
DocType: Drug Prescription,Dosage,dávkovanie
DocType: DATEV Settings,DATEV Settings,Nastavenia DATEV
DocType: Journal Entry Account,Sales Order,Predajné objednávky
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Avg. Selling Rate,Avg. Prodej Rate
DocType: Assessment Plan,Examiner Name,Meno Examiner
DocType: Lab Test Template,No Result,žiadny výsledok
DocType: Woocommerce Settings,"The fallback series is ""SO-WOO-"".",Záložná séria je „SO-WOO-“.
DocType: Purchase Invoice Item,Quantity and Rate,Množstvo a Sadzba
DocType: Delivery Note,% Installed,% Inštalovaných
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Company currencies of both the companies should match for Inter Company Transactions.,Spoločné meny oboch spoločností by mali zodpovedať transakciám medzi spoločnosťami.
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Please enter company name first,"Prosím, zadajte najprv názov spoločnosti"
DocType: Travel Itinerary,Non-Vegetarian,Non-vegetariánska
DocType: Purchase Invoice,Supplier Name,Názov dodávateľa
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Read the ERPNext Manual,Prečítajte si ERPNext Manuál
DocType: HR Settings,Show Leaves Of All Department Members In Calendar,Zobraziť listy všetkých členov katedry v kalendári
DocType: Purchase Invoice,01-Sales Return,01-Sales Return
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Qty per BOM Line,Množstvo na riadok kusovníka
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,Temporarily on Hold,Dočasne pozastavené
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} bola vytvorená automaticky
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Request for Raw Materials,Žiadosť o suroviny
DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Automaticky nastaviť sériové čísla na základe FIFO
DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,"Skontrolujte, či dodávateľské faktúry Počet Jedinečnosť"
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js,Primary Address Details,Údaje o primárnej adrese
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Public token is missing for this bank,V tejto banke chýba verejný token
DocType: Vehicle Service,Oil Change,výmena oleja
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Operating Cost as per Work Order / BOM,Prevádzkové náklady podľa objednávky / kusovníka
DocType: Leave Encashment,Leave Balance,Nechajte zostatok
DocType: Asset Maintenance Log,Asset Maintenance Log,Denník údržby majetku
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,'To Case No.' cannot be less than 'From Case No.',"""Do Prípadu č ' nesmie byť menší ako ""Od Prípadu č '"
DocType: Certification Application,Non Profit,Non Profit
DocType: Production Plan,Not Started,Nezahájené
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á oblasť - akademický rok
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Academic Year,Povinná oblasť - akademický rok
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} is not associated with {2} {3},{0} {1} nie je priradená k {2} {3}
DocType: Opportunity,Converted By,Prevedené
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,You need to login as a Marketplace User before you can add any reviews.,Pred pridaním akýchkoľvek recenzií sa musíte prihlásiť ako používateľ Marketplace.
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0} : Operation is required against the raw material item {1},Riadok {0}: Vyžaduje sa operácia proti položke surovín {1}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Transaction not allowed against stopped Work Order {0},Transakcia nie je povolená proti zastavenej pracovnej zákazke {0}
DocType: Setup Progress Action,Min Doc Count,Minimálny počet dokladov
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,Spracovať údaje dennej knihy
DocType: SMS Log,Sent On,Poslané na
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Incoming call from {0},Prichádzajúci hovor od {0}
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute {0} selected multiple times in Attributes Table,Atribút {0} vybraný niekoľkokrát v atribútoch tabuľke
DocType: HR Settings,Employee record is created using selected field. ,Zamestnanecký záznam sa vytvorí použitím vybraného poľa
DocType: Sales Order,Not Applicable,Nehodí se
DocType: Amazon MWS Settings,UK,Spojené kráľovstvo
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Opening Invoice Item,Otvorenie položky faktúry
DocType: Request for Quotation Item,Required Date,Požadovaná data
DocType: Accounts Settings,Billing Address,Fakturačná adresa
DocType: Bank Statement Settings,Statement Headers,Hlavičky vyhlásení
DocType: Travel Request,Costing,Rozpočet
DocType: Tax Rule,Billing County,Fakturačný okres
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,Správa pre dodávateľov
DocType: BOM,Work Order,Zákazka
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
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),Zobraziť na webstránke (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}! Overenie kontrolnej číslice zlyhalo. Skontrolujte, či ste správne zadali {0}."
DocType: Purchase Invoice,Unpaid,Nezaplacený
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sale,Vyhradené pre predaj
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,Riadok # {0}: Na dokončenie transakcie je potrebný platobný 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","Metódu oceňovania nemožno zmeniť, pretože existujú transakcie proti niektorým položkám, ktoré nemajú vlastnú metódu oceňovania"
DocType: Student Report Generation Tool,Attended by Parents,Zúčastnili sa rodičia
apps/erpnext/erpnext/hr/doctype/shift_assignment/shift_assignment.py,Employee {0} has already applied for {1} on {2} : ,Zamestnanec {0} už požiadal o {1} dňa {2}:
DocType: Inpatient Record,AB Positive,AB Pozitívny
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,Nevybavené aktivity pre dnešok
DocType: Salary Structure,Salary Component for timesheet based payroll.,Plat komponentov pre mzdy časového rozvrhu.
DocType: Driver,Applicable for external driver,Platí pre externý ovládač
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 (mena spoločnosti)
DocType: Loan,Total Payment,celkové platby
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Cannot cancel transaction for Completed Work Order.,Pre dokončenú pracovnú zákazku nie je možné zrušiť transakciu.
DocType: Manufacturing Settings,Time Between Operations (in mins),Doba medzi operáciou (v min)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,PO already created for all sales order items,PO už vytvorené pre všetky položky predajnej objednávky
DocType: Healthcare Service Unit,Occupied,obsadený
DocType: Clinical Procedure,Consumables,Spotrebný
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js,Include Default Book Entries,Zahrnúť predvolené 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šená, takže akciu nemožno dokončiť"
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žstvo: Množstvo, pre ktoré bola zadaná pracovná objednávka, ale čaká sa 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.,Vyžadujú sa &#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.,"Suma {0} nastavená v tejto žiadosti o platbu sa líši od vypočítanej sumy všetkých platobných plánov: {1}. Pred odoslaním dokumentu sa uistite, že je to správne."
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 nie sú rovnaké 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,Nemožno nastaviť pole <b>{0}</b> na kopírovanie vo variantoch
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Item Code,Zmeniť kód položky
DocType: Supplier Scorecard Standing,Notify Other,Oznámiť iné
DocType: Vital Signs,Blood Pressure (systolic),Krvný 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),Platnosť doručených listov (dní)
DocType: Training Event,Workshop,Dielňa
DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Upozornenie na nákupné objednávky
DocType: Employee Tax Exemption Proof Submission,Rented From Date,Prenajaté od dátumu
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Enough Parts to Build,Dosť Časti vybudovať
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Please save first,Uložte najskôr
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 sú potrebné na ťahanie surovín, ktoré sú s ňou spojené."
DocType: POS Profile User,POS Profile User,Používateľ profilu POS
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Row {0}: Depreciation Start Date is required,Riadok {0}: Vyžaduje sa dátum začiatku odpisovania
DocType: Purchase Invoice Item,Service Start Date,Dátum začiatku služby
DocType: Subscription Invoice,Subscription Invoice,Faktúra odberu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Income,Priame príjmy
DocType: Patient Appointment,Date TIme,Dátum Čas
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žnosť Kurz
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Course,Vyberte možnosť Kurz
DocType: Codification Table,Codification Table,Kodifikačná tabuľka
DocType: Timesheet Detail,Hrs,hod
apps/erpnext/erpnext/regional/report/datev/datev.py,<b>To Date</b> is a mandatory filter.,<b>Do dnešného dňa</b> je povinný filter.
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Changes in {0},Zmeny v {0}
DocType: Employee Skill,Employee Skill,Zručnosť zamestnancov
DocType: Employee Advance,Returned Amount,Vrátená suma
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Difference Account,Rozdíl účtu
DocType: Pricing Rule,Discount on Other Item,Zľava na inú položku
DocType: Purchase Invoice,Supplier GSTIN,Dodávateľ GSTIN
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,View Form,Zobraziť formulár
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,Kozmetika
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Please select Completion Date for Completed Asset Maintenance Log,Vyberte dátum dokončenia pre dokončený protokol údržby majetku
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} is not the default supplier for any items.,{0} nie je predvoleným dodávateľom žiadnych položiek.
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,Zablokovať dodávateľa
DocType: Shipping Rule,Net Weight,Hmotnost
DocType: Job Opening,Planned number of Positions,Plánovaný počet pozícií
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,kúpiť
,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,Označenie platby
DocType: Supplier,Hold Type,Typ zadržania
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Please define grade for Threshold 0%,Definujte stupeň pre prah 0%
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Please define grade for Threshold 0%,Definujte stupeň pre prah 0%
DocType: Bank Statement Transaction Payment Item,Bank Statement Transaction Payment Item,Platobná položka transakcie v banke
DocType: Sales Order,To Deliver,Dodať
DocType: Purchase Invoice Item,Item,Položka
apps/erpnext/erpnext/healthcare/setup.py,High Sensitivity,Vysoká citlivosť
apps/erpnext/erpnext/config/non_profit.py,Volunteer Type information.,Informácie o type dobrovoľníka.
DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Šablóna mapovania peňažných tokov
DocType: Travel Request,Costing Details,Podrobnosti o kalkulácii
apps/erpnext/erpnext/selling/report/sales_partner_transaction_summary/sales_partner_transaction_summary.js,Show Return Entries,Zobraziť položky návratu
apps/erpnext/erpnext/accounts/page/pos/pos.js,Serial no item cannot be a fraction,Sériovej žiadna položka nemôže byť zlomkom
DocType: Journal Entry,Difference (Dr - Cr),Rozdíl (Dr - Cr)
DocType: Bank Guarantee,Providing,ak
DocType: Account,Profit and Loss,Zisk a strata
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","Ak nie je povolené, nakonfigurujte podľa potreby šablónu Lab Test"
DocType: Patient,Risk Factors,Rizikové faktory
DocType: Patient,Occupational Hazards and Environmental Factors,Pracovné nebezpečenstvo a environmentálne faktory
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Stock Entries already created for Work Order ,Zápisy už boli vytvorené pre pracovnú objednávku
apps/erpnext/erpnext/templates/pages/cart.html,See past orders,Zobraziť minulé objednávky
apps/erpnext/erpnext/public/js/hub/pages/Selling.vue,{0} conversations,{0} konverzácií
DocType: Vital Signs,Respiratory rate,Dýchacia frekvencia
apps/erpnext/erpnext/config/help.py,Managing Subcontracting,Správa Subdodávky
DocType: Vital Signs,Body Temperature,Teplota tela
DocType: Project,Project will be accessible on the website to these users,Projekt bude k dispozícii na webových stránkach k týmto užívateľom
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},"Nie je možné zrušiť {0} {1}, pretože sériové číslo {2} nepatrí do skladu {3}"
DocType: Detected Disease,Disease,choroba
DocType: Company,Default Deferred Expense Account,Predvolený účet odloženého výdavku
apps/erpnext/erpnext/config/projects.py,Define Project type.,Definujte typ projektu.
DocType: Supplier Scorecard,Weighting Function,Funkcia váženia
DocType: Employee Tax Exemption Proof Submission,Total Actual Amount,Celková skutočná suma
DocType: Healthcare Practitioner,OP Consulting Charge,OP Poradenstvo Charge
DocType: Student Report Generation Tool,Show Marks,Zobraziť značky
DocType: Support Settings,Get Latest Query,Získajte najnovší dotaz
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,"Sazba, za kterou Ceník měna je převedena na společnosti základní měny"
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,Skratka už použitý pre inú spoločnosť
DocType: Selling Settings,Default Customer Group,Výchozí Customer Group
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Payment Tems,Platobné podmienky
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,Prebieha transakcia so faktúrami
apps/erpnext/erpnext/erpnext_integrations/exotel_integration.py,Error in Exotel incoming call,Chyba pri prichádzajúcom hovore z exotelu
DocType: Sales Order Item,Gross Profit,Hrubý Zisk
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Unblock Invoice,Odblokovať faktúru
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Increment cannot be 0,Prírastok nemôže byť 0
DocType: Company,Delete Company Transactions,Zmazať transakcie spoločnosti
DocType: Production Plan Item,Quantity and Description,Množstvo 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ý dátum je povinný pre bankové transakcie
DocType: Purchase Receipt,Add / Edit Taxes and Charges,Pridať / Upraviť dane a poplatky
DocType: Payment Entry Reference,Supplier Invoice No,Dodávateľská faktúra č
DocType: Territory,For reference,Pro srovnání
DocType: Healthcare Settings,Appointment Confirmation,Potvrdenie menovania
DocType: Inpatient Record,HLC-INP-.YYYY.-,HLC-INP-.YYYY.-
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot delete Serial No {0}, as it is used in stock transactions","Nemožno odstrániť Poradové číslo {0}, ktorý sa používa na sklade transakciách"
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Closing (Cr),Uzavření (Cr)
DocType: Purchase Invoice,Registered Composition,Registrované zloženie
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html,Hello,Ahoj
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Move Item,Posunúť položku
DocType: Employee Incentive,Incentive Amount,Suma stimuly
,Employee Leave Balance Summary,Zhrnutie stavu zostatku zamestnancov
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á suma kreditnej / debetnej platby by mala byť rovnaká ako prepojená položka denníka
DocType: Installation Note Item,Installation Note Item,Poznámka k instalaci bod
DocType: Production Plan Item,Pending Qty,Čakajúci Množstvo
DocType: Budget,Ignore,Ignorovat
apps/erpnext/erpnext/accounts/party.py,{0} {1} is not active,{0} {1} nie je aktívny
DocType: Woocommerce Settings,Freight and Forwarding Account,Účet pre prepravu a prepravu
apps/erpnext/erpnext/config/accounts.py,Setup cheque dimensions for printing,Skontrolujte nastavenie rozmery pre tlač
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Create Salary Slips,Vytvorte výplatné pásky
DocType: Vital Signs,Bloated,nafúknutý
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 hodnotenie:
DocType: Sales Invoice,Total Commission,Celkem Komise
DocType: Tax Withholding Account,Tax Withholding Account,Zrážkový účet
DocType: Pricing Rule,Sales Partner,Partner predaja
apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Všetky hodnotiace karty dodávateľa.
DocType: Buying Settings,Purchase Receipt Required,Příjmka je vyžadována
DocType: Sales Invoice,Rail,koľajnice
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Skutočné náklady
DocType: Item,Website Image,Obrázok webovej stránky
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Target warehouse in row {0} must be same as Work Order,Cieľový sklad v riadku {0} musí byť rovnaký ako pracovná zákazka
apps/erpnext/erpnext/stock/doctype/item/item.py,Valuation Rate is mandatory if Opening Stock entered,"Ocenenie Rate je povinné, ak zadaná počiatočným stavom 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",Už bolo nastavené predvolené nastavenie profilu {0} pre používateľa {1}
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,neuhradená Hodnoty
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot delete item {1} which has already been delivered,"Riadok # {0}: Nedá sa odstrániť položka {1}, ktorá už bola doručená"
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ákaznícka skupina nastaví vybranú skupinu pri synchronizácii zákazníkov so službou Shopify
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Territory is Required in POS Profile,Územie je vyžadované v POS profile
DocType: Supplier,Prevent RFQs,Zabráňte RFQ
DocType: Hub User,Hub User,Používateľ Hubu
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Salary Slip submitted for period from {0} to {1},Zápis platu bol odoslaný na obdobie od {0} do {1}
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Passing Score value should be between 0 and 100,Hodnota úspešného skóre by mala byť medzi 0 a 100
DocType: Loyalty Point Entry Redemption,Redeemed Points,Vymožené body
,Lead Id,Id Obchodnej iniciatívy
DocType: C-Form Invoice Detail,Grand Total,Celkem
DocType: Assessment Plan,Course,kurz
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Section Code,Kód sekcie
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Valuation Rate required for Item {0} at row {1},Sadzba ocenenia požadovaná pre položku {0} v riadku {1}
DocType: Timesheet,Payslip,výplatná páska
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Pricing Rule {0} is updated,Pravidlo tvorby cien {0} je aktualizované
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Half day date should be in between from date and to date,Dátum pol dňa by mal byť medzi dňom a dňom
DocType: POS Closing Voucher,Expense Amount,Suma výdavkov
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ánovania kapacity, plánovaný čas začiatku nemôže byť rovnaký ako čas ukončenia"
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,ID členstva
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Receive at Warehouse Entry,Prijať pri vstupe do skladu
apps/erpnext/erpnext/templates/pages/material_request_info.html,Delivered: {0},Dodáva: {0}
DocType: QuickBooks Migrator,Connected to QuickBooks,Pripojené k QuickBooks
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please identify/create Account (Ledger) for type - {0},Identifikujte / vytvorte účet (kniha) pre 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ý dátum je povinný
DocType: Sales Order,Billing and Delivery Status,Stav fakturácie a dodania
DocType: Job Applicant,Resume Attachment,Resume Attachment
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customers,Verní zákazníci
DocType: Leave Control Panel,Allocate,Přidělit
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variant,Vytvoriť variant
DocType: Sales Invoice,Shipping Bill Date,Dátum zasielania účtov
DocType: Production Plan,Production Plan,Výrobný plán
DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Otvorenie nástroja na tvorbu faktúr
DocType: Salary Component,Round to the Nearest Integer,Zaokrúhlite na najbližšie celé číslo
DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,"Nechajte položky, ktoré nie sú na sklade, pridať do košíka"
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,Voliť množstvo v transakciách na základe vybratého sériového čísla
,Total Stock Summary,Súhrnné zhrnutie zásob
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ánovať až {0} voľné pracovné miesta a rozpočet {1} \ pre {2} podľa personálneho plánu {3} pre materskú spoločnosť {4}.
DocType: Announcement,Posted By,Pridané
apps/erpnext/erpnext/controllers/stock_controller.py,Quality Inspection required for Item {0} to submit,"Vyžaduje sa kontrola kvality, aby sa položka {0} mohla predložiť"
DocType: Item,Delivered by Supplier (Drop Ship),Dodáva Dodávateľom (Drop Ship)
DocType: Healthcare Settings,Confirmation Message,Potvrdzujúca sprá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 alebo položka
apps/erpnext/erpnext/config/accounts.py,Customer database.,Databáza zákazníkov
DocType: Quotation,Quotation To,Ponuka 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ýchodzí merná jednotka bodu {0} nemôže byť zmenená priamo, pretože ste už nejaké transakcie (y) s iným nerozpustených. Budete musieť vytvoriť novú položku použiť iný predvolený UOM."
DocType: Purchase Invoice,Overseas,zámoria
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Please set the Company,Nastavte spoločnosť
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Please set the Company,Nastavte spoločnosť
DocType: Share Balance,Share Balance,Zostatok na účtoch
DocType: Amazon MWS Settings,AWS Access Key ID,Identifikátor prístupového kľúča AWS
DocType: Production Plan,Download Required Materials,Stiahnite si požadované materiály
DocType: Employee Tax Exemption Declaration,Monthly House Rent,Mesačný prenájom domu
apps/erpnext/erpnext/projects/doctype/task/task_list.js,Set as Completed,Nastaviť ako dokončené
DocType: Purchase Order Item,Billed Amt,Fakturovaná čiastka
DocType: Training Result Employee,Training Result Employee,vzdelávacie Výsledok
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,istina
DocType: Loan Application,Total Payable Interest,Celková splatný úrok
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Outstanding: {0},Celkom nevybavené: {0}
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Open Contact,Otvorte kontakt
DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Predajná faktúry č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 (-a) požadované pre serializovanú položku {0}
DocType: Payroll Entry,Select Payment Account to make Bank Entry,"Vybrať Platobný účet, aby Bank Entry"
apps/erpnext/erpnext/config/accounts.py,Opening and Closing,Otváranie a zatváranie
DocType: Hotel Settings,Default Invoice Naming Series,Predvolená séria pomenovaní faktúr
apps/erpnext/erpnext/utilities/activation.py,"Create Employee records to manage leaves, expense claims and payroll","Vytvoriť Zamestnanecké záznamy pre správu listy, vyhlásenia o výdavkoch a miezd"
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,An error occurred during the update process,Počas procesu aktualizácie sa vyskytla chyba
DocType: Restaurant Reservation,Restaurant Reservation,Rezervácia reštaurácie
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 dedukcie
DocType: Service Level Priority,Service Level Priority,Priorita na úrovni služby
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Wrapping up,Zahaliť
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Notify Customers via Email,Informujte zákazníkov prostredníctvom e-mailu
DocType: Item,Batch Number Series,Číselná séria šarží
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,Another Sales Person {0} exists with the same Employee id,Ďalšia predaja osoba {0} existuje s rovnakým id zamestnanca
DocType: Employee Advance,Claimed Amount,Požadovaná suma
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.js,Expire Allocation,Skončí platnosť pridelenia
DocType: QuickBooks Migrator,Authorization Settings,Nastavenia autorizácie
DocType: Travel Itinerary,Departure Datetime,Dátum odchodu
apps/erpnext/erpnext/hub_node/api.py,No items to publish,Žiadne položky na zverejnenie
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Please select Item Code first,Najskôr vyberte kód položky
DocType: Customer,CUST-.YYYY.-,CUST-.YYYY.-
DocType: Travel Request Costing,Travel Request Costing,Kalkulácia požiadaviek na cesty
apps/erpnext/erpnext/config/healthcare.py,Masters,Masters
DocType: Employee Onboarding,Employee Onboarding Template,Šablóna zamestnancov na palube
DocType: Assessment Plan,Maximum Assessment Score,Maximálne skóre Assessment
apps/erpnext/erpnext/config/accounts.py,Update Bank Transaction Dates,Transakčné Data aktualizácie Bank
apps/erpnext/erpnext/config/projects.py,Time Tracking,Time Tracking
DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLIKÁT PRE TRANSPORTER
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Row {0}# Paid Amount cannot be greater than requested advance amount,Riadok {0} # zaplatená čiastka nemôže byť väčšia ako požadovaná suma vopred
DocType: Fiscal Year Company,Fiscal Year Company,Spoločnosť pre fiškálny rok
DocType: Packing Slip Item,DN Detail,DN Detail
DocType: Training Event,Conference,konferencie
DocType: Employee Grade,Default Salary Structure,Štandardná platová štruktúra
DocType: Stock Entry,Send to Warehouse,Odoslať do skladu
apps/erpnext/erpnext/hr/report/daily_work_summary_replies/daily_work_summary_replies.py,Replies,odpovede
DocType: Timesheet,Billed,Fakturované
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áranie študentských skupín
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Creating student groups,Vytváranie študentských skupín
apps/erpnext/erpnext/accounts/utils.py,"Payment Gateway Account not created, please create one manually.","Platobná brána účet nevytvorili, prosím, vytvorte ručne."
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,Nie je oprávnený na prijatie do tohto programu podľa DOB
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot delete item {1} which is assigned to customer's purchase order.,"Riadok # {0}: Nie je možné odstrániť položku {1}, ktorá je priradená k objednávke zákazníka."
DocType: Sales Invoice,Sales Taxes and Charges,Dane z predaja a poplatky
DocType: Supplier Scorecard Period,PU-SSP-.YYYY.-,PU-SSP-.YYYY.-
DocType: Vital Signs,Height (In Meter),Výška (v metre)
DocType: Student,Sibling Details,súrodenec Podrobnosti
DocType: Vehicle Service,Vehicle Service,servis vozidiel
DocType: Employee,Reason for Resignation,Dôvod rezignácie
DocType: Sales Invoice,Credit Note Issued,dobropisu vystaveného
DocType: Task,Weight,váha
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Faktura / Zápis do deníku Podrobnosti
apps/erpnext/erpnext/accounts/utils.py,{0} '{1}' not in Fiscal Year {2},{0} '{1}' nie je vo fiškálnom roku {2}
DocType: Buying Settings,Settings for Buying Module,Nastavenie pre modul Nákupy
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Asset {0} does not belong to company {1},Aktíva {0} nepatrí do spoloč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,Pomenovanie dodávateľa podľa
DocType: Activity Type,Default Costing Rate,Predvolená sadzba kalkulácie nákladov
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 podpore zamestnancov
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Inventory,Čistá Zmena stavu zásob
DocType: Employee,Passport Number,Číslo pasu
DocType: Invoice Discounting,Accounts Receivable Credit Account,Úverový účet pohľadávok
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian2,Súvislosť s Guardian2
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Manager,Manažér
DocType: Payment Entry,Payment From / To,Platba od / do
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,From Fiscal Year,Od fiškálneho roka
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ý úverový limit je nižšia ako aktuálna dlžnej čiastky za zákazníka. Úverový limit musí byť aspoň {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please set account in Warehouse {0},Nastavte si účet v službe Warehouse {0}
apps/erpnext/erpnext/controllers/trends.py,'Based On' and 'Group By' can not be same,"""Založené na"" a ""Zoskupené podľa"", nemôžu byť rovnaké"
DocType: Sales Person,Sales Person Targets,Obchodnícke ciele
DocType: GSTR 3B Report,December,December
DocType: Work Order Operation,In minutes,V minútach
apps/erpnext/erpnext/templates/pages/cart.html,See past quotations,Zobraziť minulé ponuky
DocType: Issue,Resolution Date,Rozlišení Datum
DocType: Lab Test Template,Compound,zlúčenina
DocType: Opportunity,Probability (%),Pravdepodobnosť (%)
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Dispatch Notification,Oznámenie o doručení
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Select Property,Vyberte položku Vlastníctvo
DocType: Course Activity,Course Activity,Aktivita kurzu
DocType: Student Batch Name,Batch Name,Názov šarže
DocType: Fee Validity,Max number of visit,Maximálny počet návštev
DocType: Accounting Dimension Detail,Mandatory For Profit and Loss Account,Povinné pre účet ziskov a strá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,zapísať
DocType: GST Settings,GST Settings,Nastavenia GST
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Currency should be same as Price List Currency: {0},Mena by mala byť rovnaká ako mena cenníka: {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 na študenta bol prítomný v Student mesačnú návštevnosť Správa
DocType: Depreciation Schedule,Depreciation Amount,Suma odpisov
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to Group,Previesť na skupinu
DocType: Activity Cost,Activity Type,Druh činnosti
DocType: Request for Quotation,For individual supplier,Pre jednotlivé dodávateľa
DocType: Workstation,Production Capacity,Výrobná kapacita
DocType: BOM Operation,Base Hour Rate(Company Currency),Základňa hodinová sadzba (Company meny)
,Qty To Be Billed,Množstvo na vyúčtovanie
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Dodaná Čiastka
DocType: Coupon Code,Gift Card,Darčeková karta
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Vyhradené množstvo pre výrobu: Množstvo surovín na výrobu výrobných položiek.
DocType: Loyalty Point Entry Redemption,Redemption Date,Dátum vykúpenia
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Táto banková transakcia je už úplne vyrovnaná
DocType: Sales Invoice,Packing List,Zoznam balenia
apps/erpnext/erpnext/config/buying.py,Purchase Orders given to Suppliers.,Nákupní Objednávky odeslané Dodavatelům.
DocType: Contract,Contract Template,Šablóna zmluvy
DocType: Clinical Procedure Item,Transfer Qty,Množstvo prenosu
DocType: Purchase Invoice Item,Asset Location,Umiestnenie majetku
apps/erpnext/erpnext/projects/report/billing_summary.py, From Date can not be greater than To Date,Od dátumu nemôže byť väčšie ako do dátumu
DocType: Tax Rule,Shipping Zipcode,Prepravný PSČ
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Publishing,Zverejnenie
DocType: Accounts Settings,Report Settings,Nastavenia prehľadov
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} nenájdené v tabuľke Podrobnosti Faktúry
DocType: Asset,Asset Owner Company,Spoločnosť vlastníka aktív
DocType: Company,Round Off Cost Center,Zaokrúhliť nákladové stredisko
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 potrebujete pomôcť?
DocType: Employee Checkin,Shift Start,Shift Start
DocType: Appointment Booking Settings,Availability Of Slots,Dostupnosť automatov
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 strediska
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py,Could not find path for ,Nepodarilo sa nájsť cestu pre
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Dr),Opening (Dr)
DocType: Compensatory Leave Request,Work End Date,Dátum ukončenia práce
DocType: Loan,Applicant,žiadateľ
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,Registrovaný nákupný register spoločnosti GST
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is a limited liability company,"Uplatniteľné, ak je spoločnosť spoločnosť s ručením obmedzeným"
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py,Expected and Discharge dates cannot be less than Admission Schedule date,Očakávané a dátumy absolutória nemôžu byť kratšie ako dátum plánovania prijatia
DocType: Course Scheduling Tool,Reschedule,presunúť
DocType: Item Tax Template,Item Tax Template,Šablóna dane z položky
DocType: Loan,Total Interest Payable,Celkové úroky splatné
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for Hold,Dôvod pozastavenia
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,Riadok {0}: V Dane z obratu a poplatkoch nastavte prosím na dôvod oslobodenia od dane
DocType: Quality Goal Objective,Quality Goal Objective,Cieľ 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,Provozní doba
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Finish,Skončiť
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Base,Základ
DocType: Timesheet,Total Billed Hours,Celkom Predpísané Hodiny
DocType: Pricing Rule Item Group,Pricing Rule Item Group,Skupina položiek cenových pravidiel
DocType: Travel Itinerary,Travel To,Cestovať do
apps/erpnext/erpnext/config/accounts.py,Exchange Rate Revaluation master.,Master preceňovacieho kurzu.
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Nastavte číslovaciu sériu pre účasť cez Nastavenie&gt; Číslovacie série
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 / straty na majetku likvidáciu
DocType: Vehicle Log,Service Details,Podrobnosti o službe
DocType: Vehicle Log,Service Details,Podrobnosti o službe
DocType: Lab Test Template,Grouped,zoskupené
DocType: Selling Settings,Delivery Note Required,Dodací list povinný
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Submitting Salary Slips...,Odoslanie platových kariet ...
DocType: Bank Guarantee,Bank Guarantee Number,Číslo bankovej záruky
DocType: Bank Guarantee,Bank Guarantee Number,Číslo bankovej záruky
DocType: Assessment Criteria,Assessment Criteria,Kritériá hodnotenia
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",Pri vytváraní účtu pre detskú spoločnosť {0} sa rodičovský účet {1} nenašiel. Vytvorte nadradený účet v príslušnom COA
apps/erpnext/erpnext/support/doctype/issue/issue.js,Split Issue,Split Issue
DocType: Student Attendance,Student Attendance,študent Účasť
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,No data to export,Žiadne údaje na export
DocType: Sales Invoice Timesheet,Time Sheet,Časový rozvrh
DocType: Manufacturing Settings,Backflush Raw Materials Based On,So spätným suroviny na základe
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,Vedenie je organizácia
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Return amount cannot be greater unclaimed amount,Čiastka vrátenia nemôže byť väčšia nevyžiadaná suma
DocType: Guardian Interest,Interest,záujem
apps/erpnext/erpnext/accounts/doctype/tax_category/tax_category_dashboard.py,Pre Sales,Predpredaj
DocType: Instructor Log,Other Details,Ďalšie podrobnosti
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Suplier,Dodávateľ
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Actual Delivery Date,Skutočný dátum dodania
DocType: Lab Test,Test Template,Šablóna testu
DocType: Restaurant Order Entry Item,Served,slúžil
apps/erpnext/erpnext/config/non_profit.py,Chapter information.,Informácie o kapitole.
DocType: Account,Accounts,Účty
DocType: Vehicle,Odometer Value (Last),Hodnota počítadla kilometrov (Last)
apps/erpnext/erpnext/config/buying.py,Templates of supplier scorecard criteria.,Šablóny kritérií kritérií pre dodávateľa.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Marketing,Marketing
DocType: Sales Invoice,Redeem Loyalty Points,Uplatnite vernostné body
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry is already created,Vstup Platba je už vytvorili
DocType: Request for Quotation,Get Suppliers,Získajte dodávateľov
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ýšenie alebo zníženie množstva alebo množstva
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Preview Salary Slip,Preview výplatnej páske
apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Vytvorenie časového rozvrhu
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Účet {0} bol zadaný viackrát
DocType: Account,Expenses Included In Valuation,Náklady ceně oceňování
apps/erpnext/erpnext/hooks.py,Purchase Invoices,Nákup faktúr
apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,"Môžete obnoviť iba vtedy, ak vaše členstvo uplynie do 30 dní"
DocType: Shopping Cart Settings,Show Stock Availability,Zobraziť dostupnosť zásob
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Nastavte {0} v kategórii majetku {1} alebo v spoločnosti {2}
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per section 17(5),Podľa oddielu 17 ods. 5
DocType: Location,Longitude,zemepisná dĺžka
,Absent Student Report,Absent Študent Report
DocType: Crop,Crop Spacing UOM,Rozmiestnenie medzných plôch
DocType: Loyalty Program,Single Tier Program,Jednoduchý program
DocType: Woocommerce Settings,Delivery After (Days),Dodanie po (dňoch)
DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,"Vyberte len, ak máte nastavené dokumenty Mapper 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ýždeň
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 študentov
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Item {0} not found,Položka {0} nebyl nalezen
DocType: Bin,Stock Value,Hodnota na zásobách
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Duplicate {0} found in the table,V tabuľke sa našlo duplikát {0}
apps/erpnext/erpnext/accounts/doctype/account/account.py,Company {0} does not exist,Spoločnosť {0} neexistuje
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} has fee validity till {1},{0} má platnosť do {1}
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Tree Type,Tree Type
DocType: Leave Control Panel,Employee Grade (optional),Trieda zamestnanca (voliteľné)
DocType: Pricing Rule,Apply Rule On Other,Použiť pravidlo na iné
DocType: BOM Explosion Item,Qty Consumed Per Unit,Množství spotřebované na jednotku
DocType: Shift Type,Late Entry Grace Period,Obdobie odkladu vstupu
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žstvo a sklad
DocType: Sales Invoice,Commission Rate (%),Výška provízie (%)
DocType: Asset,Allow Monthly Depreciation,Povoliť mesačné odpisy
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Program,Vyberte program
DocType: Project,Estimated Cost,odhadované náklady
DocType: Supplier Quotation,Link to material requests,Odkaz na materiálnych požiadaviek
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Publish,publikovať
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.,Faktúry pre zákazníkov.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,In Value,v Hodnota
DocType: Asset Category,Depreciation Options,Možnosti odpisovania
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Either location or employee must be required,"Musí sa vyžadovať buď umiestnenie, alebo zamestnanec"
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Create Employee,Vytvorte zamestnanca
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid Posting Time,Neplatný čas odoslania
DocType: Salary Component,Condition and Formula,Podmienka a vzorec
DocType: Lead,Campaign Name,Názov kampane
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Task Completion,Pri dokončení úlohy
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,There is no leave period in between {0} and {1},Neexistuje žiadne obdobie dovolenky medzi {0} a {1}
DocType: Fee Validity,Healthcare Practitioner,Zdravotnícky lekár
DocType: Hotel Room,Capacity,kapacita
DocType: Travel Request Costing,Expense Type,Typ výdavkov
DocType: Selling Settings,Close Opportunity After Days,Close Opportunity po niekoľkých dňoch
,Reserved,Rezervováno
DocType: Driver,License Details,Detaily licencie
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field From Shareholder cannot be blank,Pole od akcionára nesmie byť prázdne
DocType: Leave Allocation,Allocation,Pridelenie
DocType: Purchase Order,Supply Raw Materials,Dodávok surovín
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Structures have been assigned successfully,Štruktúry boli úspešne priradené
apps/erpnext/erpnext/config/getting_started.py,Create Opening Sales and Purchase Invoices,Vytvorte otváracie predajné a nákupné faktúry
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} nie je 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',Zdieľajte svoje pripomienky k tréningu kliknutím na &quot;Odborná pripomienka&quot; a potom na &quot;Nové&quot;
DocType: Call Log,Caller Information,Informácie o volajúcom
DocType: Mode of Payment Account,Default Account,Východzí účet
apps/erpnext/erpnext/stock/doctype/item/item.py,Please select Sample Retention Warehouse in Stock Settings first,Najskôr vyberte položku Sample Retention Warehouse in Stock Stock Settings
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,Please select the Multiple Tier Program type for more than one collection rules.,Vyberte typ viacvrstvového programu pre viac ako jednu pravidlá kolekcie.
DocType: Payment Entry,Received Amount (Company Currency),Prijatá suma (v peňažnej mene firmy)
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Cancelled. Please check your GoCardless Account for more details,Platba bola zrušená. Skontrolujte svoj účet GoCardless pre viac informácií
DocType: Work Order,Skip Material Transfer to WIP Warehouse,Preskočiť prenos materiálu do skladu WIP
DocType: Contract,N/A,N / A
DocType: Task Type,Task Type,Typ úlohy
DocType: Topic,Topic Content,Obsah témy
DocType: Delivery Settings,Send with Attachment,Odoslať s prí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 Negatívny
DocType: Work Order Operation,Planned End Time,Plánované End Time
DocType: POS Profile,Only show Items from these Item Groups,Zobrazovať iba položky z týchto skupín položiek
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 členstve typu
DocType: Delivery Note,Customer's Purchase Order No,Zákazníka Objednávka No
DocType: Clinical Procedure,Consume Stock,Spotreba akcií
DocType: Budget,Budget Against,rozpočet Proti
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Lost Reasons,Stratené dôvody
apps/erpnext/erpnext/stock/reorder_item.py,Auto Material Requests Generated,Žiadosti Auto materiál vygenerovaný
DocType: Shift Type,Working hours below which Half Day is marked. (Zero to disable),"Pracovné hodiny, pod ktorými je vyznačený poldeň. (Nulovanie na deaktiváciu)"
DocType: Job Card,Total Completed Qty,Celkom dokončené množstvo
DocType: HR Settings,Auto Leave Encashment,Automatické opustenie 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álna výška dávky
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for manufacturing,Vyhradené pre výrobu
DocType: Soil Texture,Sand,piesok
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}.,Riadok {0}: {1} Sériové čísla vyžadované pre položku {2}. Poskytli ste {3}.
apps/erpnext/erpnext/controllers/accounts_controller.py,Cannot set quantity less than delivered quantity,Nie je možné nastaviť menšie množstvo ako dodané množstvo
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please select a table,Vyberte tabuľku
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,Pridajte účet do koreňovej úrovne spoločnosti -% s
DocType: Content Activity,Content Activity,Obsahová aktivita
DocType: Special Test Items,Particulars,podrobnosti
DocType: Employee Checkin,Employee Checkin,Kontrola zamestnancov
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,Pošle e-maily na vedenie alebo kontakt na základe plánu kampane
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}","Viac Cena pravidlá existuje u rovnakých kritérií, prosím vyriešiť konflikt tým, že priradí prioritu. Cena Pravidlá: {0}"
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation Account,Účet z precenenia výmenného kurzu
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Min Amt can not be greater than Max Amt,Minimálny Amt nesmie byť väčší ako 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,Zvoľte Spoločnosť a dátum odoslania na zadanie záznamov
DocType: Asset,Maintenance,Údržba
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Get from Patient Encounter,Získajte od stretnutia s pacientmi
DocType: Subscriber,Subscriber,predplatiteľ
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.,Výmena peňazí musí byť uplatniteľná pri kúpe alebo predaji.
apps/erpnext/erpnext/hr/doctype/leave_ledger_entry/leave_ledger_entry.py,Only expired allocation can be cancelled,"Zrušiť možno len pridelené prostriedky, ktorých platnosť vypršala"
DocType: Item,Maximum sample quantity that can be retained,"Maximálne množstvo vzorky, ktoré možno uchovať"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Riadok {0} # Položka {1} nemožno previesť viac ako {2} do objednávky {3}
apps/erpnext/erpnext/config/crm.py,Sales campaigns.,Predajné kampane
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Unknown Caller,Neznámy volajúci
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žiaky UIN
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Ordered,čiastočne usporiadané
DocType: Lab Test,Lab Test,Laboratórny test
DocType: Student Report Generation Tool,Student Report Generation Tool,Nástroj na generovanie správ študentov
DocType: Healthcare Schedule Time Slot,Healthcare Schedule Time Slot,Časový rozvrh časového harmonogramu zdravotnej starostlivosti
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,Predvolené nastavenia pre Košík
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Save Item,Uložiť položku
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Expense,Nové výdavky
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Ignore Existing Ordered Qty,Ignorovať existujúce objednané množstvo
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Timeslots,Pridať Timeslots
apps/erpnext/erpnext/stock/__init__.py,Please set Account in Warehouse {0} or Default Inventory Account in Company {1},Nastavte účet vo Warehouse {0} alebo predvolený účet inventára v spoločnosti {1}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset scrapped via Journal Entry {0},Asset vyhodený cez položka denníka {0}
DocType: Loan,Interest Income Account,Účet Úrokové výnosy
DocType: Bank Transaction,Unreconciled,nezmierilo
DocType: Shift Type,Allow check-out after shift end time (in minutes),Povoliť odhlásenie po čase ukončenia zmeny (v minútach)
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Max benefits should be greater than zero to dispense benefits,"Maximálne prínosy by mali byť väčšie ako nula, aby sa vylúčili prínosy"
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py,Review Invitation Sent,Recenzia pozvánky odoslaná
DocType: Shift Assignment,Shift Assignment,Presunutie posunu
DocType: Employee Transfer Property,Employee Transfer Property,Vlastníctvo prevodu zamestnancov
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field Equity/Liability Account cannot be blank,Pole Účet vlastného imania / zodpovednosti nemôže byť prázdne
apps/erpnext/erpnext/accounts/doctype/cashier_closing/cashier_closing.py,From Time Should Be Less Than To Time,Čas by mal byť menej ako č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}) sa nedá vyčerpať tak, ako je vynaložené, \ splnenie objednávky odberateľa {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,Prieskumník kusovníka
DocType: Shopify Settings,Update Price from Shopify To ERPNext Price List,Aktualizovať cenu z Shopify do ERPNext Cenník
apps/erpnext/erpnext/config/help.py,Setting up Email Account,Nastavenie e-mailového konta
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Please enter Item first,"Prosím, najprv zadajte položku"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Needs Analysis,Analýza potrieb
DocType: Asset Repair,Downtime,prestoje
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}.,Sankcionovaná Čiastka nemôže byť väčšia ako reklamácia Suma v riadku {0}.
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Academic Term: ,Akademický termín:
DocType: Salary Detail,Do not include in total,Nezaradenie celkom
DocType: Quiz Activity,Quiz Activity,Kvízová aktivita
DocType: Company,Default Cost of Goods Sold Account,Východiskové Náklady na predaný tovar účte
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Sample quantity {0} cannot be more than received quantity {1},Množstvo vzorky {0} nemôže byť väčšie ako prijaté množstvo {1}
DocType: Employee,Family Background,Rodinné pomery
DocType: Request for Quotation Supplier,Send Email,Odoslať email
DocType: Quality Goal,Weekday,všedný deň
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid Attachment {0},Varovanie: Neplatná Príloha {0}
DocType: Item,Max Sample Quantity,Max. Množstvo vzoriek
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,No Permission,Nemáte oprávnenie
DocType: Contract Fulfilment Checklist,Contract Fulfilment Checklist,Kontrolný zoznam plnenia zmluvy
DocType: Vital Signs,Heart Rate / Pulse,Srdcová frekvencia / pulz
DocType: Supplier,Default Bank Account,Prednastavený Bankový účet
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"To filter based on Party, select Party Type first","Ak chcete filtrovať na základe Party, vyberte typ Party prvý"
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,'Update Stock' can not be checked because items are not delivered via {0},"""Aktualizovať Sklad ' nie je možné skontrolovať, pretože položky nie sú dodané cez {0}"
DocType: Vehicle,Acquisition Date,akvizície Dátum
apps/erpnext/erpnext/regional/italy/utils.py,Nos,Balenie
DocType: Item,Items with higher weightage will be shown higher,Položky s vyšším weightage budú zobrazené vyššie
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py,Lab Tests and Vital Signs,Laboratórne testy a vitálne znaky
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,The following serial numbers were created: <br><br> {0},Boli vytvorené nasledujúce sériové čísla: <br><br> {0}
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Detail bankového odsúhlasenia
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,No employee found,Nenájdený žiadny zamestnanec
DocType: Item,If subcontracted to a vendor,Ak sa subdodávky na dodávateľa
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Student Group is already updated.,Skupina študentov je už aktualizovaná.
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Student Group is already updated.,Skupina študentov je už aktualizovaná.
DocType: HR Settings,Restrict Backdated Leave Application,Obmedzte aplikáciu neaktuálnej dovolenky
apps/erpnext/erpnext/config/projects.py,Project Update.,Aktualizácia projektu.
DocType: SMS Center,All Customer Contact,Všetky Kontakty Zákazníka
DocType: Location,Tree Details,Tree Podrobnosti
DocType: Marketplace Settings,Registered,registrovaný
DocType: Training Event,Event Status,event Status
DocType: Volunteer,Availability Timeslot,Dostupnosť 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.","Ak máte akékoľvek otázky, obráťte sa na nás."
DocType: Cash Flow Mapper,Cash Flow Mapper,Mapovač hotovostných tokov
DocType: Item,Website Warehouse,Sklad pro web
DocType: Payment Reconciliation,Minimum Invoice Amount,Minimálna suma faktúry
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} nepatrí do spoloč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 byť skupina
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Timesheet {0} is already completed or cancelled,Harmonogramu {0} je už dokončená alebo zrušená
DocType: QuickBooks Migrator,QuickBooks Migrator,QuickBooks Migrator
apps/erpnext/erpnext/templates/pages/projects.html,No tasks,žiadne úlohy
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Sales Invoice {0} created as paid,Faktúra predaja {0} bola vytvorená ako zaplatená
DocType: Item Variant Settings,Copy Fields to Variant,Kopírovať polia na variant
DocType: Asset,Opening Accumulated Depreciation,otvorenie 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 už existujú
apps/erpnext/erpnext/config/help.py,Customer and Supplier,Zákazník a Dodávateľ
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!,Ďakujeme vám za vašu firmu!
apps/erpnext/erpnext/config/support.py,Support queries from customers.,Podpora dotazy ze strany zákazníků.
DocType: Employee Property History,Employee Property History,História vlastníctva zamestnancov
apps/erpnext/erpnext/stock/doctype/item/item.py,Variant Based On cannot be changed,Variant Based On sa nedá zmeniť
DocType: Setup Progress Action,Action Doctype,Akcia Doctype
DocType: HR Settings,Retirement Age,dôchodkový vek
DocType: Bin,Moving Average Rate,Klouzavý průměr
DocType: Share Transfer,To Shareholder,Akcionárovi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Bill {1} dated {2},{0} proti účtu {1} z dňa {2}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From State,Z štátu
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Allocating leaves...,Prideľovanie listov ...
DocType: Program Enrollment,Vehicle/Bus Number,Číslo vozidla / autobusu
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Create New Contact,Vytvoriť nový kontakt
apps/erpnext/erpnext/education/doctype/course/course.js,Course Schedule,rozvrh
DocType: GSTR 3B Report,GSTR 3B Report,Správa GSTR 3B
DocType: Request for Quotation Supplier,Quote Status,Citácia 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á suma platieb nemôže byť vyššia ako {}
DocType: Daily Work Summary Group,Select Users,Vyberte používateľov
DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,Položka ceny izieb hotela
DocType: Loyalty Program Collection,Tier Name,Názov úrovne
DocType: HR Settings,Enter retirement age in years,Zadajte vek odchodu do dôchodku v rokoch
DocType: Job Card,PO-JOB.#####,PO-JOB. #####
DocType: Crop,Target Warehouse,Target Warehouse
DocType: Payroll Employee Detail,Payroll Employee Detail,Mzdový detail zamestnancov
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select a warehouse,Vyberte si sklad
DocType: Cheque Print Template,Starting location from left edge,Počnúc umiestnenie od ľavého okraja
,Territory Target Variance Based On Item Group,Variant teritoriálneho cieľa na základe skupiny položiek
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,Bod K výrobě
DocType: Leave Control Panel,Employment Type (optional),Druh zamestnania (voliteľné)
DocType: Pricing Rule,Threshold for Suggestion,Prahová hodnota návrhu
apps/erpnext/erpnext/buying/utils.py,{0} {1} status is {2},{0} {1} stav je {2}
DocType: Water Analysis,Collection Temperature ,Teplota zberu
DocType: Employee,Provide Email Address registered in company,Poskytnúť e-mailovú adresu registrovanú vo firme
DocType: Shopping Cart Settings,Enable Checkout,aktivovať Checkout
apps/erpnext/erpnext/config/help.py,Purchase Order to Payment,Objednávka na platobné
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Projected Qty,Předpokládané množství
DocType: Sales Invoice,Payment Due Date,Splatné dňa
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 zvoľte, ak je zvolená adresa upravená po uložení"
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant {0} already exists with same attributes,Variant Položky {0} už existuje s rovnakými vlastnosťami
DocType: Item,Hub Publishing Details,Podrobnosti o publikovaní Hubu
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,'Opening',"""Otváranie"""
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open To Do,otvorená robiť
DocType: Pricing Rule,Mixed Conditions,Zmiešané podmienky
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Summary Saved,Súhrn hovorov bol uložený
DocType: Issue,Via Customer Portal,Prostredníctvom zákazníckeho portálu
DocType: Employee Tax Exemption Proof Submission Detail,Actual Amount,Skutočná suma
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,SGST Amount,Suma SGST
DocType: Lab Test Template,Result Format,Formát výsledkov
DocType: Expense Claim,Expenses,Výdaje
DocType: Service Level,Support Hours,Čas podpory
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Delivery Notes,Dodacie listy
DocType: Item Variant Attribute,Item Variant Attribute,Vlastnosť Variantu Položky
,Purchase Receipt Trends,Doklad o koupi Trendy
DocType: Payroll Entry,Bimonthly,dvojmesačne
DocType: Vehicle Service,Brake Pad,Brzdová doštička
DocType: Fertilizer,Fertilizer Contents,Obsah hnojiva
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áklade platobných podmienok
apps/erpnext/erpnext/config/settings.py,ERPNext Settings,ERPĎalšie nastavenia
DocType: Company,Registration Details,Registrace Podrobnosti
apps/erpnext/erpnext/support/doctype/issue/issue.py,Couldn't Set Service Level Agreement {0}.,Nepodarilo sa nastaviť dohodu o úrovni služieb {0}.
DocType: Timesheet,Total Billed Amount,Celková suma Fakturovaný
DocType: Item Reorder,Re-Order Qty,Doobjednacie množstvo
DocType: Leave Block List Date,Leave Block List Date,Nechte Block List Datum
DocType: Quality Feedback Parameter,Quality Feedback Parameter,Parameter spätnej väzby kvality
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM #{0}: Raw material cannot be same as main Item,BOM # {0}: Surovina nemôže byť rovnaká ako 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,"Celkom Použiteľné Poplatky v doklade o kúpe tovaru, ktorý tabuľky musí byť rovnaká ako celkom daní a poplatkov"
DocType: Production Plan Item,"If enabled, system will create the work order for the exploded items against which BOM is available.","Ak je povolený, systém vytvorí pracovný príkaz pre rozložené položky, proti ktorým je kusovník k dispozícii."
DocType: Sales Team,Incentives,Pobídky
apps/erpnext/erpnext/accounts/general_ledger.py,Values Out Of Sync,Hodnoty nie sú synchronizované
apps/erpnext/erpnext/stock/report/stock_and_account_value_comparison/stock_and_account_value_comparison.py,Difference Value,Hodnota rozdielu
DocType: SMS Log,Requested Numbers,Požadované Čísla
DocType: Volunteer,Evening,Večer
DocType: Quiz,Quiz Configuration,Konfigurácia testu
DocType: Customer Credit Limit,Bypass credit limit check at Sales Order,Zablokujte kontrolu kreditného limitu na objednávke
DocType: Vital Signs,Normal,normálne
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","Povolenie &quot;použitia na nákupného košíka&quot;, ako je povolené Nákupný košík a tam by mala byť aspoň jedna daňové pravidlá pre Košík"
DocType: Sales Invoice Item,Stock Details,Detaily zásob
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,Mieste predaja
DocType: Fee Schedule,Fee Creation Status,Stav tvorby poplatkov
apps/erpnext/erpnext/utilities/activation.py,Create Sales Orders to help you plan your work and deliver on-time,"Vytvorte zákazky odberateľa, aby ste si mohli naplánovať svoju prácu a včas dodať"
DocType: Vehicle Log,Odometer Reading,stav tachometra
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,Zostatok musí byť
,Available Qty,Množství k dispozici
DocType: Shopify Settings,Default Warehouse to to create Sales Order and Delivery Note,Predvolená skladačka na vytvorenie objednávky predaja a dodacieho listu
DocType: Purchase Taxes and Charges,On Previous Row Total,Na předchozí řady Celkem
DocType: Purchase Invoice Item,Rejected Qty,zamietnutá Množstvo
DocType: Setup Progress Action,Action Field,Pole akcií
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 svoje produkty so zariadením Amazon MWS pred synchronizáciou podrobností objednávok
DocType: Delivery Trip,Delivery Stops,Zastavenie doručenia
DocType: Salary Slip,Working Days,Pracovní dny
apps/erpnext/erpnext/accounts/deferred_revenue.py,Cannot change Service Stop Date for item in row {0},Nemôžem zmeniť dátum ukončenia servisu pre položku v riadku {0}
DocType: Serial No,Incoming Rate,Příchozí Rate
DocType: Packing Slip,Gross Weight,Hrubá hmotnost
DocType: Leave Type,Encashment Threshold Days,Denné prahové hodnoty pre inkasovanie
,Final Assessment Grades,Záverečné stupne hodnotenia
apps/erpnext/erpnext/public/js/setup_wizard.js,The name of your company for which you are setting up this system.,"Názov spoločnosti, pre ktorú nastavujete tento systém"
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 svoj inštitút v ERPNext
DocType: Agriculture Analysis Criteria,Plant Analysis,Analýza rastlín
DocType: Task,Timeline,časová os
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Hold,Držet
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Alternate Item,Alternatívna položka
DocType: Shopify Log,Request Data,Vyžiadajte si ú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álne sedenie
DocType: Item Attribute,Item Attribute Values,Položka Hodnoty atributů
DocType: Examination Result,Examination Result,vyšetrenie Výsledok
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,Nastavte predvolené UOM v nastaveniach zásob
DocType: Purchase Invoice,Accounting Dimensions,Účtovné dimenzie
,Subcontracted Raw Materials To Be Transferred,"Subdodávateľské suroviny, ktoré sa majú preniesť"
apps/erpnext/erpnext/config/accounts.py,Currency exchange rate master.,Devizový kurz master.
,Sales Person Target Variance Based On Item Group,Cieľová odchýlka predajnej osoby na základe skupiny položiek
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Reference Doctype must be one of {0},Referenčná DOCTYPE musí byť 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,Filtrovanie celkového množstva nuly
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.,Kvôli veľkému počtu záznamov nastavte filter na základe položky alebo skladu.
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,Pre prenos nie sú k dispozícii žiadne položky
DocType: Employee Boarding Activity,Activity Name,Názov aktivity
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Change Release Date,Zmeniť dátum vydania
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žstvo hotového produktu <b>{0}</b> a Množstvo <b>{1}</b> sa nemôžu líšiť
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Closing (Opening + Total),Uzávierka (otvorenie + celkom)
DocType: Delivery Settings,Dispatch Notification Attachment,Príloha o oznámení odoslania
DocType: Payroll Entry,Number Of Employees,Počet zamestnancov
DocType: Journal Entry,Depreciation Entry,Zápis odpisu
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Please select the document type first,Najprv vyberte 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.,"Ak chcete zachovať úrovne opätovného poradia, musíte povoliť automatické opätovné objednávanie v nastaveniach zásob."
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,Sadzba alebo zľava
apps/erpnext/erpnext/accounts/doctype/bank/bank_dashboard.py,Bank Details,Bankové údaje
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é údaje
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to ledger.,Sklady s existujúcimi transakcie nemožno previesť na knihy.
DocType: Service Day,Service Day,Servisný deň
apps/erpnext/erpnext/projects/doctype/project/project.py,Project Summary for {0},Zhrnutie projektu pre {0}
apps/erpnext/erpnext/hub_node/api.py,Unable to update remote activity,Nemožno aktualizovať vzdialenú 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 dátumu a do dátumu ležia v inom fiškálnom roku
apps/erpnext/erpnext/healthcare/utils.py,The Patient {0} do not have customer refrence to invoice,Pacient {0} nemá faktúru odberateľa
DocType: Quality Feedback Template,Quality Feedback Template,Šablóna spätnej väzby 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,Vytvorenie faktúry {0}
DocType: Medical Code,Medical Code Standard,Štandardný zdravotnícky kód
DocType: Soil Texture,Clay Composition (%),Zloženie hliny (%)
DocType: Item Group,Item Group Defaults,Predvolené položky skupiny položiek
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Please save before assigning task.,Uložte pred udelením úlohy.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Balance Value,Hodnota zostatku
DocType: Lab Test,Lab Technician,Laboratórny technik
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,Sales Price List,Predajný cenní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.","Ak je začiarknuté, vytvorí sa zákazník, zmapovaný na pacienta. Faktúry pacienta budú vytvorené voči tomuto zákazníkovi. Môžete tiež vybrať existujúceho zákazníka pri vytváraní pacienta."
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,Customer isn't enrolled in any Loyalty Program,Zákazník nie je zaregistrovaný v žiadnom vernostnom programe
DocType: Bank Reconciliation,Account Currency,Mena účtu
DocType: Lab Test,Sample ID,ID vzorky
apps/erpnext/erpnext/accounts/general_ledger.py,Please mention Round Off Account in Company,"Prosím, uveďte zaokrúhliť účet v spoloč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,Zamestnanec {0} nie je aktívny alebo neexistuje
DocType: Fee Structure,Components,komponenty
DocType: Support Search Source,Search Term Param Name,Hľadaný výraz Param Name
DocType: Item Barcode,Item Barcode,Položka Barcode
DocType: Delivery Trip,In Transit,V preprave
DocType: Woocommerce Settings,Endpoints,Endpoints
DocType: Shopping Cart Settings,Show Configure Button,Zobraziť tlačidlo Konfigurovať
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,Nemožno {0} {1} {2} bez negatívnych vynikajúce faktúra
DocType: Share Transfer,From Folio No,Z Folio č
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.,Definovať rozpočet pre finančný rok.
DocType: Shopify Tax Account,ERPNext Account,Následný účet ERP
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čiatočný a konečný dátum.
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} is blocked so this transaction cannot proceed,"{0} je zablokovaná, aby táto transakcia nemohla pokračovať"
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on MR,Ak je akumulovaný mesačný rozpočet prekročen na MR
DocType: Employee,Permanent Address Is,Trvalé bydliště je
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Enter Supplier,Zadajte dodávateľa
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},Zdravotnícky lekár {0} nie je k dispozícii na {1}
DocType: Payment Terms Template,Payment Terms Template,Šablóna platobných podmienok
apps/erpnext/erpnext/public/js/setup_wizard.js,The Brand,Značka
DocType: Employee Tax Exemption Proof Submission,Rented To Date,Prenajaté do dátumu
DocType: Manufacturing Settings,Allow Multiple Material Consumption,Povoliť viacnásobnú spotrebu 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,Prijatá faktúra
DocType: Manufacturing Settings,Allow multiple Material Consumption against a Work Order,Povoliť viacnásobnú spotrebu materiálu proti pracovnej objednávke
DocType: GL Entry,Voucher Detail No,Voucher Detail No
DocType: Email Digest,New Sales Invoice,Nová predajná faktúra
DocType: Stock Entry,Total Outgoing Value,Celková hodnota Odchozí
DocType: Healthcare Practitioner,Appointments,schôdzky
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,Action Initialised,Iniciovaná akcia
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date and Closing Date should be within same Fiscal Year,Dátum začatia a dátumom ukončenia by malo byť v rámci rovnakého fiškálny rok
DocType: Lead,Request for Information,Žádost o informace
DocType: Course Activity,Activity Date,Dátum aktivity
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,{} of {},{} z {}
DocType: Sales Invoice Item,Rate With Margin (Company Currency),Sadzba s maržou (mena spoločnosti)
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Categories,Kategórie
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Offline Invoices,Sync Offline Faktúry
DocType: Payment Request,Paid,Zaplatené
DocType: Service Level,Default Priority,Predvolená 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.","Nahradiť konkrétny kusovník vo všetkých ostatných kusovníkoch, kde sa používa. Bude nahradiť starý odkaz BOM, aktualizovať cenu a obnoviť tabuľku &quot;BOM Explosion Item&quot; podľa nového kusovníka. Aktualizuje tiež poslednú cenu vo všetkých kusovníkoch."
DocType: Employee Skill Map,Employee Skill Map,Mapa zručností zamestnancov
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,The following Work Orders were created:,Boli vytvorené tieto pracovné príkazy:
DocType: Salary Slip,Total in words,Celkem slovy
DocType: Inpatient Record,Discharged,Vybitý
DocType: Material Request Item,Lead Time Date,Čas a Dátum Obchodnej iniciatívy
,Employee Advance Summary,Súhrnný prehľad zamestnancov
DocType: Asset,Available-for-use Date,Dátum k dispozícii na použitie
DocType: Guardian,Guardian Name,Meno Guardian
DocType: Cheque Print Template,Has Print Format,Má formát tlače
DocType: Support Settings,Get Started Sections,Začnite sekcie
DocType: Lead,CRM-LEAD-.YYYY.-,CRM-LEAD-.YYYY.-
DocType: Invoice Discounting,Sanctioned,Sankcionované
,Base Amount,Základná čiastka
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js,Total Contribution Amount: {0},Celková suma príspevku: {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,Príspevky na platy boli odoslané
DocType: Crop Cycle,Crop Cycle,Orezový cyklus
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.","Pre &quot;produktom Bundle predmety, sklad, sériové číslo a dávkové No bude považovaná zo&quot; Balenie zoznam &#39;tabuľky. Ak Warehouse a Batch No sú rovnaké pre všetky balenia položky pre akúkoľvek &quot;Výrobok balík&quot; položky, tieto hodnoty môžu byť zapísané do hlavnej tabuľky položky, budú hodnoty skopírované do &quot;Balenie zoznam&quot; tabuľku."
DocType: Amazon MWS Settings,BR,BR
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Place,Z miesta
DocType: Student Admission,Publish on website,Publikovať na webových stránkach
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice Date cannot be greater than Posting Date,Dodávateľ Dátum faktúry nemôže byť väčšia ako Dátum zverejnenia
DocType: Installation Note,MAT-INS-.YYYY.-,MAT-INS-.YYYY.-
DocType: Subscription,Cancelation Date,Dátum zrušenia
DocType: Purchase Invoice Item,Purchase Order Item,Položka nákupnej objednávky
DocType: Agriculture Task,Agriculture Task,Úloha poľnohospodárstva
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,Študent Účasť Tool
DocType: Restaurant Menu,Price List (Auto created),Cenník (vytvorený automaticky)
DocType: Pick List Item,Picked Qty,Vybrané množstvo
DocType: Cheque Print Template,Date Settings,Nastavenia dátumu
apps/erpnext/erpnext/education/doctype/question/question.py,A question must have more than one options,Otázka musí mať viac ako jednu možnosť
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Variance,Odchylka
DocType: Employee Promotion,Employee Promotion Detail,Podrobnosti o propagácii zamestnancov
DocType: Delivery Trip,Driver Email,E-mail vodiča
DocType: SMS Center,Total Message(s),Celkem zpráv (y)
DocType: Share Balance,Purchased,zakúpené
DocType: Item Variant Settings,Rename Attribute Value in Item Attribute.,Premenujte hodnotu atribútu v atribúte položky.
DocType: Purchase Invoice,Additional Discount Percentage,Ďalšie zľavy Percento
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,View a list of all the help videos,Zobraziť zoznam všetkých videí nápovedy
DocType: Agriculture Analysis Criteria,Soil Texture,Textúra pôdy
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,Vytlačiť kartu správ
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","Riadok {0}: faktúra {1} je neplatná, to by mohlo byť zrušené / neexistuje. \ Zadajte platnú faktúru"
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ýchodisková banka / Peňažný účet budú automaticky aktualizované v plat položka denníku ak je zvolený tento režim.
DocType: Quiz,Latest Attempt,Najnovší pokus
DocType: Quiz Result,Quiz Result,Výsledok testu
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total leaves allocated is mandatory for Leave Type {0},Celkový počet priradených listov je povinný pre typ dovolenky {0}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Riadok # {0}: Sadzba nesmie byť vyššia ako sadzba použitá v {1} {2}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Riadok # {0}: Sadzba nesmie byť vyššia ako sadzba 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,Laboratórne testovanie dátumu nemôže byť pred dátumom zberu
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á čiastka preddavku
DocType: Delivery Stop,Estimated Arrival,Odhadovaný príchod
apps/erpnext/erpnext/templates/pages/help.html,See All Articles,Pozrite si všetky články
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Walk In,Vejít
DocType: Item,Inspection Criteria,Inšpekčné kritéria
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Transfered,Prevedené
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 svoju hlavičku a logo pre dokumenty. (Môžete ich upravovať neskôr.)
DocType: Timesheet Detail,Bill,Účtenka
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,White,Biela
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid Company for Inter Company Transaction.,Neplatná spoločnosť pre medzipodnikové transakcie.
DocType: SMS Center,All Lead (Open),Všetky Iniciatívy (Otvorené)
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.,V zozname začiarkavacích políčok môžete vybrať maximálne jednu možnosť.
DocType: Purchase Invoice,Get Advances Paid,Získejte zaplacené zálohy
DocType: Item,Automatically Create New Batch,Automaticky vytvoriť novú 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.","Používateľ, ktorý sa použije na vytvorenie zákazníkov, položiek a zákaziek odberateľa. Tento používateľ by mal mať príslušné povolenia."
DocType: Asset Category,Enable Capital Work in Progress Accounting,Povoliť kapitálové účtovníctvo v priebehu
DocType: POS Field,POS Field,Pole POS
DocType: Supplier,Represents Company,Reprezentuje spoločnosť
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Make ,Vytvoriť
DocType: Student Admission,Admission Start Date,Vstupné Dátum začatia
DocType: Journal Entry,Total Amount in Words,Celková částka slovy
apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js,New Employee,Nový zamestnanec
DocType: Lead,Next Contact Date,Další Kontakt Datum
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Opening Qty,Otváracie množstvo
DocType: Healthcare Settings,Appointment Reminder,Pripomienka na menovanie
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please enter Account for Change Amount,"Prosím, zadajte účet pre zmenu Suma"
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,For operation {0}: Quantity ({1}) can not be greter than pending quantity({2}),Pre operáciu {0}: Množstvo ({1}) nemôže byť väčšie ako množstvo čakajúce na spracovanie ({2})
DocType: Program Enrollment Tool Student,Student Batch Name,Študent Batch Name
DocType: Holiday List,Holiday List Name,Názov zoznamu sviatkov
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Import položiek a UOM
DocType: Repayment Schedule,Balance Loan Amount,Bilancia Výška úveru
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Pridané k podrobnostiam
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Ľutujeme, kód kupónu je vyčerpaný"
DocType: Communication Medium,Catch All,Chytiť všetko
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,rozvrh
DocType: Budget,Applicable on Material Request,Platí pre materiálové požiadavky
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Stock Options,Možnosti zásob
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,No Items added to cart,Do košíka nie sú pridané žiadne 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?,Naozaj chcete obnoviť tento vyradený aktívum?
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Qty for {0},Množství pro {0}
DocType: Attendance,Leave Application,Aplikácia na priepustky
DocType: Patient,Patient Relation,Vzťah pacientov
DocType: Item,Hub Category to Publish,Kategória Hubu na publikovanie
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","Predajná objednávka {0} má rezerváciu pre položku {1}, môžete doručiť rezervované {1} iba proti {0}. Sériové číslo {2} sa nedá dodať"
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Item {0}: {1} qty produced. ,Položka {0}: {1} vyprodukované množstvo.
DocType: Sales Invoice,Billing Address GSTIN,Fakturačná adresa GSTIN
DocType: Homepage,Hero Section Based On,Hero Section Na základe
DocType: Employee Tax Exemption Proof Submission,Total Eligible HRA Exemption,Celková oprávnená výnimka pre HRA
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! A GSTIN must have 15 characters.,Neplatné GSTIN! GSTIN musí mať 15 znakov.
DocType: Assessment Plan,Evaluate,Ohodnotiť
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ériá
DocType: Packing Slip Item,Packing Slip Item,Balení Slip Item
DocType: Purchase Invoice,Cash/Bank Account,Hotovostný / Bankový účet
DocType: Travel Itinerary,Train,Vlak
,Delayed Item Report,Prehľad oneskorených položiek
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Eligible ITC,Oprávnené ITC
DocType: Healthcare Service Unit,Inpatient Occupancy,Umiestnenie v nemocnici
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,Publish Your First Items,Zverejnite svoje prvé 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 ukončení zmeny, počas ktorého sa check-out považuje za účasť."
apps/erpnext/erpnext/public/js/queries.js,Please specify a {0},Zadajte {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Removed items with no change in quantity or value.,Odstránené položky bez zmeny množstva alebo hodnoty.
DocType: Delivery Note,Delivery To,Doručenie do
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant creation has been queued.,Tvorba variantu bola zaradená do frontu.
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,Work Summary for {0},Súhrn práce pre {0}
DocType: Department,The first Leave Approver in the list will be set as the default Leave Approver.,Prvý prideľovač odchýlok v zozname bude nastavený ako predvolený neprístupný.
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute table is mandatory,Atribút tabuľka je povinné
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Delayed Days,Oneskorené dni
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 byť záporné
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Connect to Quickbooks,Pripojte sa k Quickbooks
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Clear values,Vymazať hodnoty
DocType: Training Event,Self-Study,Samoštúdium
DocType: POS Closing Voucher,Period End Date,Dátum ukončenia obdobia
apps/erpnext/erpnext/regional/india/utils.py,Transport Receipt No and Date are mandatory for your chosen Mode of Transport,Pre zvolený spôsob dopravy sú povinné číslo a dátum prepravy
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py,Soil compositions do not add up to 100,Pôdne zložky nedosahujú hodnotu 100
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Discount,Zľava
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,Na vytvorenie {2} faktúr na otvorenie {0}: {1} je potrebný riadok
DocType: Membership,Membership,členstva
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 debetnej platby
DocType: Sales Invoice Item,Rate With Margin,Sadzba s maržou
DocType: Sales Invoice Item,Rate With Margin,Sadzba s maržou
DocType: Purchase Invoice,Is Return (Debit Note),Je Return (Debit Note)
DocType: Workstation,Wages,Mzdy
DocType: Asset Maintenance,Maintenance Manager Name,Meno správcu údržby
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Transactions against the company already exist! ,Transakcie proti spoločnosti už existujú!
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requesting Site,Žiadajúci web
DocType: Agriculture Task,Urgent,Naléhavý
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Fetching records......,Prebieha načítavanie záznamov ......
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please specify a valid Row ID for row {0} in table {1},Zadajte platný riadok ID riadku tabuľky {0} {1}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py,Unable to find variable: ,Nepodarilo sa nájsť premennú:
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select a field to edit from numpad,"Vyberte pole, ktoré chcete upraviť z čísla"
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot be a fixed asset item as Stock Ledger is created.,"Nemôže byť položka fixného majetku, pretože je vytvorená účtovná kniha."
DocType: Subscription Plan,Fixed rate,Fixna sadzba
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.js,Admit,Pripustiť
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Go to the Desktop and start using ERPNext,Prejdite na plochu a začnite používať ERPNext
apps/erpnext/erpnext/templates/pages/order.js,Pay Remaining,Platba zostávajúca
DocType: Purchase Invoice Item,Manufacturer,Výrobca
DocType: Landed Cost Item,Purchase Receipt Item,Položka příjemky
DocType: Leave Allocation,Total Leaves Encashed,Celkový počet zapuzdrených listov
DocType: POS Profile,Sales Invoice Payment,Platba na odoslanú faktúru
DocType: Quality Inspection Template,Quality Inspection Template Name,Názov šablóny inšpekcie kvality
DocType: Project,First Email,Prvý e-mail
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Relieving Date must be greater than or equal to Date of Joining,Dátum vydania musí byť väčší alebo rovný dátumu pripojenia
DocType: Company,Exception Budget Approver Role,Role prístupu k výnimke rozpočtu
DocType: Purchase Invoice,"Once set, this invoice will be on hold till the set date",Po nastavení bude táto faktúra pozastavená až do stanoveného dátumu
DocType: Cashier Closing,POS-CLO-,POS-CLO-
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Selling Amount,Predajná čiastka
DocType: Repayment Schedule,Interest Amount,záujem Suma
DocType: Job Card,Time Logs,Čas Záznamy
DocType: Sales Invoice,Loyalty Amount,Vernostná suma
DocType: Employee Transfer,Employee Transfer Detail,Podrobnosti o zamestnancovi
DocType: Serial No,Creation Document No,Tvorba dokument č
DocType: Manufacturing Settings,Other Settings,ďalšie nastavenie
DocType: Location,Location Details,Podrobné informácie o polohe
DocType: Share Transfer,Issue,Problém
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter_dashboard.py,Records,Záznamy
DocType: Asset,Scrapped,zošrotovaný
DocType: Appointment Booking Settings,Agents,agents
DocType: Item,Item Defaults,Predvolené položky
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ázov organizácie
DocType: Support Settings,Show Latest Forum Posts,Zobraziť najnovšie príspevky vo fórach
DocType: Tax Rule,Shipping State,Prepravné State
,Projected Quantity as Source,Množstvo projekciou 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ány pomocí ""získat předměty z kupní příjmy"" tlačítkem"
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Delivery Trip,Rozvoz tovaru
DocType: Student,A-,A-
DocType: Share Transfer,Transfer Type,Typ prenosu
DocType: Pricing Rule,Quantity and Amount,Množstvo a množstvo
DocType: Appointment Booking Settings,Success Redirect URL,Adresa URL presmerovania úspechu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Sales Expenses,Predajné náklady
DocType: Diagnosis,Diagnosis,diagnóza
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Buying,Štandardný nákup
DocType: Attendance Request,Explanation,vysvetlenie
DocType: GL Entry,Against,Proti
DocType: Item Default,Sales Defaults,Predvolené hodnoty predaja
DocType: Sales Order Item,Work Order Qty,Počet pracovných zákaziek
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,kotúč
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Target Location or To Employee is required while receiving Asset {0},Cieľová poloha alebo Na zamestnanca je potrebné pri prijímaní aktíva {0}
DocType: Buying Settings,Material Transferred for Subcontract,Materiál prenesený na subdodávateľskú zmluvu
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Date,Dátum objednávky
DocType: Email Digest,Purchase Orders Items Overdue,Položky nákupných objednávok 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},Predajné 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 príjmu v úvere {0}
DocType: Opportunity,Contact Info,Kontaktné informácie
apps/erpnext/erpnext/config/help.py,Making Stock Entries,Tvorba prírastkov zásob
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Cannot promote Employee with status Left,Nemožno povýšiť zamestnanca so statusom odídený
DocType: Packing Slip,Net Weight UOM,Čistá hmotnosť MJ
DocType: Item Default,Default Supplier,Výchozí Dodavatel
DocType: Loan,Repayment Schedule,splátkový kalendár
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,Faktúru nemožno vykonať za nulovú fakturačnú hodinu
DocType: Company,Date of Commencement,Dátum začiatku
DocType: Sales Person,Select company name first.,"Prosím, vyberte najprv názov spoločnosti"
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Email sent to {0},Email odoslaný na {0}
apps/erpnext/erpnext/config/buying.py,Quotations received from Suppliers.,Ponuky od Dodávateľov.
DocType: Quality Goal,January-April-July-October,Január-apríl-júl-október
apps/erpnext/erpnext/config/manufacturing.py,Replace BOM and update latest price in all BOMs,Nahraďte kusovník a aktualizujte najnovšiu cenu vo všetkých kusovníkoch
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 koreňová skupina dodávateľov a nie je možné ju upravovať.
DocType: Sales Invoice,Driver Name,Názov vodiča
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Average Age,Průměrný věk
DocType: Education Settings,Attendance Freeze Date,Účasť
DocType: Education Settings,Attendance Freeze Date,Účasť
DocType: Payment Request,Inward,dovnútra
DocType: Accounting Dimension,Dimension Defaults,Predvolené rozmery
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Minimum Lead Age (Days),Minimálny vek vedenia (dni)
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Minimum Lead Age (Days),Minimálny vek vedenia (dni)
apps/erpnext/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py,Available For Use Date,Dostupné na použitie
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,All BOMs,všetky kusovníky
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Create Inter Company Journal Entry,Založenie záznamu do firemného denníka
DocType: Company,Parent Company,Materská spoločnosť
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Hotel Rooms of type {0} are unavailable on {1},Hotel Izby typu {0} sú k dispozícii na {1}
apps/erpnext/erpnext/config/manufacturing.py,Compare BOMs for changes in Raw Materials and Operations,Porovnajte kusovníky pre zmeny v surovinách a operáciách
apps/erpnext/erpnext/accounts/doctype/bank_transaction/bank_transaction.js,Document {0} successfully uncleared,Dokument {0} bol úspešne nejasný
DocType: Healthcare Practitioner,Default Currency,Predvolená mena
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Reconcile this account,Zosúladiť tento účet
apps/erpnext/erpnext/controllers/selling_controller.py,Maximum discount for Item {0} is {1}%,Maximálna zľava pre položku {0} je {1}%
DocType: Chart of Accounts Importer,Attach custom Chart of Accounts file,Pripojte vlastný súbor účtovných osnov
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žieb
DocType: Driver,Cellphone Number,Mobilné číslo
DocType: Project,Monitor Progress,Monitorovanie 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,Sekcia Auto Repeat
DocType: Service Level Priority,Response Time,Doba odozvy
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ý Atribút
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é kampane
DocType: Sales Partner,To Track inbound purchase,Ak chcete sledovať prichádzajúci nákup
DocType: Buying Settings,Default Supplier Group,Predvolená skupina dodávateľov
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Množstvo musí byť menší ako alebo rovný {0}
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Maximálna čiastka oprávnená pre komponent {0} presahuje {1}
DocType: Department Approver,Department Approver,Schôdza oddelenia
DocType: QuickBooks Migrator,Application Settings,Nastavenia aplikácie
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,Založenie spoločnosti a importná účtovná osnova
DocType: Employee Advance,Claimed,vyhlasoval
DocType: Crop,Row Spacing,Rozstup riadkov
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,Pre vybranú položku nie je žiadna iná položka
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,Šablóna postupu
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Publish Items,Publikovať položky
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution %,Príspevok%
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}","Podľa nákupných nastavení, ak je objednávka požadovaná == &#39;ÁNO&#39;, potom pre vytvorenie nákupnej faktúry musí používateľ najprv vytvoriť nákupnú objednávku pre položku {0}"
,HSN-wise-summary of outward supplies,HSN-múdre zhrnutie vonkajších dodávok
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,Asset Finance Book
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 predvolený bankový účet spoločnosti {0}
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set 'Apply Additional Discount On',Prosím nastavte na &quot;Použiť dodatočnú zľavu On&quot;
DocType: Party Tax Withholding Config,Applicable Percent,Použiteľné percento
,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í byť nižšia ako 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ázov akcie
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Start Year,Začiatočný rok
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.js,Create Loan,Vytvoriť pôžič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,Účasť na procese po
,IRS 1099,IRS 1099
DocType: Salary Slip,Leave Without Pay,Nechat bez nároku na mzdu
DocType: Payment Request,Outward,von
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On {0} Creation,Dňa {0} stvorenia
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,State/UT Tax,Štátna / UT daň
,Trial Balance for Party,Trial váhy pre stranu
,Gross and Net Profit Report,Správa o hrubom a čistom zisku
apps/erpnext/erpnext/config/quality_management.py,Tree of Procedures,Strom postupov
DocType: Lead,Consultant,Konzultant
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Parents Teacher Meeting Attendance,Zúčastňovanie učiteľov rodičov
DocType: Salary Slip,Earnings,Príjmy
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Finished Item {0} must be entered for Manufacture type entry,Dokončené Položka {0} musí byť zadaný pre vstup typu Výroba
apps/erpnext/erpnext/config/help.py,Opening Accounting Balance,Otvorenie účtovníctva Balance
,GST Sales Register,Obchodný register spoločnosti GST
DocType: Sales Invoice Advance,Sales Invoice Advance,Záloha na odoslanej faktúre
apps/erpnext/erpnext/public/js/setup_wizard.js,Select your Domains,Vyberte svoje domény
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/sync_product.py,Shopify Supplier,Nakupujte dodávateľa
DocType: Bank Statement Transaction Entry,Payment Invoice Items,Položky faktúry platby
DocType: Payroll Entry,Employee Details,Podrobnosti o zaměstnanci
apps/erpnext/erpnext/regional/doctype/import_supplier_invoice/import_supplier_invoice.py,Processing XML Files,Spracovanie súborov XML
DocType: Amazon MWS Settings,CN,CN
DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Polia budú kopírované iba v čase vytvorenia.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Management,Manažment
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.js,Show {0},Zobraziť {0}
DocType: Cheque Print Template,Payer Settings,nastavenie platcu
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,No pending Material Requests found to link for the given items.,"Žiadne prebiehajúce žiadosti o materiál, z ktorých sa zistilo, že odkazujú na dané položky."
apps/erpnext/erpnext/public/js/utils/party.js,Select company first,Najprv vyberte spoločnosť
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 Prebieha spracovanie a nedá sa aktualizovať zápisom do denníka
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Compare List function takes on list arguments,Funkcia Porovnanie zoznamu preberie argumenty zoznamu
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 bol úspešný
apps/erpnext/erpnext/config/quality_management.py,Goal and Procedure,Cieľ a postup
apps/erpnext/erpnext/agriculture/doctype/disease/disease.py,Start day is greater than end day in task '{0}',Začiatočný deň je väčší ako koniec dňa v úlohe &#39;{0}&#39;
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Return / Debit Note,Return / ťarchopis
DocType: Price List Country,Price List Country,Cenník Krajina
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>.","Ak sa chcete dozvedieť viac o plánovanom množstve, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">kliknite sem</a> ."
DocType: Sales Invoice,Set Source Warehouse,Nastaviť zdrojový sklad
DocType: Tally Migration,UOMs,Merné Jednotky
DocType: Account Subtype,Account Subtype,Podtyp účtu
apps/erpnext/erpnext/stock/utils.py,{0} valid serial nos for Item {1},{0} platné sériové čísla pre 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,Faktor konverzie MJ
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js,Please enter Item Code to get Batch Number,"Prosím, zadajte kód položky sa dostať číslo šarže"
DocType: Loyalty Point Entry,Loyalty Point Entry,Zadanie vernostného bodu
DocType: Employee Checkin,Shift End,Shift End
DocType: Stock Settings,Default Item Group,Predvolená skupina položiek
DocType: Job Card Time Log,Time In Mins,Čas v minútach
apps/erpnext/erpnext/config/non_profit.py,Grant information.,Poskytnite informácie.
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 ?,Táto akcia zruší prepojenie tohto účtu s akoukoľvek externou službou integrujúcou ERPNext s vašimi bankovými účtami. Nedá sa vrátiť späť. Ste si istí?
apps/erpnext/erpnext/config/accounts.py,Supplier database.,Databáze dodavatelů.
DocType: Contract Template,Contract Terms and Conditions,Zmluvné podmienky
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,You cannot restart a Subscription that is not cancelled.,"Predplatné, ktoré nie je zrušené, nemôžete reštartovať."
DocType: Account,Balance Sheet,Rozvaha
DocType: Leave Type,Is Earned Leave,Získaná dovolenka
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount,Suma 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é stretnutie učiteľov rodičov
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 nie je nakonfigurovaný. Prosím skontrolujte, či je účet bol nastavený na režim platieb alebo na POS Profilu."
apps/erpnext/erpnext/buying/utils.py,Same item cannot be entered multiple times.,Rovnakú položku nemožno zadávať viackrá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","Ďalšie účty môžu byť vyrobené v rámci skupiny, ale údaje je možné proti non-skupín"
DocType: Call Log,Lead,Obchodná iniciatíva
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ň pre
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Entry {0} created,Sklad Vstup {0} vytvoril
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,You don't have enought Loyalty Points to redeem,Nemáte dostatok vernostných bodov na vykúpenie
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 priradený účet v kategórii zrážky dane {0} voči spoločnosti {1}
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Qty can not be entered in Purchase Return,Riadok # {0}: zamietnutie Množstvo nemôže byť zapísaný do kúpnej Návrat
apps/erpnext/erpnext/stock/doctype/item/item.js,Changing Customer Group for the selected Customer is not allowed.,Zmena zákazníckej skupiny pre vybraného zákazníka nie je povolená.
,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},Riadok {1}: Pomenovanie diel je povinné pre automatické vytváranie položky {0}
DocType: Program Enrollment Tool,Enrollment Details,Podrobnosti o registrácii
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot set multiple Item Defaults for a company.,Nie je možné nastaviť viaceré predvolené položky pre spoločnosť.
DocType: Customer Group,Credit Limits,Úverové limity
DocType: Purchase Invoice Item,Net Rate,Čistá miera
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,Ponechajte alokácie
DocType: Job Card,Started Time,Čas začiatku
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,Hodnotiace podmienky
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,Druh dovolenky je panikavý
DocType: Support Settings,Close Issue After Days,Close Issue po niekoľkých dňoch
,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 byť používateľom s funkciami Správca systémov a Správca položiek, pomocou ktorých môžete používateľov pridávať do služby Marketplace."
DocType: Attendance,Early Exit,Skorý východ
DocType: Job Opening,Staffing Plan,Personálny 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,E-Way Bill JSON môže byť generovaný iba z predloženého dokumentu
apps/erpnext/erpnext/config/hr.py,Employee Tax and Benefits,Daň z príjmu zamestnancov a výhody
DocType: Bank Guarantee,Validity in Days,Platnosť v dňoch
DocType: Bank Guarantee,Validity in Days,Platnosť v dňoch
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,C-form is not applicable for Invoice: {0},C-forma sa nevzťahuje na faktúre: {0}
DocType: Certified Consultant,Name of Consultant,Názov 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čet objednávok
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Count,Počet objednávok
DocType: Global Defaults,Current Fiscal Year,Aktuálny fiškálny rok
DocType: Purchase Invoice,Group same items,Skupina rovnaké položky
DocType: Purchase Invoice,Disable Rounded Total,Vypnúť zaokrúhlovanie sumy spolu
DocType: Marketplace Settings,Sync in Progress,Priebeh synchronizácie
DocType: Department,Parent Department,Rodičovské oddelenie
DocType: Loan Application,Repayment Info,splácanie Info
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,'Entries' cannot be empty,"""Položky"" nemôžu býť prázdne"
DocType: Maintenance Team Member,Maintenance Role,Úloha údržby
apps/erpnext/erpnext/utilities/transaction_base.py,Duplicate row {0} with same {1},Duplicitný riadok {0} s rovnakým {1}
DocType: Marketplace Settings,Disable Marketplace,Zakázať trhovisko
DocType: Quality Meeting,Minutes,minúty
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Your Featured Items,Vaše odporúčané položky
,Trial Balance,Trial Balance
apps/erpnext/erpnext/templates/pages/projects.js,Show Completed,Zobraziť dokončené
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Fiscal Year {0} not found,Fiškálny rok {0} nebol nájdený
apps/erpnext/erpnext/config/help.py,Setting up Employees,Nastavenia pre modul Zamestnanci
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Vykonajte zadanie zásob
DocType: Hotel Room Reservation,Hotel Reservation User,Používateľ rezervácie hotelov
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Nastaviť 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 splnenia
apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Vo vašom okolí
DocType: Student,O-,O-
DocType: Subscription Settings,Subscription Settings,Nastavenia odberu
DocType: Purchase Invoice,Update Auto Repeat Reference,Aktualizovať referenciu automatického opakovania
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Optional Holiday List not set for leave period {0},Voliteľný prázdninový zoznam nie je nastavený na obdobie dovolenky {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,Riadok {0}: Čas od času musí byť kratší ako č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 aspoň jeden atribút v tabuľke atribúty
DocType: Announcement,All Students,všetci študenti
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} must be a non-stock item,Item {0} musí byť 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,Zosúladené transakcie
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Earliest,Najstarší
DocType: Crop Cycle,Linked Location,Prepojená poloha
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","Položková  skupina s rovnakým názvom už existuje. Prosím, zmeňte názov položky alebo premenujte skupinu položiek"
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invocies,Získajte faktúry
DocType: Designation,Skills,zručností
DocType: Crop Cycle,Less than a year,Menej ako rok
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Student Mobile No.,Študent 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 mať 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ískajte položky zo služieb zdravotnej starostlivosti
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Finished Qty,Dokončené Množstvo
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: Activity Type is mandatory.,Riadok {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 platené
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Accounting Ledger,Účtovné Ledger
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Difference Amount,Rozdiel Suma
DocType: Purchase Invoice,Reverse Charge,Spätné nabíjanie
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Retained Earnings,Nerozdelený zisk
DocType: Job Card,Timing Detail,Časový detail
DocType: Purchase Invoice,05-Change in POS,05-Zmena POS
DocType: Vehicle Log,Service Detail,servis Detail
DocType: BOM,Item Description,Položka Popis
DocType: Student Sibling,Student Sibling,študent Súrodenec
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 aktívnu ponuku reštaurácie {0}
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Commission Rate %,Komisia sadzba%
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Qty To Manufacture,Množství K výrobě
DocType: Email Digest,New Income,new príjmov
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Open Lead,Otvorte potenciálneho zákazníka
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,Študent a Guardian Kontaktné údaje
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge Account,Zlúčiť úč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,Riadok {0}: Pre dodávateľov je potrebná {0} E-mailová adresa pre odoslanie e-mailu
DocType: Shift Type,Attendance will be marked automatically only after this date.,Účasť bude automaticky označená až po tomto dátume.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Opening,Dočasné Otvorenie
,Employee Leave Balance,Zostatok voľna pre zamestnanca
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},Zostatok na účte {0} musí byť vždy {1}
DocType: Patient Appointment,More Info,Více informací
DocType: Supplier Scorecard,Scorecard Actions,Akcie Scorecard
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,Supplier {0} not found in {1},Dodávateľ {0} nebol nájdený 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í Center Nákup Cost
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.","Ak chcete získať to najlepšie z ERPNext, odporúčame vám nejaký čas venovať týmto videám."
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,For Default Supplier (optional),Pre predvoleného dodávateľa (nepovinné)
DocType: Supplier Quotation Item,Lead Time in days,Vek Obchodnej iniciatívy v dňoch
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Target ({}),Zacielenie ({})
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 zásob ({0}) a zostatok na účte ({1}) nie sú synchronizované s účtom {2} a súvisiacimi skladmi.
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,Upozornenie na novú žiadosť o ponuku
apps/erpnext/erpnext/utilities/activation.py,Purchase orders help you plan and follow up on your purchases,Objednávky pomôžu pri plánovaní a sledovaní na vaše nákupy
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Lab Test Prescriptions,Predpisy pre laboratórne 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é emisie / prenosu množstvo {0} v hmotnej Request {1} \ nemôže byť väčšie než množstvo {2} pre 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","Ak služba Shopify neobsahuje zákazníka v objednávke, pri synchronizácii objednávok systém zváži objednávku predvoleného zákazníka"
DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Otvorenie položky nástroja na vytvorenie faktúry
DocType: Cashier Closing Payments,Cashier Closing Payments,Pokladničné platby
DocType: Education Settings,Employee Number,Počet zaměstnanců
DocType: Subscription Settings,Cancel Invoice After Grace Period,Zrušiť faktúru 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čených
,Invoiced Amount (Exculsive Tax),Fakturovaná částka (bez daně)
DocType: Asset Finance Book,Rate of Depreciation,Miera odpisovania
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},Riadok {0}: Kontrola kvality zamietnutá pre položku {1}
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 2,Položka 2
DocType: Pricing Rule,Validate Applied Rule,Potvrdiť použité pravidlo
DocType: QuickBooks Migrator,Authorization Endpoint,Koncový bod autorizácie
DocType: Employee Onboarding,Notify users by email,Upozorniť používateľov e-mailom
DocType: Travel Request,International,medzinárodný
DocType: Training Event,Training Event,Training Event
DocType: Item,Auto re-order,Auto re-order
DocType: Attendance,Late Entry,Neskorý 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,Zľava na propagačnú schému
DocType: Contract,Contract,Zmluva
DocType: GSTR 3B Report,May,Květen
DocType: Plant Analysis,Laboratory Testing Datetime,Laboratórne testovanie
DocType: Email Digest,Add Quote,Pridať ponuku
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,UOM coversion factor required for UOM: {0} in Item: {1},Koeficient prepočtu MJ je potrebný k MJ: {0} v bode: {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,Poľnohospodárstvo
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Sales Order,Vytvorenie objednávky predaja
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Accounting Entry for Asset,Účtovné položky pre aktíva
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} nie je skupinový uzol. Vyberte skupinový uzol ako materské nákladové stredisko
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Block Invoice,Blokovať faktúru
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Quantity to Make,"Množstvo, ktoré sa má vyrobiť"
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,Prebieha kontrola
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Nepodarilo sa prihlásiť
DocType: Coupon Code,Promotional,propagačné
DocType: Special Test Items,Special Test Items,Špeciálne testovacie 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 byť používateľom s funkciami Správca systému a Správca položiek na registráciu na trhu.
apps/erpnext/erpnext/config/buying.py,Key Reports,Kľúčové sprá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,Podľa vašej pridelenej štruktúry platov nemôžete požiadať 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 mala byť verejná súboru alebo webovej 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,Zlúčiť
DocType: Journal Entry Account,Purchase Order,Nákupná objednávka
DocType: Vehicle,Fuel UOM,palivo UOM
DocType: Warehouse,Warehouse Contact Info,Sklad Kontaktní informace
DocType: Payment Entry,Write Off Difference Amount,Odpísať Difference Suma
DocType: Volunteer,Volunteer Name,Názov dobrovoľníka
apps/erpnext/erpnext/controllers/accounts_controller.py,Rows with duplicate due dates in other rows were found: {0},V iných riadkoch boli nájdené riadky s duplicitnými termínmi: {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,"{0}: Employee email not found, hence email not sent","{0}: e-mail zamestnanec nebol nájdený, a preto 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},Žiadna platová štruktúra priradená zamestnancovi {0} v daný deň {1}
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule not applicable for country {0},Prepravné pravidlo sa nevzťahuje na krajinu {0}
DocType: Import Supplier Invoice,Import Invoices,Importovať faktúry
DocType: Item,Foreign Trade Details,Zahraničný obchod Podrobnosti
,Assessment Plan Status,Stav plánu hodnotenia
DocType: Email Digest,Annual Income,Ročný príjem
DocType: Serial No,Serial No Details,Podrodnosti k sériovému číslu
DocType: Purchase Invoice Item,Item Tax Rate,Sazba daně položky
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Party Name,Z 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,Dodanie na základe zákazky odberateľa
DocType: Student Group Student,Group Roll Number,Číslo skupiny rollov
DocType: Student Group Student,Group Roll Number,Číslo skupiny rollov
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ál Vybavenie
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,Najprv nastavte kód položky
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,DokTyp
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 intervalov
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Schôdzky a stretnutia s pacientmi
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Hodnota chýba
DocType: Employee,Department and Grade,Oddelenie a trieda
DocType: Antibiotic,Antibiotic,antibiotikum
,Team Updates,tím Updates
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,Vytvoriť formát tlače
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Created,Poplatok vytvorený
apps/erpnext/erpnext/utilities/bot.py,Did not find any item called {0},Nenašiel žiadnu položku s názvom {0}
apps/erpnext/erpnext/stock/report/item_prices/item_prices.js,Items Filter,Filtrovanie položiek
DocType: Supplier Scorecard Criteria,Criteria Formula,Kritérium vzorca
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,trvanie
apps/erpnext/erpnext/controllers/status_updater.py,"For an item {0}, quantity must be positive number",Pri položke {0} musí byť množstvo kladné
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é dni žiadosti o dovolenku nie sú v platných sviatkoch
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Child warehouse exists for this warehouse. You can not delete this warehouse.,Dieťa sklad existuje pre tento sklad. Nemôžete odstrániť 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},Zadajte <b>rozdielny účet</b> alebo nastavte predvolený <b>účet</b> na vyrovnanie <b>zásob</b> spoločnosti {0}
DocType: Item,Website Item Groups,Webové stránky skupiny položek
DocType: Purchase Invoice,Total (Company Currency),Total (Company meny)
DocType: Daily Work Summary Group,Reminder,pripomienka
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Accessable Value,Prí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,Z GSTIN
DocType: Expense Claim Advance,Unclaimed amount,Nevyžiadaná suma
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items in progress,{0} položky v prebiehajúcej
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,Alternatívna položka nesmie byť rovnaká ako 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,Dosky na zľavu produktov
DocType: Target Detail,Target Distribution,Target Distribution
DocType: Purchase Invoice,06-Finalization of Provisional assessment,06 - Dokončenie predbežného hodnotenia
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Parties and Addresses,Dovážajúce strany a adresy
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Prepočítavací faktor UOM ({0} -&gt; {1}) nenájdený pre položku: {2}
DocType: Salary Slip,Bank Account No.,Číslo bankového účtu
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)
","Možno použiť premenné tabuľky výsledkov, rovnako ako: {total_score} (celkové skóre z tohto obdobia), {period_number} (počet období do súčasnosti)"
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Purchase Order,Vytvorenie objednávky
DocType: Quality Inspection Reading,Reading 8,Čtení 8
DocType: Inpatient Record,Discharge Note,Poznámka o vyčerpaní
DocType: Appointment Booking Settings,Number of Concurrent Appointments,Počet súbežných stretnutí
apps/erpnext/erpnext/config/desktop.py,Getting Started,Začíname
DocType: Purchase Invoice,Taxes and Charges Calculation,Daně a poplatky výpočet
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Automatické odpisovanie majetku v účtovnej závierke
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Automatické odpisovanie majetku v účtovnej závierke
DocType: BOM Operation,Workstation,pracovna stanica
DocType: Request for Quotation Supplier,Request for Quotation Supplier,Žiadosť o cenovú ponuku dodávateľa
DocType: Healthcare Settings,Registration Message,Registrácia Správa
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Hardware,Technické vybavení
DocType: Prescription Dosage,Prescription Dosage,Dávkovanie na predpis
DocType: Appointment Booking Settings,HR Manager,HR Manager
apps/erpnext/erpnext/accounts/party.py,Please select a Company,Vyberte spoločnosť
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Privilege Leave,Privilege Leave
DocType: Purchase Invoice,Supplier Invoice Date,Dátum dodávateľskej faktúry
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,odpísanie
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>Príklad:</b> SAL- {first_name} - {date_of_birth.year} <br> Takto sa vygeneruje heslo ako SAL-Jane-1972
DocType: Stock Settings,Naming Series Prefix,Pomenovanie predvoľby série
DocType: Appraisal Template Goal,Appraisal Template Goal,Posouzení Template Goal
DocType: Salary Component,Earning,Príjem
DocType: Supplier Scorecard,Scoring Criteria,Kritériá hodnotenia
DocType: Purchase Invoice,Party Account Currency,Party Mena účtu
DocType: Delivery Trip,Total Estimated Distance,Celková odhadovaná vzdialenosť
DocType: Invoice Discounting,Accounts Receivable Unpaid Account,Nesplatené účty pohľadávok
DocType: Tally Migration,Tally Company,Spoločnosť Tally
apps/erpnext/erpnext/config/manufacturing.py,BOM Browser,BOM Browser
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py,Not allowed to create accounting dimension for {0},Nie je povolené vytvárať účtovnú dimenziu pre {0}
apps/erpnext/erpnext/templates/emails/training_event.html,Please update your status for this training event,Aktualizujte svoj stav tejto tréningovej udalosti
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 bankovej transakcii
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,Neaktívne predajné položky
DocType: Quality Review,Additional Information,Ďalšie informácie
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 o uzatvorení dokladu POS
DocType: Bank Account,Is the Default Account,Je predvolený účet
DocType: Shopify Log,Shopify Log,Obchodný záznam
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,No communication found.,Nenašla sa žiadna komunikácia.
DocType: Inpatient Occupancy,Check In,Prihlásiť sa
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Create Payment Entry,Založenie záznamu platby
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 v porovnaní s {1}
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Enrolling student,učiaci študenta
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Currency of the Closing Account must be {0},"Mena záverečného účtu, musí byť {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ôdza sa prekrýva s {0}. <br> {1} má naplánované stretnutie s {2} o {3} s trvaním {4} minút.
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py,Sum of points for all goals should be 100. It is {0},Súčet bodov za všetkých cieľov by malo byť 100. Je {0}
DocType: Project,Start and End Dates,Dátum začatia a ukončenia
DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Zmluvné podmienky pre splnenie podmienok zmluvy
,Delivered Items To Be Billed,Dodávaných výrobků fakturovaných
DocType: Coupon Code,Maximum Use,Maximálne použitie
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Otvorená 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ýnimka za rok HRA
DocType: Rename Tool,Utilities,Utilities
DocType: POS Profile,Accounting,Účtovníctvo
DocType: Asset,Purchase Receipt Amount,Čiastka kúpnej sumy
DocType: Employee Separation,Exit Interview Summary,Ukončiť zhrnutie rozhovoru
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select batches for batched item ,Vyberte dávky pre doručenú položku
DocType: Asset,Depreciation Schedules,odpisy Plány
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Sales Invoice,Vytvoriť predajnú faktúru
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Ineligible ITC,Neoprávnené ITC
DocType: Task,Dependent Tasks,Závislé úlohy
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Following accounts might be selected in GST Settings:,Nasledujúce účty môžu byť vybraté v nastaveniach GST:
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js,Quantity to Produce,Množstvo na výrobu
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Application period cannot be outside leave allocation period,Obdobie podávania žiadostí nemôže byť alokačné obdobie vonku voľno
DocType: Activity Cost,Projects,Projekty
DocType: Payment Request,Transaction Currency,transakčné mena
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,Niektoré e-maily sú 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ý koší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šená automaticky pri zrušení diela, pretože bolo \ autogenerované pre diela {1}"
DocType: Supplier,Name and Type,Názov a typ
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Item Reported,Položka bola nahlásená
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čite nahlásenie a odhlásenie
DocType: Salary Structure,Max Benefits (Amount),Maximálne výhody (čiastka)
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Add notes,Pridajte poznámky
DocType: Purchase Invoice,Contact Person,Kontaktná osoba
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,No data for this period,Žiadne údaje za toto obdobie
DocType: Course Scheduling Tool,Course End Date,Koniec Samozrejme Dátum
DocType: Holiday List,Holidays,Prázdniny
DocType: Sales Order Item,Planned Quantity,Plánované Množstvo
DocType: Water Analysis,Water Analysis Criteria,Kritériá analýzy vody
DocType: Item,Maintain Stock,Udržiavať Zásoby
DocType: Terms and Conditions,Applicable Modules,Uplatniteľné moduly
DocType: Employee,Prefered Email,preferovaný Email
DocType: Student Admission,Eligibility and Details,Oprávnenosť a podrobnosti
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Included in Gross Profit,Zahrnuté v hrubom zisku
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Fixed Asset,Čistá zmena v stálych aktív
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Reqd Qty,Požad
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,Pre spoločnosť
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.",Žiadosť o cenovú ponuku je zakázaný prístup z portálu pre viac Skontrolujte nastavenie portálu.
DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Hodnota ukazovateľa skóre skóre dodávateľa
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.,Spoločnosť s majetkom {0} a nákupný doklad {1} sa nezhodujú.
DocType: POS Closing Voucher,Modes of Payment,Spôsoby platby
DocType: Sales Invoice,Shipping Address Name,Názov dodacej adresy
apps/erpnext/erpnext/accounts/doctype/account/account.js,Chart of Accounts,Účtovný rozvrh
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,Pri vytváraní kurzov sa vyskytli chyby
DocType: Communication Medium,Timeslots,Časové úseky
DocType: Department,The first Expense Approver in the list will be set as the default Expense Approver.,Prvý odhadovač výdavkov v zozname bude nastavený ako predvolený odhadovač nákladov.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,cannot be greater than 100,nemôže byť väčšie ako 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.,"Aby ste sa mohli zaregistrovať na trhu, musíte byť iným používateľom než správcom s roly Správcu systémov a Správca položiek."
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,Nenašli sa žiadne produkty
DocType: Employee,Better Prospects,Lepší vyhlídky
DocType: Travel Itinerary,Gluten Free,Bezlepkový
DocType: Loyalty Program Collection,Minimum Total Spent,Minimálny celkový počet vynaložených prostriedkov
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","Riadok # {0}: Dávka {1} má iba {2} qty. Vyberte inú dávku, ktorá má {3} k dispozícii, alebo rozdeľte riadok do viacerých riadkov a doručte / vydávajte z viacerých šarží"
DocType: Loyalty Program,Expiry Duration (in days),Trvanie platnosti (v dňoch)
DocType: Inpatient Record,Discharge Date,Dátum vykládky
DocType: Subscription Plan,Price Determination,Stanovenie ceny
DocType: Vehicle,License Plate,Poznávacia značka
apps/erpnext/erpnext/hr/doctype/department/department_tree.js,New Department,Nové oddelenie
DocType: Compensatory Leave Request,Worked On Holiday,Pracoval na dovolenke
DocType: Appraisal,Goals,Ciele
DocType: Support Settings,Allow Resetting Service Level Agreement,Povoliť obnovenie dohody o úrovni služieb
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Select POS Profile,Zvoľte POS profil
DocType: Warranty Claim,Warranty / AMC Status,Záruka / AMC Status
,Accounts Browser,Účty Browser
DocType: Procedure Prescription,Referral,postúpenie
DocType: Payment Entry Reference,Payment Entry Reference,Platba Vstup referencie
DocType: GL Entry,GL Entry,Vstup GL
DocType: Support Search Source,Response Options,Možnosti odpovede
DocType: Pricing Rule,Apply Multiple Pricing Rules,Použite pravidlá viacerých cien
DocType: HR Settings,Employee Settings,Nastavení zaměstnanců
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.html,Loading Payment System,Načítanie platobné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}.,"Riadok # {0}: Nie je možné nastaviť sadzbu, ak je suma vyššia ako čiastka fakturácie pre položku {1}."
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Print settings updated in respective print format,Nastavenie tlače aktualizované v príslušnom formáte tlači
DocType: Package Code,Package Code,Kód zásielky
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Apprentice,Učeň
DocType: Purchase Invoice,Company GSTIN,IČDPH firmy
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Negative Quantity is not allowed,Záporné množstvo nie je dovolené
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.,Zamestnanec nemôže reportovať sám sebe.
apps/erpnext/erpnext/templates/pages/order.html,Rate:,rýchlosť:
DocType: Bank Account,Change this date manually to setup the next synchronization start date,Tento dátum zmeňte manuálne a nastavte nasledujúci dátum začatia synchronizácie
DocType: Leave Type,Max Leaves Allowed,Max povolené povolenia
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,Bankový zostatok
apps/erpnext/erpnext/controllers/accounts_controller.py,Accounting Entry for {0}: {1} can only be made in currency: {2},Účtovný záznam pre {0}: {1} môžu vykonávať len v mene: {2}
DocType: HR Settings,Leave Approver Mandatory In Leave Application,Povolenie odchýlky je povinné v aplikácii zanechať
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 pre transakcie.
DocType: Rename Tool,Type of document to rename.,Typ dokumentu na premenovanie.
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Resolve error and upload again.,Vyriešte chybu a odovzdajte znova.
DocType: Buying Settings,Over Transfer Allowance (%),Preplatok za prevod (%)
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 potrebná proti pohľadávok účtu {2}
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Spolu dane a poplatky (v peňažnej mene firmy)
DocType: Weather,Weather Parameter,Parametre počasia
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Show unclosed fiscal year's P&L balances,Ukázať P &amp; L zostatky neuzavretý fiškálny rok je
DocType: Item,Asset Naming Series,Asset Naming Series
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,Prenajaté rodinné domy by mali byť aspoň 15 dní od seba
DocType: Clinical Procedure Template,Collection Details,Podrobnosti zbierky
DocType: POS Profile,Allow Print Before Pay,Povoliť tlač pred zaplatením
DocType: Linked Soil Texture,Linked Soil Texture,Prepojená pôdna štruktúra
DocType: Shipping Rule,Shipping Account,Dodací účet
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} is inactive,{0} {1}: Účet {2} je neaktívny
DocType: GSTR 3B Report,March,marec
DocType: Bank Statement Transaction Entry,Bank Transaction Entries,Položky bankových transakcií
DocType: Quality Inspection,Readings,Čtení
DocType: Stock Entry,Total Additional Costs,Celkom Dodatočné náklady
DocType: Quality Action,Quality Action,Kvalitná akcia
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,No of Interactions,Počet interakcií
DocType: BOM,Scrap Material Cost(Company Currency),Šrot materiálové náklady (Company mena)
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čiatočný a konečný čas pre \ 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,úloha Hmotnosť
DocType: Shipping Rule Condition,To Value,Chcete-li hodnota
DocType: Accounts Settings,Automatically Add Taxes and Charges from Item Tax Template,Automaticky pridávať dane a poplatky zo šablóny dane z položiek
DocType: Loyalty Program,Loyalty Program Type,Typ vernostného programu
DocType: Asset Movement,Stock Manager,Manažér zásob
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.,Platobný termín na riadku {0} je pravdepodobne duplicitný.
apps/erpnext/erpnext/public/js/setup_wizard.js,Agriculture (beta),Poľnohospodárstvo (beta)
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Packing Slip,List k balíku
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,Nastavenie SMS brány
DocType: Disease,Common Name,Spoločný názov
DocType: Customer Feedback Template Table,Customer Feedback Template Table,Tabuľka šablón spätnej väzby od zákazníkov
DocType: Employee Boarding Activity,Employee Boarding Activity,Aktivita nástupu zamestnancov
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,Krvný 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} sa nenachádza v platnom mzdovom období
DocType: Employee Benefit Application,Max Benefits (Yearly),Maximálne výhody (ročné)
DocType: Item,Inventory,Inventář
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Stiahnuť ako Json
DocType: Item,Sales Details,Predajné 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; už existuje pre {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.","Poradie, v ktorom sa majú sekcie zobraziť. 0 je prvý, 1 je druhý a tak ďalej."
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,Overiť zapísaný kurz pre študentov v študentskej skupine
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 poistné {0} už existuje pre jázd
DocType: Asset Movement Item,Source Location,Umiestnenie zdroja
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Name,Meno Institute
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter repayment Amount,"Prosím, zadajte splácanie Čiastka"
DocType: Shift Type,Working Hours Threshold for Absent,Prah pracovných hodín pre neprítomnosť
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.,Na základe celkovej výdavky môže byť viacnásobný zberný faktor. Ale konverzný faktor pre spätné odkúpenie bude vždy rovnaký pre všetky úrovne.
apps/erpnext/erpnext/config/help.py,Item Variants,Varianty Položky
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,Kusovník 2
DocType: Payment Order,PMO-,PMO-
DocType: HR Settings,Email Salary Slip to Employee,Email výplatnej páske pre zamestnancov
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áranie faktúr
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Select Possible Supplier,Zvoľte Možné dodávateľa
DocType: Communication Medium,Communication Medium Type,Typ komunikačného média
DocType: Customer,"Select, to make the customer searchable with these fields","Vyberte, ak chcete, aby sa zákazník stal pomocou týchto polí"
DocType: Shopify Settings,Import Delivery Notes from Shopify on Shipment,Importovať doručené poznámky z Shopify pri odoslaní
apps/erpnext/erpnext/templates/pages/projects.html,Show closed,Zobraziť uzatvorené
DocType: Issue Priority,Issue Priority,Priorita vydania
DocType: Leave Ledger Entry,Is Leave Without Pay,Je odísť 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 kategória je povinný pre položku investičného majetku
DocType: Fee Validity,Fee Validity,Platnosť 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},Táto {0} je v rozpore s {1} o {2} {3}
DocType: Student Attendance Tool,Students HTML,študenti HTML
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,{0}: {1} must be less than {2},{0}: {1} musí byť menej ako {2}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,"Select BOM, Qty and For Warehouse","Vyberte kusovník, množstvo a sklad"
DocType: GST HSN Code,GST HSN Code,GST kód HSN
DocType: Employee External Work History,Total Experience,Celková zkušenost
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Projects,otvorené projekty
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Packing Slip(s) cancelled,Balení Slip (y) zrušeno
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Investing,Peňažný tok z investovania
DocType: Program Course,Program Course,program kurzu
DocType: Healthcare Service Unit,Allow Appointments,Povoliť schôdzky
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,Firemný slogan na titulnej stránke webu
DocType: Item Group,Item Group Name,Názov položkovej skupiny
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,Taken,Zaujatý
DocType: Invoice Discounting,Short Term Loan Account,Krátkodobý úverový účet
DocType: Student,Date of Leaving,Dátum odchodu
DocType: Pricing Rule,For Price List,Pre Cenní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,Nastavenie predvolených nastavení
DocType: Loyalty Program,Auto Opt In (For all customers),Automatická registrácia (pre všetkých zákazníkov)
apps/erpnext/erpnext/utilities/activation.py,Create Leads,Vytvoriť iniciatívu
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 potrebný na použitie predajného miesta
DocType: Cashier Closing,Net Amount,Čistá suma
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} has not been submitted so the action cannot be completed,"{0} {1} nebola odoslaná, takže akciu nemožno dokončiť"
DocType: Purchase Order Item Supplied,BOM Detail No,BOM Detail No
DocType: Support Search Source,Result Route Field,Výsledok Pole trasy
DocType: Supplier,PAN,PAN
DocType: Employee Checkin,Log Type,Typ denníka
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Dodatočná zľava Suma (Mena Company)
DocType: Supplier Scorecard,Supplier Scorecard,Hodnotiaca tabuľka dodávateľa
DocType: Plant Analysis,Result Datetime,Výsledok Datetime
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,From employee is required while receiving Asset {0} to a target location,Od príjemcu sa vyžaduje pri prijímaní aktíva {0} na cieľové miesto
,Support Hour Distribution,Distribúcia hodín podpory
DocType: Maintenance Visit,Maintenance Visit,Maintenance Visit
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Close Loan,Zatvorte pôžičku
DocType: Student,Leaving Certificate Number,maturita číslo
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,"Appointment cancelled, Please review and cancel the invoice {0}","Schôdza bola zrušená, skontrolujte a zrušte faktúru {0}"
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,K dispozícii dávky Množstvo v sklade
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Update Print Format,Aktualizácia Print Format
DocType: Bank Account,Is Company Account,Je firemný účet
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,Leave Type {0} is not encashable,Typ ponechania {0} nie je vymeniteľný
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Credit limit is already defined for the Company {0},Úverový limit je už pre spoločnosť definovaný {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,Zvoľte adresu pre dodanie
DocType: Timesheet Detail,Expected Hrs,Očakávané hodiny
apps/erpnext/erpnext/config/non_profit.py,Memebership Details,Informácie o členstve
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),Zadajte všetky požadované hodnoty výsledkov
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Accounts Receivable Summary,Pohledávky Shrnutí
DocType: POS Closing Voucher,Linked Invoices,Prepojené faktúry
DocType: Loan,Monthly Repayment Amount,Mesačné splátky čiastka
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices,Otvorenie faktúr
DocType: Contract,Contract Details,Detaily zmluvy
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please set User ID field in an Employee record to set Employee Role,Prosím nastavte používateľské ID v karte zamestnanca ak chcete umožniť rolu zamestnanca
DocType: UOM,UOM Name,Názov Mernej Jednotky
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 1,Na adresu 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ýška príspevku
DocType: Homepage Section,Section Order,Poradie sekcií
DocType: Inpatient Record,Patient Encounter,Stretnutie s pacientmi
DocType: Accounts Settings,Shipping Address,Dodacia 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,Neoverené údaje Webhook
DocType: Water Analysis,Container,kontajner
apps/erpnext/erpnext/education/utils.py,Student {0} - {1} appears Multiple times in row {2} & {3},Študent {0} - {1} objaví viackrát za sebou {2} {3}
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Following fields are mandatory to create address:,Na vytvorenie adresy sú povinné nasledujúce polia:
DocType: Item Alternative,Two-way,obojsmerný
apps/erpnext/erpnext/accounts/deferred_revenue.py,Error while processing deferred accounting for {0},Chyba pri spracovaní odloženého účtovania pre {0}
,Employee Billing Summary,Súhrn fakturácie zamestnancov
DocType: Project,Day to Send,Deň na odoslanie
DocType: Healthcare Settings,Manage Sample Collection,Správa kolekcie vzoriek
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set the series to be used.,"Nastavte prosím sériu, ktorú chcete použiť."
DocType: Patient,Tobacco Past Use,Použitie tabaku v minulosti
DocType: Travel Itinerary,Mode of Travel,Spôsob cestovania
DocType: Sales Invoice Item,Brand Name,Jméno značky
DocType: Purchase Receipt,Transporter Details,Transporter Podrobnosti
DocType: Issue,Service Level Agreement Creation,Vytvorenie dohody o úrovni služieb
apps/erpnext/erpnext/accounts/page/pos/pos.js,Default warehouse is required for selected item,Predvolené sklad je vyžadované pre vybraná položka
DocType: Quiz,Passing Score,Skóre skóre
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Possible Supplier,možné Dodávateľ
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,Zoznam príjemcov je prázdny. Prosím vytvorte zoznam príjemcov.
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 sa nezhoduje s formátom GSTIN pre držiteľov UIN alebo nerezidentných poskytovateľov služieb OIDAR
apps/erpnext/erpnext/public/js/setup_wizard.js,Healthcare (beta),Zdravotníctvo (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",Pre položku {0} nebol nájdený aktívny kusovník. Dodanie pomocou sériového čísla nie je možné zabezpečiť
DocType: Sales Partner,Sales Partner Target,Sales Partner Target
DocType: Loan Type,Maximum Loan Amount,Maximálna výška úveru
DocType: Coupon Code,Pricing Rule,Cenové pravidlo
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplicitné číslo rolky pre študenta {0}
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplicitné číslo rolky pre študentov {0}
apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Materiál Žiadosť o príkaze k nákupu
DocType: Company,Default Selling Terms,Predvolené podmienky predaja
DocType: Shopping Cart Settings,Payment Success URL,Platba Úspech URL
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Returned Item {1} does not exists in {2} {3},Riadok # {0}: vrátenej 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,Bankové účty
,Bank Reconciliation Statement,Bank Odsouhlasení prohlášení
DocType: Patient Encounter,Medical Coding,Lekárske kódovanie
DocType: Healthcare Settings,Reminder Message,Pripomenutie správy
DocType: Call Log,Lead Name,Meno Obchodnej iniciatívy
,POS,POS
DocType: C-Form,III,III
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Prospecting,prieskum
apps/erpnext/erpnext/config/help.py,Opening Stock Balance,Otvorenie Sklad Balance
DocType: Asset Category Account,Capital Work In Progress Account,Účet Kapitálu Rozrobenosti
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Value Adjustment,Úprava hodnoty majetku
DocType: Additional Salary,Payroll Date,Dátum mzdy
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,{0} must appear only once,{0} môže byť uvedené iba raz
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,Leaves Allocated Successfully for {0},Listy Přidělené úspěšně za {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,Momentálne sú podporované iba súbory .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žstvo je povinné
DocType: Loan,Repayment Method,splácanie Method
DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Ak je zaškrtnuté, domovská stránka bude východiskový bod skupina pre webové stránky"
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,Čakajúce množstvo
apps/erpnext/erpnext/utilities/activation.py,"Students are at the heart of the system, add all your students","Študenti sú v centre systému, pridajte všetky svoje študentov"
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Member ID,ID člena
DocType: Employee Tax Exemption Proof Submission,Monthly Eligible Amount,Mesačná oprávnená suma
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Riadok # {0}: dátum Svetlá {1} nemôže byť pred Cheque Dátum {2}
DocType: Asset Maintenance Task,Certificate Required,Potrebný certifikát
DocType: Company,Default Holiday List,Východzí zoznam sviatkov
DocType: Pricing Rule,Supplier Group,Skupina dodávateľov
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},Riadok {0}: čas od času aj na čas z {1} sa prekrýva s {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Liabilities,Zásoby Pasíva
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 spoločnosť
,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ôže vám sledovať zmluvy na základe dodávateľa, zákazníka a zamestnanca"
DocType: Company,Discount Received Account,Zľavový prijatý účet
DocType: Appointment Booking Settings,Enable Appointment Scheduling,Povoliť plánovanie schôdzky
DocType: Student Report Generation Tool,Print Section,Tlačiť sekciu
DocType: Staffing Plan Detail,Estimated Cost Per Position,Odhadovaná cena za pozíciu
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.,Používateľ {0} nemá predvolený profil POS. Začiarknite predvolené nastavenie v riadku {1} pre tohto používateľa.
DocType: Quality Meeting Minutes,Quality Meeting Minutes,Zápisnica zo zasadnutia o kvalite
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Employee Referral,Odporúčanie zamestnancov
DocType: Student Group,Set 0 for no limit,Nastavte 0 pre žiadny 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 deň, keď (y), na ktoré žiadate o povolenie sú prázdniny. Nemusíte požiadať o voľno."
DocType: Customer,Primary Address and Contact Detail,Primárna adresa a podrobnosti kontaktu
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Resend Payment Email,Znovu poslať e-mail Payment
apps/erpnext/erpnext/templates/pages/projects.html,New task,novú úlohu
DocType: Appointment,Appointment,vymenovanie
apps/erpnext/erpnext/config/buying.py,Other Reports,Ostatné správy
apps/erpnext/erpnext/public/js/setup_wizard.js,Please select at least one domain.,Vyberte aspoň jednu doménu.
DocType: Dependent Task,Dependent Task,Závislá úloha
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to UIN holders,Spotrebný materiál vyrobený pre držiteľov 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},Leave 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.,Skúste plánovanie operácií pre X dní vopred.
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} voľných pracovných miest a {1} rozpočet pre {2} už naplánované pre dcérske spoločnosti {3}. \ Môžete plánovať až {4} voľné pracovné miesta a rozpočet {5} podľa personálneho plánu {6} pre materskú spoločnosť {3}.
DocType: HR Settings,Stop Birthday Reminders,Zastaviť pripomenutie narodenín
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set Default Payroll Payable Account in Company {0},"Prosím nastaviť predvolený účet mzdy, splatnú v spoločnosti {0}"
DocType: Pricing Rule Brand,Pricing Rule Brand,Značka pravidla stanovovania cien
DocType: Amazon MWS Settings,Get financial breakup of Taxes and charges data by Amazon ,Získajte finančné rozdelenie údajov o daniach a poplatkoch od spoločnosti Amazon
DocType: SMS Center,Receiver List,Zoznam príjemcov
DocType: Pricing Rule,Rule Description,Popis pravidla
apps/erpnext/erpnext/accounts/page/pos/pos.js,Search Item,hľadanie položky
DocType: Program,Allow Self Enroll,Povoliť vlastné prihlásenie
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,Polovičný dátum by mal byť medzi prácou od dátumu a dátumom ukončenia práce
DocType: Healthcare Settings,Healthcare Service Items,Položky zdravotníckych služieb
apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Neplatný čiarový kód. K tomuto čiarovému kódu nie je pripojená žiadna 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á zmena v hotovosti
DocType: Assessment Plan,Grading Scale,stupnica
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,Skladom v ruke
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",Pridajte zvyšné výhody {0} do aplikácie ako \ pro-rata
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the public administration '%s',"Prosím, nastavte daňový kód pre verejnú 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é položky
DocType: Healthcare Practitioner,Hospital,Nemocnica
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,Finančná čiastka
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Previous Financial Year is not closed,Predchádzajúci finančný rok nie je uzavretý
DocType: Practitioner Schedule,Practitioner Schedule,Pracovný rozvrh
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Age (Days),Staroba (dni)
DocType: Instructor,EDU-INS-.YYYY.-,EDU-INS-.YYYY.-
DocType: Additional Salary,Additional Salary,Dodatočný plat
DocType: Quotation Item,Quotation Item,Položka ponuky
DocType: Customer,Customer POS Id,ID zákazníka POS
apps/erpnext/erpnext/education/utils.py,Student with email {0} does not exist,Študent s e-mailom {0} neexistuje
DocType: Account,Account Name,Názov účtu
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.py,From Date cannot be greater than To Date,Dátum OD nemôže byť väčší ako dátum 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žite zľavu na sadzbu
DocType: Tally Migration,Tally Debtors Account,Účet Tally dlžníkov
DocType: Pricing Rule,Promotional Scheme,Propagačná schéma
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter Woocommerce Server URL,Zadajte URL servera Woocommerce
DocType: GSTR 3B Report,September,septembra
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ázov platby
DocType: Share Balance,To No,Nie
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Atleast one asset has to be selected.,Musí byť vybrané aspoň jedno aktívum.
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,All the mandatory Task for employee creation hasn't been done yet.,Všetky povinné úlohy na tvorbu zamestnancov ešte neboli vykonané.
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled or stopped,{0} {1} je zrušená alebo zastavená
DocType: Accounts Settings,Credit Controller,Credit Controller
DocType: Loan,Applicant Type,Typ žiadateľa
DocType: Purchase Invoice,03-Deficiency in services,03-Nedostatok služieb
DocType: Healthcare Settings,Default Medical Code Standard,Predvolený štandard medicínskeho kódu
DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
DocType: Project Template Task,Project Template Task,Úloha šablóny projektu
DocType: Accounts Settings,Over Billing Allowance (%),Príplatok za fakturáciu (%)
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-.YYYY.-
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Billed,{0}% fakturované
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 spoločnosť a označenie
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ýrobca
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Create New Lead,Vytvoriť nového potenciálneho zákazníka
DocType: BOM Operation,Batch Size,Veľkosť šarže
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Reject,Odmietnuť
DocType: Journal Entry Account,Debit in Company Currency,Debetnej v spoločnosti Mena
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Import Successfull,Import bol úspešný
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Material Request not created, as quantity for Raw Materials already available.","Požiadavka na materiál nebola vytvorená, pretože množstvo surovín je už k dispozícii."
DocType: BOM Item,BOM Item,BOM Item
DocType: Appraisal,For Employee,Pre zamestnanca
DocType: Leave Control Panel,Designation (optional),Označenie (voliteľné)
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.","Miera ocenenia nenájdená pre položku {0}, ktorá je potrebná na vykonanie účtovných zápisov pre {1} {2}. Ak položka obchoduje ako položka s nulovým hodnotením v {1}, uveďte to v tabuľke {1}. V opačnom prípade vytvorte prichádzajúcu transakciu zásob pre položku alebo uveďte hodnotu ocenenia v zázname o položke a potom skúste zadať / zrušiť túto položku."
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Supplier must be debit,Riadok {0}: Advance proti dodávateľom musí byť odpísať
DocType: Company,Default Values,Predvolené hodnoty
DocType: Certification Application,INR,INR
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Party Addresses,Adresy spracovateľských strán
DocType: Woocommerce Settings,Creation User,Vytvorenie používateľa
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 nájdete v protokole chýb
DocType: Bank Transaction,Reconciled,zmierený
DocType: Expense Claim,Total Amount Reimbursed,Celkovej sumy vyplatenej
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žené na protokoloch proti tomuto vozidlu. Pozri časovú os nižšie podrobnosti
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Payroll date can not be less than employee's joining date,Dátum výplaty nemôže byť nižší ako dátum pripojenia zamestnanca
DocType: Pick List,Item Locations,Polohy položiek
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.py,{0} {1} created,{0} {1} vytvoril
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}",Otvorené pracovné miesta na označenie {0} už otvorené alebo dokončené na základe Personálneho plánu {1}
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,You can publish upto 200 items.,Môžete publikovať až 200 položiek.
DocType: Vital Signs,Constipated,zápchu
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,Predvolený cenník
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Asset Movement record {0} created,Záznam Asset Pohyb {0} vytvoril
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,Nemožno odstrániť fiškálny rok {0}. Fiškálny rok {0} je nastavený ako predvolený v globálnom nastavení
DocType: Share Transfer,Equity/Liability Account,Účet vlastného imania / zodpovednosti
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py,A customer with the same name already exists,Zákazník s rovnakým názvom už 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ýmto sa odošlú výplatné pásky a vytvorí sa účtovníctvo časového rozlíšenia. Chcete pokračovať?
DocType: Purchase Invoice,Total Net Weight,Celková čistá hmotnosť
DocType: Purchase Order,Order Confirmation No,Potvrdenie 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,Spôsobilosť pre 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á Zmena účty záväzkov
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Credit limit has been crossed for customer {0} ({1}/{2}),Úverový limit bol pre zákazníka prekročený {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žstvo
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Pricing,Stanovenie ceny
DocType: Employee,Attendance Device ID (Biometric/RF tag ID),ID dochádzkového zariadenia (biometrické / RF ID značky)
DocType: Quotation,Term Details,Termín Podrobnosti
DocType: Item,Over Delivery/Receipt Allowance (%),Príspevok na prekročenie dodávky / príjem (%)
DocType: Employee Incentive,Employee Incentive,Zamestnanecké stimuly
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Cannot enroll more than {0} students for this student group.,Nemôže prihlásiť viac ako {0} študentov na tejto študentské skupiny.
apps/erpnext/erpnext/templates/print_formats/includes/total.html,Total (Without Tax),Spolu (bez dane)
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Lead Count,Počet iniciatív
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Lead Count,Počet iniciatív
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Stock Available,Skladom k dispozícii
DocType: Manufacturing Settings,Capacity Planning For (Days),Plánovanie kapacít Pro (dni)
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py,Procurement,Obstarávanie
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,None of the items have any change in quantity or value.,Žiadna z týchto položiek nemá zmenu v množstve alebo hodnote.
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Program,Povinné pole - Program
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Program,Povinné pole - Program
DocType: Special Test Template,Result Component,Zložka výsledkov
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js,Warranty Claim,Záruční reklamace
,Lead Details,Podrobnosti Obchodnej iniciatívy
DocType: Volunteer,Availability and Skills,Dostupnosť a zručnosti
DocType: Salary Slip,Loan repayment,splácania úveru
DocType: Share Transfer,Asset Account,Asset Account
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Nový dátum vydania by mal byť v budúcnosti
DocType: Purchase Invoice,End date of current invoice's period,Datum ukončení doby aktuální faktury je
DocType: Lab Test,Technician Name,Názov technikov
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.","Nie je možné zabezpečiť doručenie sériovým číslom, pretože je pridaná položka {0} s alebo bez dodávky."
DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Odpojiť Platba o zrušení faktúry
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Aktuálny stav km vstúpil by mala byť väčšia ako počiatočný stav kilometrov {0}
,Purchase Order Items To Be Received or Billed,"Položky objednávok, ktoré majú byť prijaté alebo fakturované"
DocType: Restaurant Reservation,No Show,Žiadne zobrazenie
apps/erpnext/erpnext/regional/india/utils.py,You must be a registered supplier to generate e-Way Bill,"Ak chcete generovať faktúru za e-Way, musíte byť registrovaným dodávateľom"
DocType: Shipping Rule Country,Shipping Rule Country,Prepravné Pravidlo Krajina
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Leave and Attendance,Priepustky a dochádzky
DocType: Asset,Comprehensive Insurance,Komplexné poistenie
DocType: Maintenance Visit,Partially Completed,Částečně Dokončeno
apps/erpnext/erpnext/public/js/event.js,Add Leads,Pridať návrhy
apps/erpnext/erpnext/healthcare/setup.py,Moderate Sensitivity,Stredná citlivosť
DocType: Leave Type,Include holidays within leaves as leaves,Zahrnúť dovolenku v listoch sú listy
DocType: Loyalty Program,Redemption,vykúpenie
DocType: Sales Invoice,Packed Items,Zabalené položky
DocType: Tally Migration,Vouchers,poukážky
DocType: Tax Withholding Category,Tax Withholding Rates,Sadzby zrážkovej dane
DocType: Contract,Contract Period,Zmluvné obdobie
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',&quot;Celkom&quot;
DocType: Shopping Cart Settings,Enable Shopping Cart,Povolit Nákupní košík
DocType: Employee,Permanent Address,Trvalé bydliště
DocType: Loyalty Program,Collection Tier,Zbierka Tier
apps/erpnext/erpnext/hr/utils.py,From date can not be less than employee's joining date,Od dátumu nemôže byť menej ako dátum spájania zamestnanca
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}",Vyplatená záloha proti {0} {1} nemôže byť väčšia \ než Grand Celkom {2}
DocType: Patient,Medication,liečenie
DocType: Production Plan,Include Non Stock Items,"Zahrňte položky, ktoré nie sú na sklade"
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,Štúdium v Same ústave
DocType: Leave Type,Earned Leave,Získaná dovolenka
apps/erpnext/erpnext/erpnext_integrations/connectors/shopify_connection.py,Tax Account not specified for Shopify Tax {0},Daňový účet nie je uvedený pre daň z obchodov {0}
DocType: Employee,Salary Details,Podrobnosti platu
DocType: Territory,Territory Manager,Oblastní manažer
DocType: Packed Item,To Warehouse (Optional),Warehouse (voliteľné)
DocType: GST Settings,GST Accounts,Účty GST
DocType: Payment Entry,Paid Amount (Company Currency),Zaplatená suma (Company meny)
DocType: Purchase Invoice,Additional Discount,Ďalšie zľavy
DocType: Selling Settings,Selling Settings,Nastavenia pre Predaj
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žstvo alebo Pomer ocenenia, alebo obidve."
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py,Fulfillment,splnenie
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,View in Cart,Zobraziť Košík
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Purchase Invoice cannot be made against an existing asset {0},Nákupnú faktúru nie je možné uplatniť proti existujúcemu dielu {0}
DocType: Employee Checkin,Shift Actual Start,Shift Skutočný štart
DocType: Tally Migration,Is Day Book Data Imported,Importujú sa údaje dennej knihy
,Purchase Order Items To Be Received or Billed1,"Položky objednávok, ktoré majú byť prijaté alebo fakturované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} jednotiek z {1} nie je k dispozícii.
,Item Shortage Report,Položka Nedostatek Report
DocType: Bank Transaction Payments,Bank Transaction Payments,Platby bankových transakcií
apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py,Can't create standard criteria. Please rename the criteria,Štandardné kritériá sa nedajú vytvoriť. Premenujte kritériá
apps/erpnext/erpnext/stock/doctype/item/item.js,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Hmotnosť je uvedená, \n uveďte prosím aj ""váhu MJ"""
apps/erpnext/erpnext/hr/doctype/attendance/attendance_list.js,For Month,Za mesiac
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Materiál Žádost používá k výrobě této populace Entry
DocType: Hub User,Hub Password,Heslo Hubu
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Samostatná skupina kurzov pre každú dávku
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Samostatná skupina kurzov pre každú dávku
,Sales Partner Target Variance based on Item Group,Cieľová odchýlka odbytového partnera na základe skupiny položiek
apps/erpnext/erpnext/config/support.py,Single unit of an Item.,Single jednotka položky.
DocType: Fee Category,Fee Category,poplatok Kategórie
DocType: Agriculture Task,Next Business Day,Nasledujúci pracovný deň
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Allocated Leaves,Pridelené listy
DocType: Drug Prescription,Dosage by time interval,Dávkovanie podľa časového intervalu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Total Taxable Value,Celková zdaniteľná hodnota
DocType: Cash Flow Mapper,Section Header,Záhlavie sekcie
,Student Fee Collection,Študent Fee Collection
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Appointment Duration (mins),Dĺžka schôdzky (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,Zadajte platné dátumy začiatku a konca finančného roka
DocType: Employee,Date Of Retirement,Dátum odchodu do dôchodku
apps/erpnext/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py,Asset Value,Hodnota aktív
DocType: Upload Attendance,Get Template,Získat šablonu
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Pick List,Vyberte zoznam
,Sales Person Commission Summary,Súhrnný prehľad komisie pre predajcov
DocType: Material Request,Transferred,prevedená
DocType: Vehicle,Doors,dvere
DocType: Healthcare Settings,Collect Fee for Patient Registration,Získať poplatok za registráciu 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,Atribúty nie je možné zmeniť po transakcii s akciami. Vytvorte novú položku a presuňte materiál do novej položky
DocType: Course Assessment Criteria,Weightage,Weightage
DocType: Purchase Invoice,Tax Breakup,Daňové rozdelenie
DocType: Employee,Joining Details,Podrobnosti spojenia
DocType: Member,Non Profit Member,Neziskový člen
DocType: Email Digest,Bank Credit Balance,Zostatok bankového úveru
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 potrebné nákladového strediska pre &#39;zisku a straty &quot;účtu {2}. Prosím nastaviť predvolené nákladového strediska pre spoločnosť.
DocType: Payment Schedule,Payment Term,Lehota splatnosti
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ěnit název zákazníka nebo přejmenujte skupinu zákazníků"
DocType: Location,Area,rozloha
apps/erpnext/erpnext/public/js/templates/contact_list.html,New Contact,Nový kontakt
DocType: Company,Company Description,Popis firmy
DocType: Territory,Parent Territory,Parent Territory
DocType: Purchase Invoice,Place of Supply,Miesto 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},Zamestnanec {0} už predložil žiadosť {1} pre mzdové obdobie {2}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Material Receipt,Příjem materiálu
DocType: Bank Statement Transaction Entry,Submit/Reconcile Payments,Odoslať / Zosúladiť platby
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ískajte faktúry na základe filtrov
DocType: Announcement,Instructor,inštruktor
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Quantity to Manufacture can not be zero for the operation {0},Množstvo na výrobu nemôže byť pre operáciu nulové {0}
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Select Item (optional),Vyberte položku (voliteľné)
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,The Loyalty Program isn't valid for the selected company,Vernostný program nie je platný pre vybranú firmu
DocType: Fee Schedule Student Group,Fee Schedule Student Group,Poplatkový študijný program
DocType: Student,AB+,AB +
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Ak je táto položka má varianty, potom to nemôže byť vybraná v predajných objednávok atď"
apps/erpnext/erpnext/config/selling.py,Define coupon codes.,Definujte kódy kupónov.
DocType: Products Settings,Hide Variants,Skryť varianty
DocType: Lead,Next Contact By,Další Kontakt By
DocType: Compensatory Leave Request,Compensatory Leave Request,Žiadosť o kompenzačnú dovolenku
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","Nie je možné preplatiť položku {0} v riadku {1} viac ako {2}. Ak chcete povoliť nadmernú fakturáciu, nastavte príspevok v nastaveniach účtov"
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 Suma nákupu
DocType: Asset,Depreciation Method,odpisy Metóda
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ímania
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Integrated Tax,Integrovaná daň
DocType: Soil Texture,Sand Composition (%),Zloženie piesku (%)
DocType: Job Applicant,Applicant for a Job,Žadatel o zaměstnání
DocType: Production Plan Material Request,Production Plan Material Request,Výroba Dopyt Plán Materiál
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Automatic Reconciliation,Automatické vyrovnanie
DocType: Purchase Invoice,Release Date,Dátum vydania
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,Názov predajcu Hubu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Employee Advances,Zamestnanecké zálohy
DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Povoliť viac Predajné objednávky proti Zákazníka Objednávky
DocType: Student Group Instructor,Student Group Instructor,Inštruktor skupiny študentov
DocType: Student Group Instructor,Student Group Instructor,Inštruktor skupiny študentov
DocType: Grant Application,Assessment  Mark (Out of 10),Značka hodnotenia (z 10)
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Mobile No,Guardian2 Mobile Žiadne
apps/erpnext/erpnext/setup/doctype/company/company.py,Main,Hlavné
DocType: GSTR 3B Report,July,júl
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,Nasledujúca položka {0} nie je označená ako položka {1}. Môžete ich povoliť ako {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",Pre položku {0} musí byť množstvo záporné
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,Zamestnanci HTML
apps/erpnext/erpnext/stock/doctype/item/item.py,Default BOM ({0}) must be active for this item or its template,Predvolené BOM ({0}) musí byť aktívna pre túto položku alebo jeho šablóny
DocType: Employee,Leave Encashed?,Ponechte zpeněžení?
apps/erpnext/erpnext/regional/report/datev/datev.py,<b>From Date</b> is a mandatory filter.,<b>Od dátumu</b> je povinný filter.
DocType: Email Digest,Annual Expenses,ročné náklady
DocType: Item,Variants,Varianty
DocType: SMS Center,Send To,Odoslať na
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,Príspevok na celkom netto
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Manufactured,vyrábané
DocType: Sales Invoice Item,Customer's Item Code,Zákazníka Kód položky
DocType: Stock Reconciliation,Stock Reconciliation,Inventúra zásob
DocType: Territory,Territory Name,Území Name
DocType: Email Digest,Purchase Orders to Receive,Nákupné príkazy na príjem
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 predplatnom môžete mať len Plány s rovnakým účtovacím cyklom
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,Dátum mzdového obdobia
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
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,Sila študentskej skupiny
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Student Group Strength,Sila študentskej skupiny
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","Dcérske spoločnosti už plánovali {1} voľné pracovné miesta s rozpočtom {2}. \ Personálny plán pre {0} by mal prideliť ďalšie voľné pracovné miesta a rozpočet na {3}, ako sa plánovalo pre dcérske spoločnosti"
apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py,Training Events,Školenia
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,Cieľ preskúmania kvality
apps/erpnext/erpnext/config/crm.py,Track Leads by Lead Source.,Track Leads by Lead Zdroj.
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 zadajte
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Maintenance Log,Denník ú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 nastaviť filter na základe výtlačku alebo v sklade
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%,Suma zľavy nemôže byť vyššia ako 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 centier, bude zahrnuté v názve nákladového strediska ako predponu"
DocType: Sales Order,To Deliver and Bill,Dodať a Bill
DocType: Student Group,Instructors,inštruktori
DocType: GL Entry,Credit Amount in Account Currency,Kreditné Čiastka v mene účtu
DocType: Stock Entry,Receive at Warehouse,Prijať do skladu
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Accounting Dimension <b>{0}</b> is required for 'Profit and Loss' account {1}.,Účtovná dimenzia <b>{0}</b> sa vyžaduje pre účet „Zisk a strata“ {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 podielov
DocType: Authorization Control,Authorization Control,Autorizace Control
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Riadok # {0}: zamietnutie Warehouse je povinná proti zamietnutej bodu {1}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Received Stock Entries,Prijaté položky zásob
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Payment,Splátka
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} nie je prepojený s žiadnym účtom, uveďte účet v zozname skladov alebo nastavte predvolený inventárny účet v spoločnosti {1}."
apps/erpnext/erpnext/utilities/activation.py,Manage your orders,Spravovať svoje objednávky
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,Rozdelenie plodín
DocType: Budget,Action if Annual Budget Exceeded on PO,"Opatrenie, ak bol prekročený ročný rozpočet na PO"
DocType: Issue,Service Level,Úroveň služieb
DocType: Student Leave Application,Student Leave Application,Študent nechať aplikáciu
DocType: Item,Will also apply for variants,Bude platiť aj pre varianty
apps/erpnext/erpnext/assets/doctype/asset/asset.py,"Asset cannot be cancelled, as it is already {0}","Asset nemožno zrušiť, pretože je už {0}"
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} on Half day on {1},Zamestnancov {0} o pol dňa na {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Total working hours should not be greater than max working hours {0},Celkom pracovná doba by nemala byť väčšia ako maximálna pracovnej 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,Nastavenia odosielania
DocType: Material Request Plan Item,Actual Qty,Skutečné Množství
DocType: Sales Invoice Item,References,Referencie
DocType: Quality Inspection Reading,Reading 10,Čtení 10
DocType: Item,Barcodes,čiarové 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,Importujú sa kmeňové údaje
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,Musí sa odoslať pracovná objednávka {0}
apps/erpnext/erpnext/accounts/page/pos/pos.js,New Cart,new košík
DocType: Taxable Salary Slab,From Amount,Z čiastky
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,inkaso
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.js,Select a company,Vyberte spoločnosť
DocType: Delivery Settings,Delivery Settings,Nastavenia doručenia
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Fetch Data,Načítať údaje
apps/erpnext/erpnext/hr/doctype/leave_policy/leave_policy.py,Maximum leave allowed in the leave type {0} is {1},Maximálna povolená dovolenka v type dovolenky {0} je {1}
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Publish 1 Item,Zverejniť 1 položku
DocType: SMS Center,Create Receiver List,Vytvoriť zoznam príjemcov
DocType: Student Applicant,LMS Only,Iba LMS
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available-for-use Date should be after purchase date,Dátum dostupný na použitie by mal byť po dátume nákupu
DocType: Vehicle,Wheels,kolesá
DocType: Packing Slip,To Package No.,Balit No.
DocType: Patient Relation,Family,Rodina
DocType: Invoice Discounting,Invoice Discounting,Diskontovanie faktúry
DocType: Sales Invoice Item,Deferred Revenue Account,Účet odloženého výnosu
DocType: Production Plan,Material Requests,materiál Žiadosti
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á účasť na dňoch
DocType: Sales Invoice Timesheet,Timesheet Detail,Detail pracovného výkazu
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: {},K týmto filtrom nezodpovedal žiadny účet: {}
apps/erpnext/erpnext/accounts/party.py,Billing currency must be equal to either default company's currency or party account currency,Mena fakturácie sa musí rovnať mene menovej jednotky alebo účtovnej parity
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ý zostatok
DocType: Soil Texture,Loam,hlina
apps/erpnext/erpnext/controllers/accounts_controller.py,Row {0}: Due Date cannot be before posting date,Riadok {0}: dátum splatnosti nemôže byť pred dátumom odoslania
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,Pre
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,Dodací sklad
DocType: Leave Type,Earned Leave Frequency,Frekvencia získanej dovolenky
apps/erpnext/erpnext/config/accounts.py,Tree of financial Cost Centers.,Strom Nákl.stredisko finančných.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Sub Type,Sub typ
DocType: Serial No,Delivery Document No,Dodávka dokument č
DocType: Sales Order Item,Ensure Delivery Based on Produced Serial No,Zabezpečte doručenie na základe 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;/ STRATY zisk z aktív odstraňovaním&quot; vo firme {0}
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Add to Featured Item,Pridať k odporúčanej položke
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Získat položky z Příjmového listu
DocType: Serial No,Creation Date,Dátum vytvorenia
DocType: GSTR 3B Report,November,november
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,Položka dodávateľskej ponuky
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Material Consumption is not set in Manufacturing Settings.,Spotreba materiálu nie je nastavená v nastaveniach výroby.
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,View all issues from {0},Zobraziť všetky čísla od {0}
DocType: Quality Inspection,MAT-QA-.YYYY.-,MAT-QA-.YYYY.-
DocType: Quality Meeting Table,Quality Meeting Table,Tabuľka stretnutí kvality
apps/erpnext/erpnext/templates/pages/help.html,Visit the forums,Navštívte fóra
DocType: Student,Student Mobile Number,Študent Číslo mobilného telefónu
DocType: Item,Has Variants,Má varianty
DocType: Employee Benefit Claim,Claim Benefit For,Nárok na dávku pre
apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Aktualizácia odpovede
apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Už ste vybrané položky z {0} {1}
DocType: Monthly Distribution,Name of the Monthly Distribution,Názov mesačného rozdelenia
DocType: Quality Procedure Process,Quality Procedure Process,Proces kvality
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Batch ID is mandatory,Číslo šarže je povinné
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,Najskôr 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,"Žiadne položky, ktoré sa majú dostať, nie sú oneskorené"
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The seller and the buyer cannot be the same,Predávajúci a kupujúci nemôžu byť rovnakí
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,No views yet,Zatiaľ žiadne zobrazenia
DocType: Project,Collect Progress,Zbierajte postup
DocType: Delivery Note,MAT-DN-.YYYY.-,MAT-DN-.YYYY.-
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Select the program first,Najprv vyberte program
DocType: Patient Appointment,Patient Age,Vek pacienta
apps/erpnext/erpnext/config/help.py,Managing Projects,Správa projektov
DocType: Quiz,Latest Highest Score,Najvyššie skóre
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial no {0} has been already returned,Sériové číslo {0} už bolo vrátené
DocType: Supplier,Supplier of Goods or Services.,Dodavatel zboží nebo služeb.
DocType: Budget,Fiscal Year,Fiškálny rok
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Only users with the {0} role can create backdated leave applications,Aplikácie s neaktívnou dovolenkou môžu vytvárať iba používatelia s rolí {0}
DocType: Asset Maintenance Log,Planned,plánovaná
apps/erpnext/erpnext/hr/utils.py,A {0} exists between {1} and {2} (,A {0} existuje medzi {1} a {2} (
DocType: Vehicle Log,Fuel Price,palivo Cena
DocType: BOM Explosion Item,Include Item In Manufacturing,Zahrnúť položku do výroby
DocType: Item,Auto Create Assets on Purchase,Automatické vytváranie aktív pri nákupe
DocType: Bank Guarantee,Margin Money,Margin Money
DocType: Budget,Budget,Rozpočet
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Set Open,Otvorte Otvoriť
apps/erpnext/erpnext/stock/doctype/item/item.py,Fixed Asset Item must be a non-stock item.,Fixed Asset položky musia byť 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 nemožno priradiť proti {0}, pretože to nie je výnos alebo náklad účet"
DocType: Quality Review Table,Achieved,Dosažená
DocType: Student Admission,Application Form Route,prihláška Trasa
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,End Date of Agreement can't be less than today.,Dátum ukončenia dohody nemôže byť nižší ako dnes.
apps/erpnext/erpnext/public/js/hub/components/CommentInput.vue,Ctrl + Enter to submit,Ctrl + Enter na odoslanie
DocType: Healthcare Settings,Patient Encounters in valid days,Stretnutia pacientov v platných dňoch
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leave Type {0} cannot be allocated since it is leave without pay,"Nechať Typ {0} nemôže byť pridelená, pretože sa odísť bez zaplatenia"
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,Nasleduj
apps/erpnext/erpnext/accounts/report/financial_statements.py,Cost Center: {0} does not exist,Nákladové stredisko: {0} neexistuje
DocType: Item,Is Sales Item,Je Sales Item
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,Item Group Tree,Strom položkových skupín
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,"Suma, ktorá má dodávať"
DocType: Asset,Insurance Start Date,Dátum začatia poistenia
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ý Dátum začatia nemôže byť skôr ako v roku dátum začiatku akademického roka, ku ktorému termín je spojená (akademický rok {}). Opravte dáta a skúste to znova."
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,Nepodarilo sa nastaviť predvolené hodnoty
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Employee {0} has already applied for {1} between {2} and {3} : ,Zamestnanec {0} už požiadal {1} medzi {2} a {3}:
DocType: Guardian,Guardian Interests,Guardian záujmy
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Name / Number,Aktualizovať názov / číslo účtu
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,Niekoľko fiškálnych rokov existujú pre dáta {0}. Prosím nastavte spoločnosť vo fiškálnom roku
DocType: Education Settings,Instructor Records to be created by,"Záznamy inštruktorov, ktoré vytvorí"
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,{0} created,{0} vytvoril
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úci
DocType: Supplier,Warn POs,Upozorňujte organizácie výrobcov
,Daily Timesheet Summary,Denný súhrn pracovných výkazov
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žené na akciovom pohybu. Pozri {0} Podrobnosti
DocType: Pricing Rule,Selling,Predaj
DocType: Payment Entry,Payment Order Status,Stav platobného príkazu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} deducted against {2},Množstvo {0} {1} odpočítať proti {2}
DocType: Sales Person,Name and Employee ID,Meno a ID zamestnanca
DocType: Promotional Scheme,Promotional Scheme Product Discount,Zľava na propagačnú schému
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,Žiadna schéma platu sa nepodarilo predložiť na vyššie uvedené kritériá ALEBO platový výkaz už bol predložený
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Duties and Taxes,Odvody a dane
DocType: Projects Settings,Projects Settings,Nastavenia projektov
DocType: Purchase Receipt Item,Batch No!,Šarža č.
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} platobné položky nemôžu byť filtrované podľa {1}
DocType: Item Website Specification,Table for Item that will be shown in Web Site,"Tabuľka k Položke, která sa zobrazí na webových stránkách"
DocType: Purchase Order Item Supplied,Supplied Qty,Dodávané Množstvo
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,Zatiaľ žiadne recenzie
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,Predané
,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ákladná suma (Company Currency)
DocType: Purchase Invoice,Registered Regular,Pravidelná registrácia
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Raw Materials,Suroviny
DocType: Payment Reconciliation Payment,Reference Row,referenčnej Row
DocType: Installation Note,Installation Time,Instalace Time
DocType: Sales Invoice,Accounting Details,Účtovné Podrobnosti
DocType: Shopify Settings,status html,status html
apps/erpnext/erpnext/setup/doctype/company/company.js,Delete all the Transactions for this Company,Odstráňte všetky transakcie pre túto spoločnosť
DocType: Designation,Required Skills,Požadované zručnosti
DocType: Inpatient Record,O Positive,O pozitívne
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 transakcie
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, zadajte Žiadosti materiál vo vyššie uvedenej tabuľke"
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments available for Journal Entry,Pre položku zápisu nie sú k dispozícii žiadne splátky
DocType: Hub Tracked Item,Image List,Zoznam obrázkov
DocType: Item Attribute,Attribute Name,Názov atribútu
DocType: Subscription,Generate Invoice At Beginning Of Period,Generovanie faktúry na začiatku obdobia
DocType: BOM,Show In Website,Zobraziť na webstránke
DocType: Loan Application,Total Payable Amount,Celková suma Splatné
DocType: Task,Expected Time (in hours),Predpokladaná doba (v hodinách)
DocType: Item Reorder,Check in (group),Check in (skupina)
DocType: Soil Texture,Silt,kal
,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áväzkom alebo vlastným imaním, v ktorom budú Zisk / strata rezervovať"
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},Ďalší rozpočetový záznam {0} už existuje proti {1} &#39;{2}&#39; a účet {3} pre fiškálny 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,margin Type
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,{0} hours,{0} hodín
DocType: Course,Default Grading Scale,Predvolené Stupnica
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é priestory
DocType: C-Form Invoice Detail,Invoice No,Faktúra č.
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Make Payment,Vykonať platbu
DocType: Room,Room Name,Room Meno
DocType: Prescription Duration,Prescription Duration,Trvanie predpisu
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}","Nechajte nemožno aplikovať / zrušená pred {0}, pretože rovnováha dovolenky už bolo carry-odovzdávané v budúcej pridelenie dovolenku záznamu {1}"
DocType: Activity Cost,Costing Rate,Sadzba kalkulácie nákladov
apps/erpnext/erpnext/config/selling.py,Customer Addresses And Contacts,Adresy zákazníkov a kontakty
DocType: Homepage Section,Section Cards,Karty sekcií
,Campaign Efficiency,Efektívnosť kampane
,Campaign Efficiency,Efektívnosť kampane
DocType: Discussion,Discussion,diskusia
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Sales Order Submission,O zadaní zákazky odberateľa
DocType: Bank Transaction,Transaction ID,ID transakcie
DocType: Payroll Entry,Deduct Tax For Unsubmitted Tax Exemption Proof,Odpočítajte daň z nezdaniteľnej daňovej výnimky
DocType: Volunteer,Anytime,kedykoľvek
DocType: Bank Account,Bank Account No,Číslo bankového účtu
DocType: Employee Tax Exemption Proof Submission,Employee Tax Exemption Proof Submission,Oslobodenie od dane z oslobodenia od dane zamestnancov
DocType: Patient,Surgical History,Chirurgická história
DocType: Bank Statement Settings Item,Mapped Header,Zmapovaná hlavička
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 sa použije na vytvorenie zákaziek odberateľa. Núdzový sklad je „Obchody“.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Please set the Date Of Joining for employee {0},Nastavte dátum založenia pre zamestnanca {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Please set the Date Of Joining for employee {0},Nastavte dátum založenia pre zamestnanca {0}
DocType: Inpatient Record,Discharge,výtok
DocType: Task,Total Billing Amount (via Time Sheet),Celková suma Billing (cez Time Sheet)
apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js,Create Fee Schedule,Vytvorte rozvrh poplatkov
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 Pomenovací systém inštruktorov v časti Vzdelanie&gt; Nastavenia vzdelávania
DocType: Quiz,Enter 0 to waive limit,"Ak chcete upustiť od limitu, zadajte 0"
DocType: Bank Statement Settings,Mapped Items,Mapované položky
DocType: Amazon MWS Settings,IT,IT
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""","Nechajte doma prázdne. Ide o relatívnu adresu URL stránky, napríklad „about“ presmeruje na „https://yoursitename.com/about“"
,Fixed Asset Register,Register fixných aktív
DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,"Predvolený účet sa automaticky aktualizuje v POS faktúre, keď je vybratý tento režim."
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select BOM and Qty for Production,Vyberte BOM a Množstvo na 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 mala byť v rozmedzí od dátumu a do dnešného dňa
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 štandardné cenové centrum v spoločnosti {0}.
apps/erpnext/erpnext/projects/doctype/project/project.py,Daily Project Summary for {0},Zhrnutie 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ý Billing: {0}
DocType: Shopify Webhook Detail,Shopify Webhook Detail,Nakupujte podrobnosti Webhook
apps/erpnext/erpnext/config/accounts.py,Goods and Services Tax (GST India),Daň z tovarov a služieb (GST India)
DocType: Delivery Note,Excise Page Number,Spotřební Číslo stránky
DocType: Asset,Purchase Date,Dátum nákupu
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Could not generate Secret,Tajomstvo sa nepodarilo vytvoriť
DocType: Volunteer,Volunteer Type,Typ dobrovoľníka
DocType: Payment Request,ACC-PRQ-.YYYY.-,ACC-PRQ-.YYYY.-
DocType: Shift Assignment,Shift Type,Typ posunu
DocType: Student,Personal Details,Osobné údaje
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,Export E-Invoices,Export elektronických faktúr
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é stredisko&quot; vo firme {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.",Nie je dostatok diel vytvorených alebo prepojených na {0}. \ Vytvorte alebo prepojte {1} Aktíva s príslušným dokumentom.
DocType: Pricing Rule,Apply Rule On Brand,Použiť pravidlo na značku
DocType: Task,Actual End Date (via Time Sheet),Skutočný dátum ukončenia (cez Time Sheet)
apps/erpnext/erpnext/projects/doctype/task/task.py,Cannot close task {0} as its dependant task {1} is not closed.,"Úlohu {0} nemožno zavrieť, pretože jej závislá úloha {1} nie je uzavretá."
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žstvo {0} {1} na {2} {3}
,Quotation Trends,Vývoje ponúk
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Item Group not mentioned in item master for item {0},Položková skupina nie je uvedená v hlavnej položke pre  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 pre položku {0} v riadku {1}
DocType: Shipping Rule,Shipping Amount,Prepravovaná čiastka
DocType: Supplier Scorecard Period,Period Score,Skóre obdobia
apps/erpnext/erpnext/public/js/event.js,Add Customers,Pridajte zákazníkov
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,špeciálna
DocType: Loyalty Program,Conversion Factor,Konverzný koeficient
DocType: Purchase Order,Delivered,Dodané
,Vehicle Expenses,Náklady pre autá
DocType: Healthcare Settings,Create Lab Test(s) on Sales Invoice Submit,Vytvorte laboratórne testy na odoslanie faktúry predaja
DocType: Serial No,Invoice Details,Podrobnosti faktúry
apps/erpnext/erpnext/regional/india/utils.py,Salary Structure must be submitted before submission of Tax Ememption Declaration,Štruktúra miezd musí byť predložená pred predložením daňového priznania
DocType: Grant Application,Show on Website,Zobraziť na webovej stránke
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Start on,Začnite zapnuté
DocType: Hub Tracked Item,Hub Category,Kategória Hubu
DocType: Purchase Invoice,SEZ,SEZ
DocType: Purchase Receipt,Vehicle Number,Číslo vozidla
DocType: Loan,Loan Amount,Výška pôžičky
DocType: Student Report Generation Tool,Add Letterhead,Pridať hlavičkový papier
DocType: Program Enrollment,Self-Driving Vehicle,Samohybné vozidlo
DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Hodnota karty dodávateľa je stála
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Row {0}: Bill of Materials not found for the Item {1},Riadok {0}: Nomenklatúra nebol nájdený pre výtlačku {1}
DocType: Contract Fulfilment Checklist,Requirement,požiadavka
DocType: Journal Entry,Accounts Receivable,Pohledávky
DocType: Quality Goal,Objectives,ciele
DocType: HR Settings,Role Allowed to Create Backdated Leave Application,Úloha povolená na vytvorenie aplikácie s opusteným dátumom
DocType: Travel Itinerary,Meal Preference,Preferencia jedla
,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,Počet intervalov fakturácie nesmie byť menší ako 1
DocType: Purchase Invoice,Availed ITC Central Tax,Využil centrálnu daň ITC
DocType: Sales Invoice,Company Address Name,Názov adresy spoloč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á alokovaná čiastka ({0}) je označená ako zaplatená suma ({1}).
DocType: Landed Cost Voucher,Distribute Charges Based On,Distribuovat poplatků na základě
DocType: Projects Settings,Timesheets,Pracovné výkazy
DocType: HR Settings,HR Settings,Nastavení HR
apps/erpnext/erpnext/config/accounts.py,Accounting Masters,Masters účtovníctva
DocType: Salary Slip,net pay info,Čistá mzda info
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CESS Amount,Čiastka CESS
DocType: Woocommerce Settings,Enable Sync,Povoliť synchronizáciu
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.,Táto hodnota sa aktualizuje v Predvolenom zozname cien predaja.
apps/erpnext/erpnext/templates/pages/cart.html,Your cart is Empty,Vaša karta je prázdna
DocType: Email Digest,New Expenses,nové výdavky
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Cannot Optimize Route as Driver Address is Missing.,"Nie je možné optimalizovať trasu, pretože chýba adresa vodiča."
DocType: Shareholder,Shareholder,akcionár
DocType: Purchase Invoice,Additional Discount Amount,Dodatočná zľava Suma
DocType: Cash Flow Mapper,Position,pozície
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Get Items from Prescriptions,Získajte položky z predpisov
DocType: Patient,Patient Details,Podrobnosti o pacientoch
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Nature Of Supplies,Povaha spotrebného materiálu
DocType: Inpatient Record,B Positive,B Pozitívne
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álny prínos zamestnanca {0} presahuje {1} sumou {2} predchádzajúcej nárokovanej sumy
apps/erpnext/erpnext/buying/report/subcontracted_raw_materials_to_be_transferred/subcontracted_raw_materials_to_be_transferred.py,Transferred Quantity,Prevedené množstvo
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,Skrátená nemôže byť prázdne alebo priestor
DocType: Patient Medical Record,Patient Medical Record,Záznam pacienta
DocType: Quality Meeting Agenda,Quality Meeting Agenda,Program rokovania o kvalite
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),Zamestnanec (voliteľné)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Material Request {0} submitted.,Žiadosť o materiál {0} bola odoslaná.
DocType: Loan Type,Loan Name,pôžič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,Ukážka grafu
DocType: Attendance,Shift,smena
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,Enter API key in Google Settings.,Zadajte kľúč rozhrania API v Nastaveniach Google.
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Create Journal Entry,Vytvoriť zápis do denníka
DocType: Student Siblings,Student Siblings,študentské Súrodenci
DocType: Subscription Plan Detail,Subscription Plan Detail,Podrobný popis predplatné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,Odpoveď podľa odchýlky
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.,V nastavení GST nastavte limit B2C.
DocType: Marketplace Settings,Marketplace Settings,Nastavenia trhov
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,Zverejniť {0} položiek
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,Nepodarilo sa nájsť kurz {0} až {1} pre kľúčový dátum {2}. Ručne vytvorte záznam o menovej karte
DocType: POS Profile,Price List,Cenní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 teraz predvolený Fiškálny rok. Prosím aktualizujte svoj prehliadač, aby sa prejavili zmeny."
apps/erpnext/erpnext/projects/doctype/task/task.js,Expense Claims,Nákladové Pohľadávky
DocType: Issue,Support,Podpora
DocType: Appointment,Scheduled Time,Naplánovaný čas
DocType: Employee Tax Exemption Declaration,Total Exemption Amount,Celková suma oslobodenia od dane
DocType: Content Question,Question Link,Odkaz na otázku
,BOM Search,BOM Search
DocType: Accounting Dimension Detail,Mandatory For Balance Sheet,Povinné pre súvahu
DocType: Project,Total Consumed Material Cost  (via Stock Entry),Celková spotreba materiálových nákladov (prostredníctvom vkladu)
DocType: Subscription,Subscription Period,Obdobie upisovania
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js,To Date cannot be less than From Date,Dátumu nemôže byť menšia ako od dátumu
,Delayed Order Report,Správa o oneskorení objednávky
DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Zverejnite na sklade &quot;Na sklade&quot; alebo &quot;Nie je na sklade&quot; na základe dostupných zásob v tomto sklade.
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},Konfigurovať {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,Nasledujúci materiál žiadosti boli automaticky zvýšená na základe úrovni re-poradie položky
apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Účet {0} je neplatná. Mena účtu musí byť {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 dátumu {0} nemôže byť po uvoľnení zamestnanca Dátum {1}
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Create Payment Entries,Vytvorte platobné položky
DocType: Supplier,Is Internal Supplier,Je interný dodávateľ
DocType: Employee,Create User Permission,Vytvoriť povolenie používateľa
apps/erpnext/erpnext/projects/doctype/task/task.py,Task's {0} Start Date cannot be after Project's End Date.,{0} Dátum začatia úlohy nemôže byť po dátume ukončenia projektu.
DocType: Employee Benefit Claim,Employee Benefit Claim,Požiadavka na zamestnanecké požitky
DocType: Healthcare Settings,Remind Before,Pripomenúť predtým
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","Riadok # {0}: Reference Document Type musí byť jedným zo zákazky odberateľa, predajné faktúry alebo Journal Entry"
DocType: Loyalty Program,1 Loyalty Points = How much base currency?,1 Vernostné body = Koľko základnej meny?
DocType: Salary Component,Deduction,Dedukce
DocType: Item,Retain Sample,Zachovať ukážku
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: From Time and To Time is mandatory.,Riadok {0}: From Time a na čas je povinná.
DocType: Stock Reconciliation Item,Amount Difference,vyššie Rozdiel
apps/erpnext/erpnext/public/js/hub/pages/Buying.vue,This page keeps track of items you want to buy from sellers.,"Táto stránka sleduje položky, ktoré chcete kúpiť od predajcov."
apps/erpnext/erpnext/stock/get_item_details.py,Item Price added for {0} in Price List {1},Položka Cena pridaný pre {0} v Cenníku {1}
DocType: Delivery Stop,Order Information,informacie o objednavke
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js,Please enter Employee Id of this sales person,"Prosím, zadajte ID zamestnanca z tohto predaja 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,Vo výrobe
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Difference Amount must be zero,Rozdiel Suma musí byť nula
DocType: Project,Gross Margin,Hrubá marža
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} applicable after {1} working days,{0} uplatniteľné po {1} pracovných dňoch
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čítaná výpis z bankového účtu zostatok
DocType: Normal Test Template,Normal Test Template,Normálna šablóna 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,Ponuka
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Cannot set a received RFQ to No Quote,Nie je možné nastaviť prijatú RFQ na žiadnu ponuku
apps/erpnext/erpnext/regional/report/datev/datev.py,Please create <b>DATEV Settings</b> for Company <b>{}</b>.,Vytvorte <b>nastavenia</b> spoločnosti <b>DATEV</b> pre spoločnosť <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, ktorý chcete vytlačiť v mene účtu"
DocType: BOM,Transfer Material Against,Preneste materiál proti
,Production Analytics,Analýza výroby
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py,This is based on transactions against this Patient. See timeline below for details,Toto je založené na transakciách proti tomuto pacientovi. Viac informácií nájdete v nasledujúcej časovej osi
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.py,Loan Start Date and Loan Period are mandatory to save the Invoice Discounting,Dátum začatia pôžičky a obdobie pôžičky sú povinné na uloženie diskontovania faktúry
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Cost Updated,Náklady aktualizované
apps/erpnext/erpnext/regional/india/utils.py,Vehicle Type is required if Mode of Transport is Road,"Ak je spôsob dopravy cestný, vyžaduje sa typ vozidla"
DocType: Inpatient Record,Date of Birth,Dátum narodenia
DocType: Quality Action,Resolutions,rezolúcia
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**.,** Fiškálny rok ** predstavuje finančný rok. Všetky účtovné záznamy a ďalšie významné transakcie sú sledované pod ** Fiškálny rok **.
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Dimension Filter,Dimenzačný filter
DocType: Opportunity,Customer / Lead Address,Adresa zákazníka/obchodnej iniciatívy
DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Nastavenie tabuľky dodávateľov
DocType: Customer Credit Limit,Customer Credit Limit,Kreditný limit zákazníka
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Assessment Plan Name,Názov plánu hodnotenia
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Target Details,Podrobnosti o cieli
apps/erpnext/erpnext/regional/italy/setup.py,"Applicable if the company is SpA, SApA or SRL","Uplatniteľné, ak je spoločnosť SpA, SApA alebo SRL"
DocType: Work Order Operation,Work Order Operation,Obsluha pracovnej objednávky
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid SSL certificate on attachment {0},Varovanie: Neplatný certifikát SSL na prílohu {0}
apps/erpnext/erpnext/regional/italy/setup.py,Set this if the customer is a Public Administration company.,"Nastavte, ak je zákazníkom spoločnosť verejnej správy."
apps/erpnext/erpnext/utilities/activation.py,"Leads help you get business, add all your contacts and more as your leads","Obchodné iniciatívy vám pomôžu získať zákazku, zaevidovať všetky vaše kontakty"
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,Odpočítať
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Job Description,Popis Práca
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 vonkajších dodávkach a vnútorných dodávkach podliehajúcich preneseniu daňovej povinnosti
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Re-open,Znovu otvoriť
DocType: Sales Invoice Item,Qty as per Stock UOM,Množstvo podľa skladovej MJ
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Name,Meno Guardian2
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Root Company,Root Company
DocType: Attendance,Attendance Request,Žiadosť o účasť
DocType: Purchase Invoice,02-Post Sale Discount,02 - Zľava po predaji
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Majte prehľad o predajných kampaniach. Majte prehľad o Iniciatívach, ponukách, objednávkach z kampane, aby ste zistili, návratnosť investície."
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 uplatniť vernostné body, ktoré majú väčšiu hodnotu ako celkové množstvo."
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,Množstvo na PO
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field To Shareholder cannot be blank,Pole Akcionár nesmie byť prázdne
DocType: Guardian,Work Address,pracovná adresa
DocType: Appraisal,Calculate Total Score,Vypočítať celkové skóre
DocType: Employee,Health Insurance,Zdravotné poistenie
DocType: Asset Repair,Manufacturing Manager,Výrobný riaditeľ
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álna prípustná hodnota
apps/erpnext/erpnext/education/doctype/guardian/guardian.py,User {0} already exists,Používateľ {0} už existuje
apps/erpnext/erpnext/hooks.py,Shipments,Zásielky
DocType: Payment Entry,Total Allocated Amount (Company Currency),Celková alokovaná suma (Company mena)
DocType: Purchase Order Item,To be delivered to customer,Ak chcete byť doručený 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,"Poradové číslo {0} nepatrí do skladu,"
DocType: Grant Application,Email Notification Sent,E-mailové upozornenie bolo odoslané
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,Spoločnosť je vedúca pre firemný účet
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,"Item Code, warehouse, quantity are required on row","Kód položky, sklad, množstvo sa vyžaduje v riadku"
DocType: Bank Guarantee,Supplier,Dodávateľ
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 koreňové oddelenie a nemôže byť upravené.
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show Payment Details,Zobraziť podrobnosti platby
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Duration in Days,Trvanie v dňoch
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,Predvolená spoločnosť
DocType: Company,Transactions Annual History,Výročná história transakcií
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Bank account '{0}' has been synchronized,Bankový účet &#39;{0}&#39; bol synchronizovaný
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ázov 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,"Ponechajte pole prázdne, aby ste objednávali objednávky pre všetkých dodávateľov"
DocType: Healthcare Practitioner,Inpatient Visit Charge Item,Položka poplatku za hospitalizáciu
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 nebude odoslaný neaktívnym používateľom
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Number of Interaction,Počet interakcií
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Number of Interaction,Počet interakcií
DocType: GSTR 3B Report,February,február
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant Settings,Nastavenia Variantu položky
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Company...,Vyberte spoločnost ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} is mandatory for Item {1},{0} je povinná k položke {1}
DocType: Payroll Entry,Fortnightly,dvojtýždňové
DocType: Currency Exchange,From Currency,Od Měny
DocType: Vital Signs,Weight (In Kilogram),Hmotnosť (v kilogramoch)
DocType: Chapter,"chapters/chapter_name
leave blank automatically set after saving chapter.",kapitoly / názov_kategórie nechajte prázdne automaticky nastavené po uložení kapitoly.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Please set GST Accounts in GST Settings,Nastavte si účty GST v nastaveniach služby GST
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Type of Business,Typ podnikania
DocType: Sales Invoice,Consumer,Spotrebiteľ
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,Názov grantu
DocType: Purchase Invoice Item,Rate (Company Currency),Sadzba (V mene spoločnosti)
DocType: Student Guardian,Others,Ostatní
DocType: Subscription,Discounts,Zľavy
DocType: Bank Transaction,Unallocated Amount,nepridelené Suma
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,"Ak chcete použiť skutočné výdavky na rezerváciu, povoľte platnú objednávku a platné rezervácie"
apps/erpnext/erpnext/templates/includes/product_page.js,Cannot find a matching Item. Please select some other value for {0}.,Nemožno nájsť zodpovedajúce položku. Vyberte nejakú inú hodnotu pre {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,Žiadne ďalšie aktualizácie
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,Telefónne číslo
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py,This covers all scorecards tied to this Setup,Toto pokrýva všetky výsledkové karty viazané na toto nastavenie
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Dieťa Položka by nemala byť produkt Bundle. Odstráňte položku `{0}` a uložiť
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Banking,Bankovníctvo
apps/erpnext/erpnext/utilities/activation.py,Add Timesheets,Pridať pracovné výkazy
DocType: Vehicle Service,Service Item,servis Položka
DocType: Bank Guarantee,Bank Guarantee,Banková záruka
DocType: Bank Guarantee,Bank Guarantee,Banková záruka
DocType: Payment Request,Transaction Details,detaily transakcie
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ákupe, doplnení"
DocType: Products Settings,Enable Field Filters,Povoliť filtre polí
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kód položky&gt; Skupina položiek&gt; Značka
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot be Purchase Item also",„Položka poskytovaná zákazníkom“ nemôže byť tiež nákupnou položkou
DocType: Blanket Order Item,Ordered Quantity,Objednané množstvo
apps/erpnext/erpnext/public/js/setup_wizard.js,"e.g. ""Build tools for builders""","napríklad ""Nástroje pre stavbárov """
DocType: Grading Scale,Grading Scale Intervals,Triedenie dielikov
DocType: Item Default,Purchase Defaults,Predvolené nákupy
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 sa nepodarilo vytvoriť kreditnú poznámku. Zrušte začiarknutie možnosti &quot;Zmeniť kreditnú poznámku&quot; a znova ju odošlite
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Added to Featured Items,Pridané do odporúčaných položiek
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}: Účtovné Vstup pre {2} môžu vykonávať len v mene: {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 účtov.
DocType: Cash Flow Mapping,Cash Flow Mapping,Mapovanie peňažných tokov
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Order {1},{0} proti Predajnej Objednávke {1}
DocType: Account,Fixed Asset,Základní Jmění
DocType: Amazon MWS Settings,After Date,Po dátume
apps/erpnext/erpnext/config/help.py,Serialized Inventory,Serialized Zásoby
,Department Analytics,Analýza oddelenia
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Email not found in default contact,E-mail sa v predvolenom kontakte nenachádza
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Generate Secret,Generovať tajomstvo
DocType: Question,Question,otázka
DocType: Loan,Account Info,Informácie o účte
DocType: Activity Type,Default Billing Rate,Predvolené fakturácia Rate
DocType: Fees,Include Payment,Zahrňte platbu
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,{0} Student Groups created.,{0} Vytvorené študentské skupiny.
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,{0} Student Groups created.,{0} Vytvorené študentské skupiny.
DocType: Sales Invoice,Total Billing Amount,Celková suma fakturácie
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py,Program in the Fee Structure and Student Group {0} are different.,Program v štruktúre poplatkov a študentskej skupine {0} je odlišný.
DocType: Bank Statement Transaction Entry,Receivable Account,Účet pohľadávok
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Valid From Date must be lesser than Valid Upto Date.,Platná od dátumu musí byť menšia ako platná do dátumu.
DocType: Employee Skill,Evaluation Date,Dátum vyhodnotenia
DocType: Quotation Item,Stock Balance,Stav zásob
apps/erpnext/erpnext/config/help.py,Sales Order to Payment,Predajné objednávky na platby
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,CEO,CEO
DocType: Purchase Invoice,With Payment of Tax,S platbou dane
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,Nemáte povolenie sa prihlásiť na tento kurz
DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,TRIPLIKÁT PRE DODÁVATEĽA
DocType: Exchange Rate Revaluation Account,New Balance In Base Currency,Nový zostatok v základnej mene
DocType: Location,Is Container,Je kontajner
DocType: Crop Cycle,This will be day 1 of the crop cycle,Toto bude prvý deň cyklu plodín
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please select correct account,"Prosím, vyberte správny účet"
DocType: Salary Structure Assignment,Salary Structure Assignment,Priradenie štruktúry platov
DocType: Purchase Invoice Item,Weight UOM,Hmotnostná MJ
apps/erpnext/erpnext/config/accounts.py,List of available Shareholders with folio numbers,Zoznam dostupných akcionárov s číslami fotiek
DocType: Salary Structure Employee,Salary Structure Employee,Plat štruktúra zamestnancov
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Show Variant Attributes,Zobraziť atribúty variantu
DocType: Student,Blood Group,Krevní Skupina
DocType: Purchase Invoice Item,Page Break,Zalomenie 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 platobnej brány v pláne {0} sa líši od účtu platobnej brány v tejto žiadosti o platbu
DocType: Course,Course Name,Názov kurzu
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py,No Tax Withholding data found for the current Fiscal Year.,Pre súčasný fiškálny rok neboli zistené žiadne údaje o zadržaní dane.
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žstvo
DocType: Fiscal Year,Companies,Spoločnosti
DocType: Supplier Scorecard,Scoring Setup,Nastavenie bodovania
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Electronics,Elektronika
DocType: Manufacturing Settings,Raw Materials Consumption,Spotreba surovín
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,zamestnanci
DocType: Question,Single Correct Answer,Jedna správna odpoveď
DocType: C-Form,Received Date,Dátum prijatia
DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Ak ste vytvorili štandardné šablónu v predaji daní a poplatkov šablóny, vyberte jednu a kliknite na tlačidlo nižšie."
DocType: BOM Scrap Item,Basic Amount (Company Currency),Základná suma (Company mena)
DocType: Student,Guardians,Guardians
apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html,Payment Confirmation,Potvrdenie platby
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Service Start and End Date is required for deferred accounting,Riadok # {0}: Dátum odloženia a začiatku služby je potrebný pre odložené účtovanie
apps/erpnext/erpnext/regional/india/utils.py,Unsupported GST Category for e-Way Bill JSON generation,Nepodporovaná kategória GST pre generáciu e-Way Bill JSON
DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,"Ceny sa nebudú zobrazovať, pokiaľ Cenník nie je nastavený"
DocType: Material Request Item,Received Quantity,Prijaté množstvo
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,To Date must be greater than From Date,Dátum musí byť väčší ako od dátumu
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žadované
DocType: Clinical Procedure,Inpatient Record,Liečebný 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žať prehľad o času, nákladov a účtovania pre aktivít hotový svojho 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 zamestnancov
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Date of Transaction,Dátum transakcie
apps/erpnext/erpnext/config/buying.py,Templates of supplier scorecard variables.,Šablóny premenných ukazovateľa skóre dodávateľa.
DocType: Job Offer Term,Offer Term,Ponuka Term
DocType: Asset,Quality Manager,Manažér kvality
DocType: Job Applicant,Job Opening,Job Zahájení
DocType: Employee,Default Shift,Predvolená zmena
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},Celkové nezaplatené: {0}
DocType: BOM Website Operation,BOM Website Operation,BOM Website Operation
DocType: Bank Statement Transaction Payment Item,outstanding_amount,nesplatená suma
DocType: Supplier Scorecard,Supplier Score,Skóre dodávateľa
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Admission,Plán prijatia
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Total Payment Request amount cannot be greater than {0} amount,Celková suma žiadosti o platbu nemôže byť vyššia ako {0} suma
DocType: Tax Withholding Rate,Cumulative Transaction Threshold,Kumulatívna hranica transakcií
DocType: Promotional Scheme Price Discount,Discount Type,Typ zľavy
DocType: Purchase Invoice Item,Is Free Item,Je bezplatná položka
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.,"Percentuálny podiel, ktorý môžete previesť viac oproti objednanému množstvu. Napríklad: Ak ste si objednali 100 kusov. a váš príspevok je 10%, potom môžete previesť 110 jednotiek."
DocType: Supplier,Warn RFQs,Upozornenie na RFQ
apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Explore,Prieskumník
DocType: BOM,Conversion Rate,Konverzný kurz
apps/erpnext/erpnext/www/all-products/index.html,Product Search,Hľadať produkt
,Bank Remittance,Bankový prevod
DocType: Cashier Closing,To Time,Chcete-li čas
DocType: Invoice Discounting,Loan End Date,Dátum ukončenia pôžičky
apps/erpnext/erpnext/hr/utils.py,) for {0},) pre {0}
DocType: Authorization Rule,Approving Role (above authorized value),Schválenie role (nad oprávnenej hodnoty)
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Employee is required while issuing Asset {0},Zamestnanec je povinný pri vydávaní aktíva {0}
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á čiastka bola zaplatená
DocType: Asset,Insurance End Date,Dátum ukončenia poistenia
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Please select Student Admission which is mandatory for the paid student applicant,"Vyberte Študentské prijatie, ktoré je povinné pre platených študentov"
DocType: Pick List,STO-PICK-.YYYY.-,STO-PICK-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,Budget List,Rozpočtový zoznam
DocType: Campaign,Campaign Schedules,Harmonogramy kampaní
DocType: Job Card Time Log,Completed Qty,Dokončené množstvo
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,Povoliť Nadčasy
DocType: Training Event Employee,Training Event Employee,Vzdelávanie zamestnancov Event
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Maximálne vzorky - {0} môžu byť zadržané pre dávky {1} a položku {2}.
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Time Slots,Pridať časové sloty
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é pre položku {1}. Poskytli ste {2}.
DocType: Stock Reconciliation Item,Current Valuation Rate,Aktuálne ocenenie Rate
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 koreňových účtov nesmie byť menší ako 4
DocType: Training Event,Advance,záloha
apps/erpnext/erpnext/config/integrations.py,GoCardless payment gateway settings,Nastavenia platobnej 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 / strata
DocType: Opportunity,Lost Reason,Ztracené Důvod
DocType: Amazon MWS Settings,Enable Amazon,Povoliť Amazon
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Account {1} does not belong to company {2},Riadok # {0}: Účet {1} nepatrí spoločnosti {2}
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Unable to find DocType {0},Nepodarilo sa nájsť DocType {0}
apps/erpnext/erpnext/public/js/templates/address_list.html,New Address,Nová adresa
DocType: Quality Inspection,Sample Size,Veľkosť vzorky
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Please enter Receipt Document,"Prosím, zadajte prevzatia 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 odobraté
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,"Ďalšie nákladové strediská môžu byť vyrobené v rámci skupiny, ale položky môžu byť vykonané proti non-skupín"
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,Celkový počet priradených listov je viac dní ako maximálna alokácia {0} typu dovolenky pre zamestnanca {1} v danom 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é pasívne výrobky (bez hodnotenia, oslobodené)"
DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
DocType: Delivery Trip,Fulfillment User,Užívateľ splnenia
apps/erpnext/erpnext/config/settings.py,Printing and Branding,Tisk a identita
DocType: Company,Total Monthly Sales,Celkový mesačný predaj
DocType: Course Activity,Enrollment,Zápis
DocType: Payment Request,Subscription Plans,Predplatné
DocType: Agriculture Analysis Criteria,Weather,počasie
DocType: Bin,Actual Quantity,Skutočné Množstvo
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 poplatkov
DocType: Fee Schedule Program,Student Batch,študent Batch
DocType: Pricing Rule,Advanced Settings,Pokročilé nastavenia
DocType: Supplier Scorecard Scoring Standing,Min Grade,Min Grade
DocType: Healthcare Service Unit Type,Healthcare Service Unit Type,Typ jednotky zdravotníckych služieb
DocType: Training Event Employee,Feedback Submitted,Spätná väzba Vložené
apps/erpnext/erpnext/projects/doctype/project/project.py,You have been invited to collaborate on the project: {0},Boli ste pozvaní k spolupráci na projekte: {0}
DocType: Supplier Group,Parent Supplier Group,Rodičovská skupina dodávateľov
DocType: Email Digest,Purchase Orders to Bill,Objednávky k nákupu
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Accumulated Values in Group Company,Akumulované hodnoty v skupine spoloč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žiť akékoľvek platné značenie Bootstrap 4. Bude sa zobrazovať na vašej stránke 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 podliehajúce zdaneniu mimo Spoločenstva (iné ako nulové, nulové a oslobodené"
DocType: Crop,Crop,Plodina
DocType: Purchase Receipt,Supplier Delivery Note,Dodacie oznámenie dodávateľa
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Apply Now,Nainštalovať teraz
DocType: Employee Tax Exemption Proof Submission Detail,Type of Proof,Druh dôkazu
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html,Actual Qty {0} / Waiting Qty {1},Aktuálny počet {0} / Čakajúci počet {1}
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html,Actual Qty {0} / Waiting Qty {1},Aktuálny počet {0} / Čakajúci počet {1}
DocType: Purchase Invoice,E-commerce GSTIN,Elektronický obchod GSTIN
DocType: Sales Order,Not Delivered,Nedodané
,Bank Clearance Summary,Súhrn bankového zúčtovania
apps/erpnext/erpnext/config/settings.py,"Create and manage daily, weekly and monthly email digests.","Tvorba a správa denných, týždenných a mesačných emailových spravodajcov"
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,Vychádza z transakcií s touto predajnou osobou. Viac informácií nájdete v nasledujúcej časovej osi
DocType: Appraisal Goal,Appraisal Goal,Posouzení Goal
DocType: Stock Reconciliation Item,Current Amount,Aktuálna výška
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,Listy boli úspešne udelené
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Invoice,Nová faktúra
DocType: Products Settings,Enable Attribute Filters,Povoliť filtre atribútov
DocType: Fee Schedule,Fee Structure,štruktúra poplatkov
DocType: Timesheet Detail,Costing Amount,Nákladová Čiastka
DocType: Student Admission Program,Application Fee,Poplatok za prihlášku
DocType: Purchase Order Item,Against Blanket Order,Proti paušálnej objednávke
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,Podržanie
apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Spálenie musí mať aspoň jednu správnu voľbu
apps/erpnext/erpnext/hooks.py,Purchase Orders,Objednávky
DocType: Account,Inter Company Account,Inter firemný účet
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Dovoz hromadnú
DocType: Sales Partner,Address & Contacts,Adresa a kontakty
DocType: SMS Log,Sender Name,Meno odosielateľa
DocType: Vital Signs,Very Hyper,Veľmi Hyper
DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Kritériá analýzy poľnohospodárstva
DocType: HR Settings,Leave Approval Notification Template,Ponechať šablónu oznámenia o schválení
DocType: POS Profile,[Select],[Vybrať]
DocType: Staffing Plan Detail,Number Of Positions,Počet pozícií
DocType: Vital Signs,Blood Pressure (diastolic),Krvný tlak (diastolický)
apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Vyberte zákazníka.
DocType: SMS Log,Sent To,Odoslané na
DocType: Agriculture Task,Holiday Management,Správa prázdnin
DocType: Payment Request,Make Sales Invoice,Vytvoriť faktúru
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,Nasledujúce Kontakt dátum nemôže byť v minulosti
DocType: Company,For Reference Only.,Pouze orientační.
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select Batch No,Vyberte položku š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ánovanie kapacít
DocType: Supplier Quotation,Rounding Adjustment (Company Currency,Zaokrúhľovanie úprav (mena spoloč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,"""Dátum od"" je povinný"
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign to Employees,Priradenie zamestnancom
DocType: Bank Transaction,Reference Number,Referenční číslo
DocType: Employee,New Workplace,Nové pracovisko
DocType: Retention Bonus,Retention Bonus,Retenčný bonus
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Material Consumption,Spotreba materiálu
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Closed,Nastaviť ako Zatvorené
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 aktív nemôže byť zaúčtovaná pred dátumom nákupu aktíva <b>{0}</b> .
DocType: Normal Test Items,Require Result Value,Vyžadovať výslednú hodnotu
DocType: Purchase Invoice,Pricing Rules,Pravidlá stanovovania cien
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,Sadzba zrážkovej dane
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,Obchody
DocType: Project Type,Projects Manager,Správce projektů
DocType: Serial No,Delivery Time,Dodacia doba
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,Menovanie zrušené
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","Prevod nie je možné vykonať na zamestnanca. \ Zadajte miesto, kam sa má preniesť majetok {0}"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Travel,Cestování
DocType: Student Report Generation Tool,Include All Assessment Group,Zahrnúť celú hodnotiacu skupinu
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,No active or default Salary Structure found for employee {0} for the given dates,Žiadny aktívny alebo implicitné Plat Štruktúra nájdených pre zamestnancov {0} pre dané termíny
DocType: Leave Block List,Allow Users,Povolit uživatele
DocType: Purchase Order,Customer Mobile No,Zákazník Mobile Žiadne
DocType: Leave Type,Calculated in days,Vypočítané v dňoch
DocType: Call Log,Received By,Prijaté od
DocType: Appointment Booking Settings,Appointment Duration (In Minutes),Trvanie stretnutia (v minútach)
DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Podrobné informácie o šablóne mapovania peňažných tokov
apps/erpnext/erpnext/config/non_profit.py,Loan Management,Správa úverov
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,Nástroj na premenovanie
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Update Cost,Aktualizace Cost
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,Druh transportu
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Show Salary Slip,Show výplatnej páske
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Transfer Material,Přenos materiálu
DocType: Fees,Send Payment Request,Odoslať žiadosť o platbu
DocType: Travel Request,Any other details,Ďalšie 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 hranicou {0} {1} pre položku {4}. Robíte si iný {3} proti rovnakej {2}?
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set recurring after saving,Prosím nastavte opakovanie po uložení
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Select change amount account,Vybrať zmena výšky účet
DocType: Purchase Invoice,Price List Currency,Mena cenníka
DocType: Naming Series,User must always select,Uživatel musí vždy vybrat
DocType: Stock Settings,Allow Negative Stock,Povoliť mínusové zásoby
DocType: Installation Note,Installation Note,Poznámka k instalaci
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.js,Show Warehouse-wise Stock,Zobraziť skladové zásoby
DocType: Soil Texture,Clay,hlina
DocType: Course Topic,Topic,téma
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Financing,Peňažný tok z financovania
DocType: Budget Account,Budget Account,rozpočet účtu
DocType: Quality Inspection,Verified By,Verified By
DocType: Travel Request,Name of Organizer,Názov organizátora
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,Zodpovednosť za dane z príjmov
DocType: Grading Scale Interval,Grade Description,grade Popis
DocType: Clinical Procedure,Is Invoiced,Je faktúrovaná
apps/erpnext/erpnext/setup/doctype/company/company.js,Create Tax Template,Vytvorte šablónu dane
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,Číslo prepravného listu
apps/erpnext/erpnext/assets/doctype/asset/asset.py,"Asset has multiple Asset Movement Entries which has to be \
				cancelled manually to cancel this asset.","Aktíva má viacero záznamov o pohybe majetku, ktoré musíte \ zrušiť ručne, aby ste mohli zrušiť toto dielo."
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,sledovateľnosť
DocType: Asset Maintenance Log,Actions performed,Vykonané akcie
DocType: Cash Flow Mapper,Section Leader,Vedúci sekcie
DocType: Sales Invoice,Transport Receipt No,Doklad o preprave č
DocType: Quiz Activity,Pass,priechod
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Please add the account to root level Company - ,Pridajte účet do spoločnosti root -
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,Zdroj a cieľové umiestnenie nemôžu byť rovnaké
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","Účet rozdielov musí byť účtom typu aktív / pasív, pretože tento záznam na sklade je otváracím záznamom"
DocType: Supplier Scorecard Scoring Standing,Employee,Zamestnanec
DocType: Bank Guarantee,Fixed Deposit Number,Číslo s pevným vkladom
DocType: Asset Repair,Failure Date,Dátum zlyhania
DocType: Support Search Source,Result Title Field,Pole Názov výsledku
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Summary,Zhrnutie hovoru
DocType: Sample Collection,Collected Time,Zhromaždený čas
DocType: Employee Skill Map,Employee Skills,Zručnosti zamestnancov
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,Fuel Expense,Náklady na palivo
DocType: Company,Sales Monthly History,Mesačná história predaja
apps/erpnext/erpnext/regional/italy/utils.py,Please set at least one row in the Taxes and Charges Table,V tabuľke daní a poplatkov nastavte aspoň jeden riadok
DocType: Asset Maintenance Task,Next Due Date,Ďalší dátum splatnosti
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch,Vyberte možnosť Dávka
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is fully billed,{0} {1} je úplne fakturované
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Vital Signs,Živé znamenia
DocType: Payment Entry,Payment Deductions or Loss,Platobné zrážky alebo strata
DocType: Soil Analysis,Soil Analysis Criterias,Kritériá 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},Riadky odstránené o {0}
DocType: Shift Type,Begin check-in before shift start time (in minutes),Začať registráciu pred začiatkom smeny (v minútach)
DocType: BOM Item,Item operation,Funkcia 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?,Naozaj chcete zrušiť túto schôdzku?
DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Balík ceny izieb v hoteli
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Sales Pipeline,predajné Pipeline
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set default account in Salary Component {0},Prosím nastaviť predvolený úč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","Ak je toto políčko začiarknuté, skryje a zakáže pole Zaokrúhlený celkový počet v mzdových listoch"
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 predvolený ofset (dni) pre Dátum dodania v zákazkách odberateľa. Náhradný odstup je 7 dní od dátumu zadania objednávky.
DocType: Rename Tool,File to Rename,Súbor premenovať
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please select BOM for Item in Row {0},"Prosím, vyberte BOM pre položku v riadku {0}"
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Fetch Subscription Updates,Načítať aktualizácie odberov
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} sa nezhoduje so spoločnosťou {1} v režime účtov: {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: ,Predmet:
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 študentského LMS
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Numbers Created,Vytvorené sériové čísla
DocType: POS Profile,Applicable for Users,Platí pre používateľov
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}?,Nastaviť projekt a všetky úlohy do stavu {0}?
DocType: Purchase Invoice,Set Advances and Allocate (FIFO),Nastaviť preddavky a alokovať (FIFO)
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No Work Orders created,Žiadne pracovné príkazy neboli vytvorené
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Slip of employee {0} already created for this period,Výplatnej páske zamestnanca {0} už vytvorili pre toto obdobie
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,Na platnú sumu vkladov môžete odoslať len povolenie na zaplatenie
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 zakúpené položky
DocType: Employee Separation,Employee Separation Template,Šablóna oddelenia zamestnancov
DocType: Selling Settings,Sales Order Required,Je potrebná predajná objednávka
apps/erpnext/erpnext/public/js/hub/marketplace.js,Become a Seller,Staňte sa predajcom
,Procurement Tracker,Sledovanie obstarávania
DocType: Purchase Invoice,Credit To,Kredit:
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Reversed,ITC obrátené
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid authentication error,Chyba overeného overenia
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Active Leads / Customers,Aktívne Iniciatívy / Zákazníci
DocType: Delivery Settings,Leave blank to use the standard Delivery Note format,"Nechajte prázdne, ak chcete použiť štandardný formát dodacieho listu"
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year End Date should be one year after Fiscal Year Start Date,Dátum konca fiškálneho roka by mal byť jeden rok po dátume začiatku fiškálneho roka
DocType: Employee Education,Post Graduate,Postgraduální
DocType: Quality Meeting,Agenda,program
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Plán údržby Detail
DocType: Supplier Scorecard,Warn for new Purchase Orders,Upozornenie 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,Pripojte svoj účet Exotel k ERPĎalším a sledujte protokoly hovorov
DocType: Supplier,Is Frozen,Je Frozen
DocType: Tally Migration,Processed Files,Spracované súbory
apps/erpnext/erpnext/stock/utils.py,Group node warehouse is not allowed to select for transactions,Uzol skupina sklad nie je dovolené vybrať pre transakcie
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Accounting Dimension <b>{0}</b> is required for 'Balance Sheet' account {1}.,Účtovná dimenzia <b>{0}</b> sa vyžaduje pre účet „Súvaha“ {1}.
DocType: Buying Settings,Buying Settings,Nastavenie nákupu
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,Žiadna citácia
DocType: Support Search Source,Post Title Key,Kľúč správy titulu
DocType: Issue,Issue Split From,Vydanie rozdelené z
DocType: Warranty Claim,Raised By,Vznesené
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Prescriptions,predpisy
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á zmena objemu pohľadávok
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Compensatory Off,Náhradné voľno
DocType: Job Applicant,Accepted,Přijato
DocType: POS Closing Voucher,Sales Invoices Summary,Prehľad faktúr predaja
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Party Name,Do názvu strany
DocType: Grant Application,Organization,organizácie
DocType: Grant Application,Organization,organizácie
DocType: BOM Update Tool,BOM Update Tool,Nástroj na aktualizáciu kusovníka
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Party,Skupina podľa strany
DocType: SG Creation Tool Course,Student Group Name,Meno Študent Group
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Show exploded view,Zobraziť rozložený pohľad
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Creating Fees,Vytváranie poplatkov
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.,"Uistite sa, že naozaj chcete vymazať všetky transakcie pre túto spoločnosť. Vaše kmeňové dáta zostanú, ako to je. Túto akciu nie je možné vrátiť späť."
apps/erpnext/erpnext/templates/pages/product_search.html,Search Results,Výsledky vyhľadávania
DocType: Homepage Section,Number of Columns,Počet stĺpcov
DocType: Room,Room Number,Číslo izby
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Price not found for item {0} in price list {1},Cena nebola nájdená pre položku {0} v cenníku {1}
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requestor,žiadateľ
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid reference {0} {1},Neplatná referencie {0} {1}
apps/erpnext/erpnext/config/buying.py,Rules for applying different promotional schemes.,Pravidlá uplatňovania rôznych propagačných programov.
DocType: Shipping Rule,Shipping Rule Label,Přepravní Pravidlo Label
DocType: Journal Entry Account,Payroll Entry,Mzdový účet
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,View Fees Records,Zobrazenie záznamov poplatkov
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,Riadok # {0} (Platobný stôl): Suma musí byť záporná
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,"Could not update stock, invoice contains drop shipping item.","Nie je možné aktualizovať zásob, faktúra obsahuje pokles lodnej dopravy tovaru."
DocType: Contract,Fulfilment Status,Stav plnenia
DocType: Lab Test Sample,Lab Test Sample,Laboratórna vzorka
DocType: Item Variant Settings,Allow Rename Attribute Value,Povoliť premenovanie hodnoty atribútu
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Quick Journal Entry,Rýchly vstup Journal
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Amount,Čiastka budúcej 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,Prefix radu faktúr
DocType: Employee,Previous Work Experience,Předchozí pracovní zkušenosti
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Number / Name,Aktualizovať číslo účtu / meno
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign Salary Structure,Priraďte štruktúru platu
DocType: Support Settings,Response Key List,Zoznam kľúčových odpovedí
DocType: Stock Entry,For Quantity,Pre Množstvo
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 pre zobrazenie výsledkov
apps/erpnext/erpnext/templates/generators/item/item_configure.js,{0} items found.,Nájdených {0} položiek.
DocType: Item Price,Packing Unit,Balenie
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} nie je odoslané
DocType: Subscription,Trialling,skúšanie
DocType: Sales Invoice Item,Deferred Revenue,Výnosy budúcich období
DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Pokladničný účet sa použije na vytvorenie faktúry za predaj
DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Výnimka Podkategória
DocType: Member,Membership Expiry Date,Dátum ukončenia členstva
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,{0} must be negative in return document,{0} musí byť negatívny vo vratnom dokumente
DocType: Employee Tax Exemption Proof Submission,Submission Date,Dátum predloženia
,Minutes to First Response for Issues,Zápisy do prvej reakcie 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ázov inštitútu pre ktorý 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 bola aktualizovaná vo všetkých kusovníkoch
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),Pomenovanie Series (pre študentské prihlasovateľ)
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py,Bonus Payment Date cannot be a past date,Bonus Dátum platby nemôže byť minulý dátum
DocType: Travel Request,Copy of Invitation/Announcement,Kópia pozvánky / oznámenia
DocType: Practitioner Service Unit Schedule,Practitioner Service Unit Schedule,Časový plán služby pre praktizujúcich
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot delete item {1} which has already been billed.,"Riadok # {0}: Nie je možné odstrániť položku {1}, ktorá už bola fakturovaná."
DocType: Sales Invoice,Transporter Name,Názov prepravcu
DocType: Authorization Rule,Authorized Value,Autorizovaný Hodnota
DocType: BOM,Show Operations,ukázať Operations
,Minutes to First Response for Opportunity,Zápisy do prvej reakcie na príležitosť
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á suma
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Unit of Measure,Merná jednotka
DocType: Fiscal Year,Year End Date,Dátum konca roka
DocType: Task Depends On,Task Depends On,Úloha je závislá na
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Opportunity,Příležitost
DocType: Options,Option,voľba
apps/erpnext/erpnext/accounts/general_ledger.py,You can't create accounting entries in the closed accounting period {0},V uzavretom účtovnom období nemôžete vytvoriť účtovné záznamy {0}
DocType: Operation,Default Workstation,Výchozí Workstation
DocType: Payment Entry,Deductions or Loss,Odpočty alebo strata
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is closed,{0} {1} je uzavretý
DocType: Email Digest,How frequently?,Jak často?
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Collected: {0},Celkom zhromaždené: {0}
DocType: Purchase Receipt,Get Current Stock,Získať aktuálny stav
DocType: Purchase Invoice,ineligible,nevhodný
apps/erpnext/erpnext/config/manufacturing.py,Tree of Bill of Materials,Strom Bill materiálov
DocType: BOM,Exploded Items,Rozložené položky
DocType: Student,Joining Date,spájanie Dátum
,Employees working on a holiday,Zamestnanci pracujúci na dovolenku
,TDS Computation Summary,Zhrnutie výpočtu TDS
DocType: Share Balance,Current State,Aktuálny stav
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Present,mark Present
DocType: Share Transfer,From Shareholder,Od akcionára
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Greater Than Amount,Väčšie ako množstvo
DocType: Project,% Complete Method,Dokončené% Method
apps/erpnext/erpnext/healthcare/setup.py,Drug,liek
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 finančných nákladov
DocType: BOM,Operating Cost (Company Currency),Prevádzkové náklady (Company mena)
DocType: Authorization Rule,Applicable To (Role),Vztahující se na (Role)
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Pending Leaves,Čakajúce listy
DocType: BOM Update Tool,Replace BOM,Nahraďte kusovník
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Code {0} already exist,Kód {0} už existuje
DocType: Patient Encounter,Procedures,postupy
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Sales orders are not available for production,Príkazy na predaj nie sú k dispozícii na výrobu
DocType: Asset Movement,Purpose,Účel
DocType: Company,Fixed Asset Depreciation Settings,Nastavenie odpisovania dlhodobého majetku
DocType: Item,Will also apply for variants unless overrridden,"Bude platiť aj pre varianty, pokiaľ nebude prepísané"
DocType: Purchase Invoice,Advances,Zálohy
DocType: HR Settings,Hiring Settings,Nastavenia prijímania
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: ,Hodnotiaca skupina:
DocType: Item Reorder,Request for,Žiadosť 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á sadzba (podľa skladovej MJ)
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,Nechať bez nároku na odmenu nesúhlasí so schválenými záznamov nechať aplikáciu
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Next Steps,Ďalšie kroky
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Saved Items,Uložené položky
DocType: Travel Request,Domestic,domáci
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ávať uvedené položky na najlepšie možné ceny
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Employee Transfer cannot be submitted before Transfer Date ,Prevod zamestnancov nemožno odoslať pred dátumom prevodu
DocType: Certification Application,USD,Americký dolár
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Remaining Balance,Zostávajúci zostatok
DocType: Selling Settings,Auto close Opportunity after 15 days,Auto zavrieť Opportunity po 15 dňoch
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Objednávky nie sú povolené {0} kvôli postaveniu skóre {1}.
apps/erpnext/erpnext/stock/doctype/item/item.py,Barcode {0} is not a valid {1} code,Čiarový kód {0} nie je platný {1} kód
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,End Year,koniec roka
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot/Lead %,Quot / Olovo%
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot/Lead %,Quot / Olovo%
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,vodič
DocType: Vital Signs,Nutrition Values,Výživové hodnoty
DocType: Lab Test Template,Is billable,Je fakturovaná
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 Objednávke {1}
DocType: Patient,Patient Demographics,Demografia pacienta
DocType: Task,Actual Start Date (via Time Sheet),Skutočný dátum začatia (cez Časový rozvrh)
apps/erpnext/erpnext/portal/doctype/homepage/homepage.py,This is an example website auto-generated from ERPNext,Toto je príklad webovej stránky automaticky generovanej z ERPNext
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 1,Stárnutí Rozsah 1
DocType: Shopify Settings,Enable Shopify,Povoliť funkciu Shopify
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total claimed amount,Celková čiastka zálohy nemôže byť vyššia ako celková nárokovaná čiastka
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,Úvodné
DocType: Grant Application,Grant Application Details ,Podrobnosti o žiadosti o grant
DocType: Employee Separation,Employee Separation,Oddelenie zamestnancov
DocType: BOM Item,Original Item,Pôvodná položka
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Date,Dátum dokumentu
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py,Fee Records Created - {0},Fee Records Vytvoril - {0}
DocType: Asset Category Account,Asset Category Account,Asset Kategórie Account
apps/erpnext/erpnext/controllers/item_variant.py,The value {0} is already assigned to an exisiting Item {2}.,Hodnota {0} je už priradená k existujúcej položke {2}.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0} (Payment Table): Amount must be positive,Riadok # {0} (Platobný stôl): Suma musí byť pozitívna
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Cannot produce more Item {0} than Sales Order quantity {1},Nie je možné vyrobiť viac Položiek {0} ako je množstvo na predajnej objednávke {1}
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Nothing is included in gross,Hrubé hodnoty nie sú zahrnuté
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill already exists for this document,Elektronický účet už pre tento dokument existuje
apps/erpnext/erpnext/stock/doctype/item/item.js,Select Attribute Values,Vyberte hodnoty atribútov
DocType: Purchase Invoice,Reason For Issuing document,Dôvod pre vydanie dokumentu
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Stock Entry {0} is not submitted,Sklad Entry {0} nie je predložená
DocType: Payment Reconciliation,Bank / Cash Account,Bankový / Peňažný účet
DocType: Bank Transaction,ACC-BTN-.YYYY.-,ACC-BTN-.YYYY.-
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Next Contact By cannot be same as the Lead Email Address,Nasledujúce Kontakt Tým nemôže byť rovnaký ako hlavný e-mailovú adresu
DocType: Tax Rule,Billing City,Fakturačné mesto
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is an Individual or a Proprietorship,"Uplatniteľné, ak je spoločnosť fyzická osoba alebo vlastníčka"
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,Log Type is required for check-ins falling in the shift: {0}.,Typ denníka je vyžadovaný pre nahlásenia spadajúce do smeny: {0}.
DocType: Asset,Manual,Manuálny
DocType: Tally Migration,Is Master Data Processed,Spracovávajú sa kmeňové údaje
DocType: Salary Component Account,Salary Component Account,Účet plat Component
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} Operations: {1},{0} Operácie: {1}
DocType: Global Defaults,Hide Currency Symbol,Skrýt symbol měny
apps/erpnext/erpnext/config/non_profit.py,Donor information.,Informácie pre darcu.
apps/erpnext/erpnext/config/accounts.py,"e.g. Bank, Cash, Credit Card","napríkklad banka, hotovosť, 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álny pokojový krvný tlak u dospelého pacienta je približne 120 mmHg systolický a diastolický 80 mmHg, skrátený &quot;120/80 mmHg&quot;"
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 tovaru
apps/erpnext/erpnext/config/desktop.py,Quality,Kvalita
DocType: Projects Settings,Ignore Employee Time Overlap,Ignorovať prekrytie času zamestnanca
DocType: Warranty Claim,Service Address,Servisní adresy
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Master Data,Import kmeňových dát
DocType: Asset Maintenance Task,Calibration,Kalibrácia
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} is a company holiday,{0} je firemný sviatok
apps/erpnext/erpnext/projects/report/billing_summary.py,Billable Hours,Fakturovateľné hodiny
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Status Notification,Zanechať upozornenie na stav
DocType: Patient Appointment,Procedure Prescription,Predpísaný postup
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Furnitures and Fixtures,Nábytok a svietidlá
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,Lab Test Report
DocType: Employee Benefit Application,Employee Benefit Application,Žiadosť o zamestnanecké požitky
DocType: Appointment,Unverified,neoverený
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.py,Row({0}): {1} is already discounted in {2},Riadok ({0}): {1} je už zľavnený v {2}
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Additional Salary Component Exists.,Existuje ďalšia zložka platu.
DocType: Purchase Invoice,Unregistered,neregistrovaný
DocType: Student Applicant,Application Date,aplikácie Dátum
DocType: Salary Component,Amount based on formula,Suma podľa vzorca
DocType: Purchase Invoice,Currency and Price List,Cenník a mena
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Create Maintenance Visit,Vytvorte návštevu údržby
DocType: Opportunity,Customer / Lead Name,Zákazník / Iniciatíva Meno
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,Zdaniteľné platové platne
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 sa nezhoduje s formátom GSTIN.
apps/erpnext/erpnext/stock/report/stock_and_account_value_comparison/stock_and_account_value_comparison.py,Account Value,Hodnota účtu
DocType: Guardian,Occupation,povolania
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álna výška dávky (ročná)
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,TDS Rate %,TDS%
DocType: Crop,Planting Area,Oblasť výsadby
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},Diela {0} nepatria do umiestnenia {1}
,Product Bundle Balance,Zostatok produktu
DocType: Purchase Taxes and Charges,Parenttype,Parenttype
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Central Tax,Centrálna daň
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Result,tréning Výsledok
DocType: Purchase Invoice,Is Paid,sa vypláca
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žstvo na výrobu
DocType: Stock Ledger Entry,Outgoing Rate,Odchádzajúce Rate
apps/erpnext/erpnext/controllers/accounts_controller.py, or ,alebo
apps/erpnext/erpnext/public/js/purchase_trends_filters.js,Billing Date,Dátum fakturácie
DocType: Import Supplier Invoice,Import Supplier Invoice,Importovať dodávateľskú faktúru
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be negative,Pridelená suma nemôže byť záporná
DocType: Import Supplier Invoice,Zip File,Súbor ZIP
DocType: Sales Order,Billing Status,Stav fakturácie
apps/erpnext/erpnext/public/js/conf.js,Report an Issue,Nahlásiť 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.","Ak {0} {1} množstvo položky <b>{2}</b> , na položku sa použije 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,Riadok # {0}: Journal Entry {1} nemá účet {2} alebo už uzavreté proti inému poukazu
DocType: Supplier Scorecard Criteria,Criteria Weight,Hmotnosť kritérií
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Account: {0} is not permitted under Payment Entry,Účet: {0} nie je povolený v rámci zadania platby
DocType: Production Plan,Ignore Existing Projected Quantity,Ignorujte existujúce predpokladané množstvo
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Approval Notification,Zanechajte oznámenie o schválení
DocType: Buying Settings,Default Buying Price List,Predvolený nákupný cenník
DocType: Payroll Entry,Salary Slip Based on Timesheet,Plat Slip na základe časového rozvrhu
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Rate,Sadzba nákupu
apps/erpnext/erpnext/controllers/buying_controller.py,Row {0}: Enter location for the asset item {1},Riadok {0}: Zadajte umiestnenie položky majetku {1}
apps/erpnext/erpnext/hr/doctype/attendance/attendance_list.js,Attendance Marked,Účasť označená
DocType: Request for Quotation,PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-
apps/erpnext/erpnext/public/js/hub/pages/Seller.vue,About the Company,O spoloč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 pre položku {0}. Nie je možné nájsť jednu dávku, ktorá spĺňa túto požiadavku"
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 pre položku {0}. Nie je možné nájsť jednu dávku, ktorá spĺňa túto požiadavku"
DocType: Asset Maintenance Log,ACC-AML-.YYYY.-,ACC-AML-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,No gain or loss in the exchange rate,Žiadne zisky alebo straty vo výmennom kurze
DocType: Leave Control Panel,Select Employees,Vybrať Zamestnanci
DocType: Shopify Settings,Sales Invoice Series,Séria predajných faktúr
DocType: Opportunity,Potential Sales Deal,Potenciální prodej
DocType: Complaint,Complaints,Sťažnosti
DocType: Employee Tax Exemption Declaration,Employee Tax Exemption Declaration,Vyhlásenie o oslobodení od dane z príjmu zamestnancov
DocType: Payment Entry,Cheque/Reference Date,Šek / Referenčný dátum
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials.,Žiadne položky s kusovníkom.
apps/erpnext/erpnext/portal/doctype/homepage/homepage.js,Customize Homepage Sections,Prispôsobte sekcie domovskej stránky
DocType: Purchase Invoice,Total Taxes and Charges,Celkem Daně a poplatky
DocType: Payment Entry,Company Bank Account,Firemný bankový účet
DocType: Employee,Emergency Contact,Kontakt v nouzi
DocType: Bank Reconciliation Detail,Payment Entry,platba Entry
,sales-browser,Predajná-browser
apps/erpnext/erpnext/accounts/doctype/account/account.js,Ledger,Účtovná kniha
DocType: Drug Prescription,Drug Code,Kódexu liekov
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 tlače pre online
DocType: Shopping Cart Settings,Shopping Cart Settings,Nastavenie Nákupného košíka
DocType: Journal Entry,Accounting Entries,Účetní záznamy
DocType: Job Card Time Log,Job Card Time Log,Denník pracovných kariet
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.","Ak sa zvolí pravidlo Pricing for &#39;Rate&#39;, prepíše cenník. Sadzba Pravidlo sadzba je konečná sadzba, takže žiadna ďalšia zľava by sa mala použiť. Preto v transakciách, ako je Predajná objednávka, Objednávka atď., Bude vyzdvihnuté v poli &quot;Rýchlosť&quot;, a nie v poli Cena."
DocType: Journal Entry,Paid Loan,Platené pôžičky
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Subcontract: Raw materials quantity to make subcontracted items.,Vyhradené množstvo pre subdodávky: Množstvo surovín na výrobu subdodávateľských položiek.
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ý dátum splatnosti
DocType: Purchase Order,Ref SQ,Ref SQ
DocType: Issue,Resolution By,Rozlíšenie podľa
DocType: Leave Type,Applicable After (Working Days),Platné po (pracovné dni)
apps/erpnext/erpnext/education/doctype/student/student.py,Joining Date can not be greater than Leaving Date,Dátum vstupu nemôže byť väčší ako dátum odchodu
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Receipt document must be submitted,Príjem a musí byť predložený
DocType: Purchase Invoice Item,Received Qty,Prijaté množstvo
DocType: Stock Entry Detail,Serial No / Batch,Sériové číslo / Dávka
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Not Paid and Not Delivered,Nezaplatené a nedoručené
DocType: Product Bundle,Parent Item,Nadřazená položka
DocType: Account,Account Type,Typ účtu
DocType: Shopify Settings,Webhooks Details,Webhooks Details
apps/erpnext/erpnext/templates/pages/projects.html,No time sheets,Žiadne časové rozvrhy
DocType: GoCardless Mandate,GoCardless Customer,Zákazník spoločnosti GoCardless
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leave Type {0} cannot be carry-forwarded,Nechajte typ {0} nemožno vykonávať odovzdávané
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,Mzda
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","Pre riadok {0} v {1}. Ak chcete v rýchlosti položku sú {2}, riadky {3} musí byť tiež zahrnuté"
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žieb bola obnovená.
DocType: Bin,Reserved Quantity,Vyhrazeno Množství
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Please enter valid email address,Zadajte platnú e-mailovú adresu
DocType: Volunteer Skill,Volunteer Skill,Dobrovoľnícka zručnosť
DocType: Bank Reconciliation,Include POS Transactions,Zahrňte POS transakcie
DocType: Quality Action,Corrective/Preventive,Nápravné / preventívne
DocType: Purchase Invoice,Inter Company Invoice Reference,Interná referencia faktúry spoloč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 daňové identifikačné číslo pre zákazníka &#39;% s&#39;
apps/erpnext/erpnext/config/help.py,Customizing Forms,Prispôsobenie Formuláre
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Arrear,nedoplatok
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Amount during the period,Odpisy hodnoty v priebehu obdobia
DocType: Sales Invoice,Is Return (Credit Note),Je návrat (kreditná poznámka)
DocType: Leave Control Panel,Allocate Leaves,Prideliť 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ý šablóna nesmie byť predvolenú šablónu
DocType: Pricing Rule,Price or Product Discount,Cena alebo zľava produktu
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,For row {0}: Enter planned qty,Pre riadok {0}: Zadajte naplánované množstvo
DocType: Account,Income Account,Účet příjmů
DocType: Payment Request,Amount in customer's currency,Čiastka v mene 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...,Priradenie štruktúr ...
DocType: Stock Reconciliation Item,Current Qty,Aktuálne Množstvo
DocType: Restaurant Menu,Restaurant Menu,Reštaurácia
apps/erpnext/erpnext/public/js/event.js,Add Suppliers,Pridať dodávateľov
DocType: Sales Invoice,ACC-SINV-.YYYY.-,ACC-Sinv-.YYYY.-
DocType: Loyalty Program,Help Section,Sekcia pomocníka
apps/erpnext/erpnext/www/all-products/index.html,Prev,Predchádzajúce
DocType: Appraisal Goal,Key Responsibility Area,Key Odpovědnost Area
DocType: Delivery Trip,Distance UOM,Vzdialenosť UOM
apps/erpnext/erpnext/utilities/activation.py,"Student Batches help you track attendance, assessments and fees for students","Študent Šarže pomôže sledovať dochádzku, hodnotenia a poplatky pre študentov"
DocType: Payment Entry,Total Allocated Amount,Celková alokovaná suma
apps/erpnext/erpnext/setup/doctype/company/company.py,Set default inventory account for perpetual inventory,Nastavte predvolený inventárny účet pre trvalý inventár
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}","Nie je možné dodať sériové číslo {0} položky {1}, pretože je rezervované pre \ fullfill zákazku odberateľa {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,Odošlite e-mail na posúdenie grantu
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full, did not save","Miestne úložisko je plné, nezachránil"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}: UOM Conversion Factor is mandatory,Riadok {0}: Konverzný faktor MJ je povinný
DocType: Employee Benefit Claim,Claim Date,Dátum nároku
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field Asset Account cannot be blank,Pole Majetkový účet nemôže byť prázdne
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Already record exists for the item {0},Už existuje záznam pre 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 predtým vygenerovaných faktúrach. Naozaj chcete tento odber reštartovať?
DocType: Lab Test,LP-,LP-
DocType: Healthcare Settings,Registration Fee,Registračný poplatok
DocType: Loyalty Program Collection,Loyalty Program Collection,Zber vernostného programu
DocType: Stock Entry Detail,Subcontracted Item,Subkontraktovaná položka
apps/erpnext/erpnext/education/__init__.py,Student {0} does not belong to group {1},Študent {0} nepatrí 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,Krajina dodania
DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Inkognito dane zákazníka z predajných transakcií
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,Duplikát projektu s úlohami
DocType: Purchase Invoice,Total Quantity,Celkové množstvo
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}.,Dohoda o úrovni služieb sa zmenila na {0}.
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Sklad je možné provést pouze prostřednictvím Burzy Entry / dodací list / doklad o zakoupení
DocType: Employee Education,Class / Percentage,Třída / Procento
DocType: Shopify Settings,Shopify Settings,Nastavenie nakupovania
DocType: Amazon MWS Settings,Market Place ID,ID miesta 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,Skontrolujte voľné pracovné miesta pri vytváraní pracovných ponúk
DocType: Subscription,Cancel At End Of Period,Zrušiť na konci obdobia
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Property already added,Vlastnosti už boli pridané
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},Vernostné 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,Nie sú vybraté žiadne položky na prenos
apps/erpnext/erpnext/config/buying.py,All Addresses.,Všetky adresy
DocType: Company,Stock Settings,Nastavenie Skladu
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","Spojenie je možné len vtedy, ak tieto vlastnosti sú rovnaké v oboch záznamoch. 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 / strata z aktív likvidácii
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 nasledujúcej tabuľky bude vybraný iba žiadateľ o štúdium so stavom &quot;Schválený&quot;.
DocType: Tax Withholding Category,Rates,Sadzby
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 pre účet {0} nie je k dispozícii. <br> Prosím, nastavte účtovnú schému správne."
DocType: Task,Depends on Tasks,Závisí na úlohách
apps/erpnext/erpnext/config/crm.py,Manage Customer Group Tree.,Správa zákazníků skupiny Tree.
DocType: Normal Test Items,Result Value,Výsledná hodnota
DocType: Hotel Room,Hotels,hotely
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,New Cost Center Name,Názov nového nákladového strediska
DocType: Leave Control Panel,Leave Control Panel,Nechte Ovládací panely
DocType: Project,Task Completion,úloha Dokončenie
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,Not in Stock,nie je na sklade
DocType: Volunteer,Volunteer Skills,Dobrovoľnícke zručnosti
DocType: Additional Salary,HR User,HR User
DocType: Bank Guarantee,Reference Document Name,Názov 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ázov vernostné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,Pripomenutie aktualizácie GSTIN Sent
DocType: Discounted Invoice,Debit To,Debetní K
DocType: Restaurant Menu Item,Restaurant Menu Item,Položka ponuky Reštaurácia
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,študent Prijímacie
apps/erpnext/erpnext/accounts/party.py,{0} {1} is disabled,{0} {1} je zakázaný
DocType: Supplier,Billing Currency,Mena fakturácie
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Extra Large,Extra Veľké
DocType: Loan,Loan Application,Aplikácia úveru
DocType: Crop,Scientific Name,Vedecké meno
DocType: Healthcare Service Unit,Service Unit Type,Typ servisnej jednotky
DocType: Bank Account,Branch Code,Kód pobočky
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Leaves,Celkom Listy
DocType: Customer,"Reselect, if the chosen contact is edited after save","Znova vyberte, ak sa zvolený kontakt upraví po uložení"
DocType: Quality Procedure,Parent Procedure,Rodičovský postup
DocType: Patient Encounter,In print,V tlači
DocType: Accounting Dimension,Accounting Dimension,Účtovná dimenzia
,Profit and Loss Statement,Výkaz ziskov a strá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, na ktorú sa odkazuje {0} - {1}, je už fakturovaná"
,Sales Browser,Prehliadač predaja
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},Upozornenie: Ďalším {0} # {1} existuje proti akciovej vstupu {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ěrů a půjček (aktiva)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Debtors,Dlžníci
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Large,Veľký
DocType: Bank Statement Settings,Bank Statement Settings,Nastavenia bankového výpisu
DocType: Shopify Settings,Customer Settings,Nastavenia zákazníka
DocType: Homepage Featured Product,Homepage Featured Product,Úvodná Odporúčané tovar
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,View Orders,Zobraziť objednávky
DocType: Marketplace Settings,Marketplace URL (to hide and update label),Adresa URL Marketplace (skryť a aktualizovať štítok)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Assessment Groups,Všetky skupiny Assessment
apps/erpnext/erpnext/regional/india/utils.py,{} is required to generate e-Way Bill JSON,{} je potrebný na vygenerovanie e-Way Bill JSON
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,New Warehouse Name,Nový sklad Name
DocType: Shopify Settings,App Type,Typ aplikácie
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py,Total {0} ({1}),Celkom {0} ({1})
DocType: C-Form Invoice Detail,Territory,Území
DocType: Pricing Rule,Apply Rule On Item Code,Použiť pravidlo pre 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,Správa o stave zásob
DocType: Stock Settings,Default Valuation Method,Výchozí metoda ocenění
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,poplatok
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Zobraziť kumulatívnu čiastku
apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Prebieha aktualizácia. Môže to chvíľu trvať.
DocType: Production Plan Item,Produced Qty,Vyrobené množstvo
DocType: Vehicle Log,Fuel Qty,palivo Množstvo
DocType: Work Order Operation,Planned Start Time,Plánované Start Time
DocType: Course,Assessment,posúdenie
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 nemohol nájsť žiadny zodpovedajúci platobný záznam
DocType: Student Applicant,Application Status,stav aplikácie
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,Atribút webovej stránky
DocType: Project Update,Project Update,Aktualizácia 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,Ponuka {0} je zrušená
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,Prihláste prosím číslo SIREN do informačného súboru spoločnosti
DocType: Quality Action Table,Responsible,zodpovedný
DocType: Email Digest,Sales Orders to Bill,Predajné príkazy k Billovi
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 žiadosť o materiál
DocType: Quiz,Score out of 100,Skóre zo 100
apps/erpnext/erpnext/templates/pages/help.html,Forum Activity,Aktivita fóra
DocType: Quiz,Grading Basis,Základ klasifikácie
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 nastavenia transakcie bankového výpisu
apps/erpnext/erpnext/hr/utils.py,To date can not greater than employee's relieving date,K dnešnému dňu nemôže byť väčší ako deň odľahlosti zamestnanca
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Please create Customer from Lead {0},Prosím vytvorte Zákazníka z Obchodnej iniciatívy {0}
apps/erpnext/erpnext/healthcare/page/patient_history/patient_history.html,Select Patient,Vyberte pacienta
DocType: Price List,Applicable for Countries,Pre krajiny
DocType: Supplier Scorecard Scoring Variable,Parameter Name,Názov parametra
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,"Nechajte len aplikácie, ktoré majú status, schválené &#39;i, Zamietnuté&#39; môžu byť predložené"
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py,Creating Dimensions...,Vytvára sa dimenzia ...
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Student Group Name is mandatory in row {0},Študent Názov skupiny je povinné v rade {0}
DocType: Homepage,Products to be shown on website homepage,"Produkty, ktoré majú byť uvedené na internetových stránkach domovskej"
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žstvo musí byť väčšie ako nula
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on PO,Ak akumulovaný mesačný rozpočet prekročil PO
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Place,Na miesto
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select a Sales Person for item: {0},Vyberte obchodnú osobu pre položku: {0}
DocType: Stock Entry,Stock Entry (Outward GIT),Zásoby (Outward GIT)
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation,Prehodnotenie výmenné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,Prepojené dokumenty
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please enter Item Code to get item taxes,"Ak chcete získať dane z tovaru, zadajte kód položky"
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,"Shipping Address does not have country, which is required for this Shipping Rule","Adresa pre odosielanie nemá krajinu, ktorá sa vyžaduje pre toto Pravidlo plavby"
DocType: Journal Entry,Excise Entry,Spotřební Entry
DocType: Bank,Bank Transaction Mapping,Mapovanie bankových transakcií
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Upozornenie: predajné objednávky {0} už existuje proti Zákazníka objednanie {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,Časť založená na
DocType: Shopping Cart Settings,Show Apply Coupon Code,Zobraziť Použiť kód kupónu
DocType: Issue,Issue Type,Typ vydania
DocType: Attendance,Leave Type,Leave Type
DocType: Purchase Invoice,Supplier Invoice Details,Detaily dodávateľskej faktúry
DocType: Agriculture Task,Ignore holidays,Ignorovať dovolenku
apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Pridať / upraviť podmienky 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 Dieťa
DocType: Project,Copied From,Skopírované z
DocType: Project,Copied From,Skopírované z
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Invoice already created for all billing hours,Faktúra už vytvorená pre všetky fakturačné hodiny
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Name error: {0},Názov chyba: {0}
DocType: Healthcare Service Unit Type,Item Details,Položka Podrobnosti
DocType: Cash Flow Mapping,Is Finance Cost,Sú 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 štandardný zákazník v nastaveniach reštaurácie
,Salary Register,plat Register
DocType: Company,Default warehouse for Sales Return,Predvolený sklad pre vrátenie predaja
DocType: Pick List,Parent Warehouse,Parent Warehouse
DocType: Subscription,Net Total,Netto Spolu
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 trvanlivosť položky v dňoch, aby ste nastavili expiráciu na základe dátumu výroby plus trvanlivosti."
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Default BOM not found for Item {0} and Project {1},Predvolený kusovník sa nenašiel pre položku {0} a projekt {1}
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the Mode of Payment in Payment Schedule,Riadok {0}: Nastavte si spôsob platby v pláne platieb
apps/erpnext/erpnext/config/non_profit.py,Define various loan types,Definovať rôzne typy úverov
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),Skladové karty (FIFO)
DocType: Homepage Section,Section HTML,Sekcia 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} nepatrí do Spoloč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.,"Nie je možné vyriešiť funkciu skóre skóre {0}. Skontrolujte, či je vzorec platný."
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost as on,Náklady ako na
DocType: Healthcare Settings,Out Patient Settings,Nastavenia pre pacienta
DocType: Account,Round Off,Zaokrúhliť
DocType: Service Level Priority,Resolution Time,Čas riešenia
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Quantity must be positive,Množstvo musí byť pozitívne
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,Polia Od Akcionára a Akcionára nemôžu byť prázdne
DocType: Cashier Closing,Cashier Closing,Uzávierka pokladníka
DocType: Tax Rule,Use for Shopping Cart,Použitie pre Košík
DocType: Homepage,Homepage Slideshow,Domovská stránka Slideshow
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Serial Numbers,Vyberte 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,Vytvoriť ponuku dodávateľa
DocType: Travel Request,Require Full Funding,Vyžadovať úplné financovanie
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 mala byť zadaná s negatívnym množstvom vo vratnom dokumente
DocType: Shift Type,Grace Period Settings For Auto Attendance,Nastavenie doby odkladu pre automatickú účasť
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","Prevádzka {0} dlhšie, než všetkých dostupných pracovných hodín v pracovnej stanici {1}, rozložiť prevádzku do niekoľkých operácií"
DocType: Membership,Membership Status,Stav členstva
DocType: Travel Itinerary,Lodging Required,Požadované ubytovanie
DocType: Promotional Scheme,Price Discount Slabs,Cenové zľavy
DocType: Stock Reconciliation Item,Current Serial No,Aktuálne poradové číslo
DocType: Employee,Attendance and Leave Details,Účasť a podrobnosti o dovolenke
,BOM Comparison Tool,Nástroj na porovnávanie kusovníkov
,Requested,Požadované
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,No Remarks,Žiadne poznámky
DocType: Asset,In Maintenance,V údržbe
DocType: Amazon MWS Settings,Click this button to pull your Sales Order data from Amazon MWS.,Kliknutím na toto tlačidlo vyberiete údaje o predajnej objednávke od spoločnosti Amazon MWS.
DocType: Vital Signs,Abdomen,brucho
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,No outstanding invoices require exchange rate revaluation,Nevyrovnané faktúry nevyžadujú precenenie výmenného kurzu
DocType: Purchase Invoice,Overdue,Zpožděný
DocType: Account,Stock Received But Not Billed,Prijaté na zásoby ale neúčtované
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root Account must be a group,Root účet musí byť skupina
DocType: Drug Prescription,Drug Prescription,Predpísaný liek
DocType: Service Level,Support and Resolution,Podpora a rozlíšenie
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Free item code is not selected,Zadarmo kód položky nie je vybratý
DocType: Loan,Repaid/Closed,Splatená / Zatvorené
DocType: Amazon MWS Settings,CA,CA
DocType: Item,Total Projected Qty,Celková predpokladaná Množstvo
DocType: Monthly Distribution,Distribution Name,Názov distribúcie
DocType: Chart of Accounts Importer,Chart Tree,Strom stromu
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Include UOM,Zahrňte 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,Predvolená dohoda o úrovni služieb
DocType: SG Creation Tool Course,Course Code,kód predmetu
apps/erpnext/erpnext/hr/utils.py,More than one selection for {0} not allowed,Nie je povolený viac ako jeden výber pre {0}
DocType: Pick List,Qty of raw materials will be decided based on the qty of the Finished Goods Item,O množstve surovín sa rozhodne na základe množstva hotového tovaru
DocType: Location,Parent Location,Umiestnenie rodičov
DocType: POS Settings,Use POS in Offline Mode,Používajte POS v režime offline
apps/erpnext/erpnext/support/doctype/issue/issue.py,Priority has been changed to {0}.,Priorita sa zmenila 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žno, že záznam o výmene meny nie je vytvorený {1} až {2}"
DocType: Quotation,Rate at which customer's currency is converted to company's base currency,"Sazba, za kterou zákazník měny je převeden na společnosti základní měny"
DocType: Purchase Invoice Item,Net Rate (Company Currency),Čistý Rate (Company meny)
DocType: Salary Detail,Condition and Formula Help,Nápoveda pre podmienky a vzorce
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 účtovnú schému zo súborov CSV / Excel
DocType: Patient Service Unit,Patient Service Unit,Jednotka služieb pacienta
DocType: Bank Statement Transaction Invoice Item,Sales Invoice,Predajná faktúra
DocType: Journal Entry Account,Party Balance,Balance Party
DocType: Cash Flow Mapper,Section Subtotal,Oddiel Medzisúčet
apps/erpnext/erpnext/accounts/page/pos/pos.js,Please select Apply Discount On,"Prosím, vyberte Použiť Zľava na"
DocType: Stock Settings,Sample Retention Warehouse,Sklad pre uchovávanie vzoriek
DocType: Company,Default Receivable Account,Výchozí pohledávek účtu
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Projected Quantity Formula,Vzorec predpokladaného množstva
DocType: Sales Invoice,Deemed Export,Považovaný 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,LabTest Approver
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,You have already assessed for the assessment criteria {}.,Vyhodnotili ste kritériá hodnotenia {}.
DocType: Vehicle Service,Engine Oil,Motorový olej
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Orders Created: {0},Vytvorené pracovné príkazy: {0}
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,Please set an email id for the Lead {0},Zadajte e-mailovú identifikáciu potenciálneho 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,Adresa zákazníka
DocType: Loan,Loan Details,pôžička Podrobnosti
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup post company fixtures,Nepodarilo sa nastaviť doplnky firmy
DocType: Company,Default Inventory Account,Predvolený inventárny účet
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The folio numbers are not matching,Čísla fotiek sa nezhodujú
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Request for {0},Žiadosť o platbu za {0}
DocType: Item Barcode,Barcode Type,Typ čiarového kódu
DocType: Antibiotic,Antibiotic Name,Názov antibiotika
apps/erpnext/erpnext/config/buying.py,Supplier Group master.,Predajca skupiny dodávateľov.
DocType: Healthcare Service Unit,Occupancy Status,Stav obsadenosti
apps/erpnext/erpnext/accounts/dashboard_chart_source/account_balance_timeline/account_balance_timeline.py,Account is not set for the dashboard chart {0},Účet nie je nastavený pre tabuľku dashboardov {0}
DocType: Purchase Invoice,Apply Additional Discount On,Použiť dodatočné Zľava 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,Zatvorte POS
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Cannot return more than {1} for Item {2},Riadok # {0}: Nemožno vrátiť viac ako {1} pre 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,MJ položky
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Suma dane po zľave Suma (Company meny)
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é operácie
DocType: Cheque Print Template,Primary Settings,primárnej Nastavenie
DocType: Attendance Request,Work From Home,Práca z domu
DocType: Purchase Invoice,Select Supplier Address,Vybrať Dodávateľ Address
apps/erpnext/erpnext/public/js/event.js,Add Employees,Pridajte Zamestnanci
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,štandardná šablóna
DocType: Training Event,Theory,teória
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,Stíšiť 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 nie je možné zrušiť, pretože je prepojený s odoslaným dielom {0}. \ Ak chcete pokračovať, zrušte ho."
DocType: Account,Account Number,Číslo účtu
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Can only make payment against unbilled {0},Možno vykonať len platbu proti nevyfakturované {0}
DocType: Call Log,Missed,vynechal
apps/erpnext/erpnext/controllers/selling_controller.py,Commission rate cannot be greater than 100,Komisná sadzba nemôže byť väčšia ako 100
apps/erpnext/erpnext/stock/doctype/item_manufacturer/item_manufacturer.py,Duplicate entry against the item code {0} and manufacturer {1},Duplikát oproti kódu položky {0} a výrobcovi {1}
DocType: Sales Invoice,Allocate Advances Automatically (FIFO),Automaticky prideľovať preddavky (FIFO)
DocType: Volunteer,Volunteer,dobrovoľník
DocType: Buying Settings,Subcontract,Subdodávka
apps/erpnext/erpnext/public/js/utils/party.js,Please enter {0} first,"Prosím, najprv zadajte {0}"
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,No replies from,Žiadne odpovede 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,Zdaniteľné platové dosky
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} sa neodovzdáva pre položku: {1} v riadku {2}
DocType: Bin,Bin,Kôš
DocType: Bank Transaction,Bank Transaction,Bankové transakcie
DocType: Crop,Crop Name,Názov plodiny
apps/erpnext/erpnext/hub_node/api.py,Only users with {0} role can register on Marketplace,V službe Marketplace sa môžu zaregistrovať iba používatelia s rolou {0}
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,Schôdzky a stretnutia
DocType: Antibiotic,Healthcare Administrator,Administrátor zdravotnej starostlivosti
DocType: Dosage Strength,Dosage Strength,Pevnosť dávkovania
DocType: Healthcare Practitioner,Inpatient Visit Charge,Poplatok za návštevu v nemocnici
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,Published Items,Zverejnené 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,Farba
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Plan Assessment Criteria
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,transakcie
DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Zabráňte nákupným objednávkam
DocType: Coupon Code,Coupon Name,Názov kupónu
apps/erpnext/erpnext/healthcare/setup.py,Susceptible,vnímavý
DocType: Shift Type,Working Hours Calculation Based On,Výpočet pracovnej doby na základe
apps/erpnext/erpnext/config/buying.py,Request for quotation.,Žiadosť o cenovú ponuku.
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 skladom,&quot; je &quot;Nie&quot; a &quot;je Sales Item&quot; &quot;Áno&quot; a nie je tam žiadny iný 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álna história
apps/erpnext/erpnext/education/doctype/guardian/guardian.py,User {0} created,Používateľ {0} bol vytvorený
DocType: Fee Schedule,Fee Breakup for each student,Poplatok za každý študent
apps/erpnext/erpnext/controllers/accounts_controller.py,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Celkové zálohy ({0}) na objednávku {1} nemôže byť väčšia ako Celkom ({2})
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Code,Zmeniť kód
DocType: Purchase Invoice Item,Valuation Rate,Ocenění Rate
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Vytvorenie variantov
DocType: Vehicle,Diesel,Diesel
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Completed Quantity,Dokončené množstvo
apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Mena pre cenník nie je vybratá
DocType: Quick Stock Balance,Available Quantity,Dostupné množstvo
DocType: Purchase Invoice,Availed ITC Cess,Využil ITC Cess
,Student Monthly Attendance Sheet,Študent mesačná návštevnosť Sheet
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Pravidlo platia iba pre predaj
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Odpisový riadok {0}: Nasledujúci Dátum odpisovania nemôže byť pred dátumom 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,Premenovať Log
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Student Group or Course Schedule is mandatory,Plán študentskej skupiny alebo kurzu je povinný
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Student Group or Course Schedule is mandatory,Plán študentskej skupiny alebo kurzu 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,Všetky bankové transakcie boli vytvorené
DocType: Fee Validity,Visited yet,Navštívené
apps/erpnext/erpnext/public/js/hub/pages/FeaturedItems.vue,You can Feature upto 8 items.,Môžete obsahovať až 8 položiek.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to group.,Sklady s existujúcimi transakcie nemožno previesť na skupinu.
DocType: Assessment Result Tool,Result HTML,výsledok HTML
DocType: Selling Settings,How often should project and company be updated based on Sales Transactions.,Ako často by sa projekt a spoločnosť mali aktualizovať na základe predajných transakcií.
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expires On,Vyprší
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žstvo ({0}) sa musí rovnať počtu vyrobených ({1})
apps/erpnext/erpnext/utilities/activation.py,Add Students,Pridajte študentov
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,vzdialenosť
DocType: Water Analysis,Storage Temperature,Teplota skladovania
DocType: Sales Order,SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-
DocType: Employee Attendance Tool,Unmarked Attendance,Neoznačené Návštevnosť
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Creating Payment Entries......,Vytváranie položiek 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,Registrácia 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},Dátum začiatku by mal byť menší ako dátum ukončenia úlohy {0}
,Consolidated Financial Statement,Konsolidovaný finančný výkaz
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py,Name or Email is mandatory,Meno alebo e-mail je povinné
DocType: Instructor,Instructor Log,Denník inštruktorov
DocType: Clinical Procedure,Clinical Procedure,Klinický postup
DocType: Shopify Settings,Delivery Note Series,Séria dodacích poznámok
DocType: Purchase Order Item,Returned Qty,Vrátené Množstvo
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,Nepodarilo sa nainštalovať predvoľby
DocType: Healthcare Service Unit Type,UOM Conversion in Hours,UOM Konverzia v hodinách
DocType: Contract,Signee Details,Signee Details
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 súčasnosti má {1} hodnotiacu kartu pre dodávateľa, a RFQ pre tohto dodávateľa by mali byť vydané opatrne."
DocType: Certified Consultant,Non Profit Manager,Neziskový manažér
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,Spoločnosť Popis pre webové stránky domovskú 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,Meno suplier
apps/erpnext/erpnext/accounts/report/financial_statements.py,Could not retrieve information for {0}.,Nepodarilo sa získať informácie pre {0}.
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py,Opening Entry Journal,Otvorenie denníka vstupu
DocType: Contract,Fulfilment Terms,Podmienky plnenia
DocType: Sales Invoice,Time Sheet List,Zoznam časových rozvrhov
DocType: Healthcare Settings,Result Printed,Výsledok vytlačený
DocType: Asset Category Account,Depreciation Expense Account,Odpisy Náklady účtu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Probationary Period,Skúšobná 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á výška sumy (prostredníctvom časových rozpisov)
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,Riadok {0}: Advance proti zákazník musí byť úver
DocType: Quality Meeting,Quality Meeting,Kvalitné stretnutie
apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-skupiny k skupine
DocType: Employee,ERPNext User,ERPĎalší používateľ
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 riadku {0}
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 riadku {0}
DocType: Company,Default Buying Terms,Predvolené nákupné podmienky
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Doklad o koupi Item Dodávané
DocType: Amazon MWS Settings,Enable Scheduled Synch,Povoliť naplánovanú synchronizáciu
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 pre udržanie stavu doručenia sms
DocType: Accounts Settings,Make Payment via Journal Entry,Vykonať platbu cez Journal Entry
apps/erpnext/erpnext/controllers/item_variant.py,Please do not create more than 500 items at a time,Nevytvárajte naraz viac ako 500 položiek
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Printed On,Vytlačené na
DocType: Clinical Procedure Template,Clinical Procedure Template,Šablóna klinického postupu
DocType: Item,Inspection Required before Delivery,Inšpekcia Požadované pred pôrodom
apps/erpnext/erpnext/config/education.py,Content Masters,Obsahové mastery
DocType: Item,Inspection Required before Purchase,Inšpekcia Požadované pred nákupom
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Pending Activities,Nevybavené Aktivity
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Lab Test,Vytvoriť laboratórny test
DocType: Patient Appointment,Reminded,pripomenul
DocType: Homepage Section,Cards,karty
apps/erpnext/erpnext/public/js/setup_wizard.js,View Chart of Accounts,Zobraziť účtovnú schému
DocType: Chapter Member,Chapter Member,Člen kapitoly
DocType: Material Request Plan Item,Minimum Order Quantity,Minimálna objednávka
apps/erpnext/erpnext/public/js/setup_wizard.js,Your Organization,Vaša organizácia
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}","Preskočiť Ponechať alokáciu pre nasledujúcich zamestnancov, pretože záznamy proti alokácii už existujú proti nim. {0}"
DocType: Fee Component,Fees Category,kategórie 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 sponzora (meno, miesto)"
DocType: Supplier Scorecard,Notify Employee,Upozorniť zamestnanca
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Enter value betweeen {0} and {1},Zadajte hodnotu medzi {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,Vydavatelia novín
apps/erpnext/erpnext/hr/utils.py,Future dates not allowed,Budúce termíny nie sú povolené
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Expected Delivery Date should be after Sales Order Date,Očakávaný dátum doručenia by mal byť po dátume zákazky predaja
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,Šablóna účtovného rozvrhu
DocType: Attendance,Attendance Date,Účast Datum
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Update stock must be enable for the purchase invoice {0},Ak chcete aktualizovať nákupnú faktúru {0}
apps/erpnext/erpnext/stock/get_item_details.py,Item Price updated for {0} in Price List {1},Položka Cena aktualizovaný pre {0} v Cenníku {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Number Created,Sériové číslo bolo vytvorené
,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,Dátum pridania
DocType: Item,Valuation Method,Ocenění Method
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 byť súčasťou len jedného vernostného programu.
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Half Day,Mark Poldenné
DocType: Sales Invoice,Sales Team,Predajný 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.,Pred odoslaním zadajte meno príjemcu.
DocType: Program Enrollment Tool,Get Students,získať študentov
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Bank Data mapper doesn't exist,Mapovač bankových údajov 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 stĺpcov pre túto sekciu. Ak vyberiete 3 stĺpce, zobrazia sa 3 karty na riadok."
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,[Error],[Chyba]
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Reconcile Entries,Zmieriť položky
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},Riadok # {0}: Nákladové stredisko {1} nepatrí spoločnosti {2}
apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py,Please select Completion Date for Completed Repair,Vyberte dátum dokončenia dokončenej opravy
DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Študent Batch Účasť Tool
apps/erpnext/erpnext/controllers/status_updater.py,Limit Crossed,limit skríženými
DocType: Appointment Booking Settings,Appointment Booking Settings,Nastavenia rezervácie schôdzky
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js,Scheduled Upto,Plánované až
apps/erpnext/erpnext/hr/doctype/shift_type/shift_type.js,Attendance has been marked as per employee check-ins,Účasť bola označená podľa prihlásenia zamestnanca
DocType: Woocommerce Settings,Secret,tajomstvo
DocType: Plaid Settings,Plaid Secret,Plaid Secret
DocType: Company,Date of Establishment,Dátum založenia
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; Meno Termín&#39; {1} už existuje. Upravte tieto položky a skúste to znova.
apps/erpnext/erpnext/stock/doctype/item/item.py,"As there are existing transactions against item {0}, you can not change the value of {1}",Pretože existujú nejaké transakcie voči položke {0} nemožno zmeniť hodnotu {1}
DocType: UOM,Must be Whole Number,Musí být celé číslo
DocType: Campaign Email Schedule,Send After (days),Odoslať po (dni)
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 nebol nájdený oproti účtu {0}
DocType: Purchase Invoice,Invoice Copy,Kopírovanie faktúry
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ákazník Warehouse (voliteľne)
DocType: Blanket Order Item,Blanket Order Item,Objednávka tovaru
DocType: Pricing Rule,Discount Percentage,Zľava v percentách
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sub contracting,Vyhradené pre subkontraktovanie
DocType: Payment Reconciliation Invoice,Invoice Number,Číslo faktúry
DocType: Shopping Cart Settings,Orders,Objednávky
DocType: Travel Request,Event Details,Podrobnosti udalosti
DocType: Department,Leave Approver,Schvaľovateľ voľna
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 výdavkových nákladov
DocType: QuickBooks Migrator,Scope,Rozsah
DocType: Assessment Group,Assessment Group Name,Názov skupiny Assessment
DocType: Manufacturing Settings,Material Transferred for Manufacture,Prevádza jadrový materiál pre Výroba
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Add to Details,Pridať do podrobností
DocType: Travel Itinerary,Taxi,taxi
DocType: Shopify Settings,Last Sync Datetime,Dátum posledného synchronizácie
DocType: Landed Cost Item,Receipt Document Type,Príjem Document Type
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal/Price Quote,Návrh / cenová ponuka
DocType: Antibiotic,Healthcare,Zdravotná starostlivosť
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šetky Jobs
DocType: Sales Order,% of materials billed against this Sales Order,% Materiálov fakturovaných proti tejto Predajnej objednávke
DocType: Program Enrollment,Mode of Transportation,Spô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 dodávateľa v rámci schémy zloženia boli spoločnosti Oslobodené a Nil ohodnotené
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 oddelenie ...
DocType: Pricing Rule,Free Item,Zadarmo položka
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Suppliies made to Composition Taxable Persons,Doplnky pre osoby podliehajúce dani zo zloženia
apps/erpnext/erpnext/regional/india/utils.py,Distance cannot be greater than 4000 kms,Vzdialenosť nesmie byť väčšia ako 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žstvo {0} {1} {2} {3}
DocType: Account,Depreciation,Odpisovanie
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","Ak chcete tento dokument zrušiť, odstráňte zamestnanca <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,Účasť zamestnancov Tool
DocType: Guardian Student,Guardian Student,Guardian Student
DocType: Supplier,Credit Limit,Úverový limit
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Avg. Selling Price List Rate,Avg. Sadzba predajného cenníka
DocType: Loyalty Program Collection,Collection Factor (=1 LP),Faktor zberu (= 1 LP)
DocType: Additional Salary,Salary Component,Komponent platu
apps/erpnext/erpnext/accounts/utils.py,Payment Entries {0} are un-linked,Platobné Príspevky {0} sú un-spojený
DocType: GL Entry,Voucher No,Voucher No
,Lead Owner Efficiency,Efektívnosť vlastníka iniciatívy
,Lead Owner Efficiency,Efektívnosť vlastníka iniciatívy
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Workday {0} has been repeated.,Pracovný deň {0} sa opakoval.
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 si nárokovať iba čiastku {0}, zvyšná suma {1} by mala byť v aplikácii \ ako zložka pro-rata"
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Employee A/C Number,Číslo zamestnanca
DocType: Amazon MWS Settings,Customer Type,Typ zákazníka
DocType: Compensatory Leave Request,Leave Allocation,Nechte Allocation
DocType: Payment Request,Recipient Message And Payment Details,Príjemca správy a platobných informácií
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,Otvorte novú letenku
DocType: Training Event,Trainer Email,tréner Email
DocType: Sales Invoice,Transporter,prepravca
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Day Book Data,Importovať údaje dennej knihy
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Priority {0} has been repeated.,Priorita {0} bola opakovaná.
DocType: Restaurant Reservation,No of People,Počet ľudí
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 nie je možné aktualizovať proti dokladu o kúpe {0}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Create Delivery Trip,Vytvoriť doručovací výlet
DocType: Support Settings,Auto close Issue after 7 days,Auto zavrieť Issue po 7 dňoch
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}","Dovolenka nemôže byť pridelené pred {0}, pretože rovnováha dovolenky už bolo carry-odovzdávané v budúcej pridelenie dovolenku 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,študent Žiadateľ
DocType: Hub Tracked Item,Hub Tracked Item,Pásová sledovaná položka
DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINÁL PRE PRÍJEMCU
DocType: Asset Category Account,Accumulated Depreciation Account,účet oprávok
DocType: Certified Consultant,Discuss ID,Diskutujte ID
DocType: Stock Settings,Freeze Stock Entries,Freeze Stock Příspěvky
DocType: Program Enrollment,Boarding Student,Stravovanie Študent
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Booking Actual Expenses,"Ak chcete použiť skutočné výdavky na rezerváciu, zapnite ho"
DocType: Asset Finance Book,Expected Value After Useful Life,Očakávaná hodnota po celú dobu životnosti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For quantity {0} should not be greater than work order quantity {1},Pre množstvo {0} by nemalo byť väčšie ako množstvo pre pracovný príkaz {1}
DocType: Item,Reorder level based on Warehouse,Úroveň Zmena poradia na základe Warehouse
DocType: Activity Cost,Billing Rate,Fakturačná cena
,Qty to Deliver,Množství k dodání
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Disbursement Entry,Založenie záznamu o vyplatení
DocType: Amazon MWS Settings,Amazon will synch data updated after this date,Spoločnosť Amazon bude synchronizovať údaje aktualizované po tomto dátume
,Stock Analytics,Analýza zásob
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Operations cannot be left blank,Operácia nemôže byť prázdne
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Select a Default Priority.,Vyberte predvolenú prioritu.
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,Lab Test(s) ,Laboratórne testy
DocType: Maintenance Visit Purpose,Against Document Detail No,Proti Detail dokumentu č
apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Vymazanie nie je povolené pre krajinu {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žite 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",V prípade karty pracovných miest {0} môžete vykonať len typ zásob typu „Transfer materiálu na výrobu“
DocType: Quality Inspection,Outgoing,Vycházející
DocType: Customer Feedback Table,Customer Feedback Table,Tabuľka spätnej väzby od zákazníkov
apps/erpnext/erpnext/config/support.py,Service Level Agreement.,Dohoda o úrovni služieb.
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ý alebo zatvorené
DocType: Asset,Calculate Depreciation,Vypočítať 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ý peňažný tok z investičnej
DocType: Purchase Invoice,Import Of Capital Goods,Dovoz investičného tovaru
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í byť predložené
DocType: Fee Schedule Program,Total Students,Celkový počet študentov
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Attendance Record {0} exists against Student {1},Účasť Record {0} existuje proti Študent {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference #{0} dated {1},Referencia # {0} zo dňa {1}
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Eliminated due to disposal of assets,Odpisy vypadol v dôsledku nakladania s majetkom
DocType: Employee Transfer,New Employee ID,Nové číslo zamestnanca
DocType: Loan,Member,člen
DocType: Work Order Item,Work Order Item,Položka pracovnej objednávky
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js,Show Opening Entries,Zobraziť úvodné záznamy
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.js,Unlink external integrations,Odpojte externé integrácie
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Choose a corresponding payment,Vyberte zodpovedajúcu 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 manuálne študentov pre skupinu založenú na aktivitách
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Select students manually for the Activity based Group,Vyberte manuálne študentov pre skupinu založenú 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,Nemožno vytvoriť retenčný bonus pre odídených zamestnancov
DocType: Lead,Market Segment,Segment trhu
DocType: Agriculture Analysis Criteria,Agriculture Manager,Poľnohospodársky manažér
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Paid Amount cannot be greater than total negative outstanding amount {0},Zaplatená suma nemôže byť vyšší ako celkový negatívny dlžnej čiastky {0}
DocType: Supplier Scorecard Period,Variables,Premenné
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 Veľkosť
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} sa nezhoduje so spoločnosťou {1}
DocType: Education Settings,Current Academic Year,Súčasný akademický rok
DocType: Education Settings,Current Academic Year,Súčasný akademický rok
DocType: Stock Settings,Default Stock UOM,Predvolená skladová MJ
DocType: Asset,Number of Depreciations Booked,Počet Odpisy rezervované
apps/erpnext/erpnext/public/js/pos/pos.html,Qty Total,Celkový počet
DocType: Landed Cost Item,Receipt Document,príjem dokumentov
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á čiastka
DocType: Share Transfer,(including),(počítajúc do toho)
DocType: Quality Review Table,Yes/No,Áno nie
DocType: Asset,Double Declining Balance,double degresívne
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Closed order cannot be cancelled. Unclose to cancel.,Uzavretá objednávka nemôže byť zrušený. Otvoriť zrušiť.
DocType: Amazon MWS Settings,Synch Products,Synch Produkty
DocType: Loyalty Point Entry,Loyalty Program,Vernostný program
DocType: Student Guardian,Father,otec
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Support Tickets,Podporné vstupenky
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,'Update Stock' cannot be checked for fixed asset sale,&quot;Aktualizácia Sklad&quot; nemôžu byť kontrolované na pevnú predaji majetku
DocType: Bank Reconciliation,Bank Reconciliation,Bankové odsúhlasenie
DocType: Attendance,On Leave,Na odchode
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Get Updates,Získať aktualizácie
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Účet {2} nepatrí do spoločnosti {3}
apps/erpnext/erpnext/stock/doctype/item/item.js,Select at least one value from each of the attributes.,Vyberte aspoň jednu hodnotu z každého atribútu.
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Please login as a Marketplace User to edit this item.,"Ak chcete upraviť túto položku, prihláste sa ako používateľ služby 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,Štát odoslania
apps/erpnext/erpnext/config/help.py,Leave Management,Správa priepustiek
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 faktúru
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Please select Employee,Vyberte zamestnanca
DocType: Sales Order,Fully Delivered,Plně Dodáno
DocType: Promotional Scheme Price Discount,Min Amount,Min. Suma
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Lower Income,S nižšími příjmy
DocType: Restaurant Order Entry,Current Order,Aktuálna objednávka
DocType: Delivery Trip,Driver Address,Adresa vodiča
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,"Akt prijatý, ale neúčtovaný"
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","Rozdiel účet musí byť typu aktív / Zodpovednosť účet, pretože to Reklamná Zmierenie je Entry Otvorenie"
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Disbursed Amount cannot be greater than Loan Amount {0},Zaplatené čiastky nemôže byť väčšia ako Výška úveru {0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Riadok {0} # Pridelená čiastka {1} nemôže byť väčšia ako suma neoprávnene nárokovaná {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',"""Dátum DO"" musí byť po ""Dátum OD"""
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.js,No Staffing Plans found for this Designation,Žiadne personálne plány neboli nájdené pre toto označenie
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Batch {0} of Item {1} is disabled.,Dávka {0} položky {1} je vypnutá.
DocType: Leave Policy Detail,Annual Allocation,Ročné pridelenie
DocType: Travel Request,Address of Organizer,Adresa organizátora
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Healthcare Practitioner...,Vyberte zdravotníckeho lekára ...
DocType: Employee Boarding Activity,Applicable in the case of Employee Onboarding,Platí v prípade zamestnania na palube
apps/erpnext/erpnext/config/accounts.py,Tax template for item tax rates.,Šablóna dane pre sadzby dane z položiek.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods Transferred,Prevedený tovar
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Cannot change status as student {0} is linked with student application {1},Nemôže zmeniť štatút študenta {0} je prepojený s aplikáciou študentské {1}
DocType: Asset,Fully Depreciated,plne odpísaný
DocType: Item Barcode,UPC-A,UPC-A
,Stock Projected Qty,Naprojektovaná úroveň zásob
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á Účasť HTML
apps/erpnext/erpnext/utilities/activation.py,"Quotations are proposals, bids you have sent to your customers","Ponuky sú návrhy, ponuky zaslané vašim zákazníkom"
DocType: Sales Invoice,Customer's Purchase Order,Zákazníka Objednávka
DocType: Clinical Procedure,Patient,trpezlivý
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Bypass credit check at Sales Order ,Zablokovanie kreditnej kontroly na objednávke
DocType: Employee Onboarding Activity,Employee Onboarding Activity,Činnosť zamestnancov na palube
DocType: Location,Check if it is a hydroponic unit,"Skontrolujte, či ide o hydroponickú jednotku"
DocType: Pick List Item,Serial No and Batch,Sériové číslo a Dávka
DocType: Warranty Claim,From Company,Od Společnosti
DocType: GSTR 3B Report,January,január
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,Sum of Scores of Assessment Criteria needs to be {0}.,Súčet skóre hodnotiacich kritérií musí byť {0}.
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please set Number of Depreciations Booked,Prosím nastavte Počet Odpisy rezervované
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,Platobné podmienky
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Productions Orders cannot be raised for:,Productions Objednávky nemôže byť zvýšená pre:
DocType: Quality Meeting Minutes,Minute,Minúta
DocType: Purchase Invoice,Purchase Taxes and Charges,Nákup Daně a poplatky
DocType: Chapter,Meetup Embed HTML,Meetup Vložiť HTML
DocType: Asset,Insured value,Poistná hodnota
DocType: POS Closing Voucher Taxes,POS Closing Voucher Taxes,Dane z kupónového uzávierky 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}.","Dátumy začiatku a ukončenia, ktoré nie sú v platnom mzdovom období, nemožno vypočítať {0}."
DocType: Leave Block List,Leave Block List Allowed,Nechte Block List povolena
DocType: Grading Scale Interval,Grading Scale Interval,Stupnica 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,Zľava (%) na sadzbe cien s maržou
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Zľava (%) na sadzbe cien s maržou
DocType: Healthcare Service Unit Type,Rate / UOM,Sadzba / MJ
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py,All Warehouses,všetky Sklady
apps/erpnext/erpnext/hooks.py,Appointment Booking,Rezervácia schôdzky
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,No {0} found for Inter Company Transactions.,Nie je {0} zistené pre transakcie medzi spoločnosťami.
DocType: Travel Itinerary,Rented Car,Nájomné auto
apps/erpnext/erpnext/public/js/hub/components/profile_dialog.js,About your Company,O vašej spoločnosti
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Show Stock Ageing Data,Zobraziť údaje o starnutí zásob
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Balance Sheet account,Pripísať na účet musí byť účtu Súvaha
DocType: Donor,Donor,darcu
apps/erpnext/erpnext/regional/doctype/gst_hsn_code/gst_hsn_code.js,Update Taxes for Items,Aktualizujte dane pre položky
DocType: Global Defaults,Disable In Words,Zakázať v slovách
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Quotation {0} not of type {1},Ponuka {0} nie je typu {1}
DocType: Maintenance Schedule Item,Maintenance Schedule Item,Plán údržby Item
DocType: Sales Order,%  Delivered,% Dodaných
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 študent poslal Žiadosť o platbu"
DocType: Skill,Skill Name,Názov zručnosti
DocType: Patient,Medical History,História medicíny
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,Identifikácia pacienta
DocType: Practitioner Schedule,Schedule Name,Názov plánu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.py,Please enter GSTIN and state for the Company Address {0},Zadajte GSTIN a uveďte adresu spoločnosti {0}
DocType: Currency Exchange,For Buying,Pre nákup
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Pri zadávaní objednávky
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Pridať všetkých dodávateľov
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Riadok # {0}: Pridelená čiastka nemôže byť vyššia ako dlžná suma.
DocType: Tally Migration,Parties,strany
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Prechádzať BOM
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,Úpraviť dátum a čas vzniku
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set Depreciation related Accounts in Asset Category {0} or Company {1},"Prosím, amortizácia účty s ním súvisiacich v kategórii Asset {0} alebo {1} Company"
DocType: Lab Test Groups,Normal Range,Normálny rozsah
DocType: Call Log,Call Duration in seconds,Trvanie 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ý predaj
DocType: Loyalty Point Entry Redemption,Loyalty Point Entry Redemption,Vrátenie bodu vkladu
apps/erpnext/erpnext/config/accounts.py,Cost Center and Budgeting,Nákladové stredisko a rozpočtovanie
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Opening Balance Equity,Počiatočný stav Equity
DocType: Appointment,CRM,CRM
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Payment Schedule,Nastavte plán platieb
DocType: Pick List,Items under this warehouse will be suggested,Položky v tomto sklade budú navrhnuté
DocType: Purchase Invoice,N,N
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Remaining,zostávajúce
DocType: Appraisal,Appraisal,Ocenění
DocType: Loan,Loan Account,Úverový účet
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from and valid upto fields are mandatory for the cumulative,Pre kumulatívne sú povinné a platné až polia
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",Pre položku {0} v riadku {1} sa počet sériových čísel nezhoduje s vybraným množstvom
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.,Toto je založené na transakciách s týmto zdravotníckym lekárom.
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Email sent to supplier {0},E-mail zaslaný na dodávateľa {0}
DocType: Item,Default Sales Unit of Measure,Predvolená predajná jednotka merania
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Academic Year: ,Akademický rok:
DocType: Inpatient Record,Admission Schedule Date,Dátum schôdze prijatia
DocType: Subscription,Past Due Date,Dátum splatnosti
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Nepovoliť nastavenie alternatívnej položky pre položku {0}
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Dátum sa 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é čisté ITC (A) - (B)
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Vytvorte poplatky
DocType: Project,Total Purchase Cost (via Purchase Invoice),Celkové obstarávacie náklady (cez nákupné faktúry)
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Select Quantity,Zvoľte množstvo
DocType: Loyalty Point Entry,Loyalty Points,Vernostné body
DocType: Customs Tariff Number,Customs Tariff Number,colného sadzobníka
DocType: Employee Tax Exemption Proof Submission Detail,Maximum Exemption Amount,Maximálna výška výnimky
DocType: Products Settings,Item Fields,Polia položky
DocType: Patient Appointment,Patient Appointment,Menovanie 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ásiť sa z tohto Email Digest
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Get Suppliers By,Získajte dodávateľov od
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,{0} not found for Item {1},{0} sa nenašiel pre položku {1}
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Value must be between {0} and {1},Hodnota musí byť medzi {0} a {1}
DocType: Accounts Settings,Show Inclusive Tax In Print,Zobraziť inkluzívnu daň v tlači
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,"Bank Account, From Date and To Date are Mandatory",Bankový účet od dátumu do dňa je povinný
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Message Sent,Správa bola odoslaná
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with child nodes cannot be set as ledger,Účet s podriadené uzly nie je možné nastaviť ako hlavnej knihy
DocType: C-Form,II,II
apps/erpnext/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py,Vendor Name,Meno predajcu
DocType: Quiz Result,Wrong,zle
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Sazba, za kterou Ceník měna je převeden na zákazníka základní měny"
DocType: Purchase Invoice Item,Net Amount (Company Currency),Čistá suma (Company Mena)
DocType: Sales Partner,Referral Code,referenčný kód
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Celková výška zálohy nemôže byť vyššia ako celková výška sankcie
DocType: Salary Slip,Hour Rate,Hodinová sadzba
apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Povoliť automatické opätovné objednávanie
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 Prenesená pre 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 Vernostný 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.,Detská úloha existuje pre túto úlohu. Túto úlohu nemôžete odstrániť.
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ôzne aktivity
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}","Nastavenie udalostí do {0}, pretože zamestnanec pripojená k nižšie predajcom nemá ID užívateľa {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 cieľové sklad sa musí líšiť
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Failed. Please check your GoCardless Account for more details,Platba zlyhala. Skontrolujte svoj účet GoCardless pre viac informácií
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 je povinná
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the Bank Guarantee Number before submittting.,Pred odoslaním zadajte číslo bankovej záruky.
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ú objednávku nemožno vzniesť voči šablóne položky
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Buying,Pravidlo platia iba pre 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,Pokladničná hotovosť
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Delivery warehouse required for stock item {0},Dodávka sklad potrebný pre živočíšnu 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,Súhrn fakturácie projektu
DocType: Vital Signs,Cuts,rezy
DocType: Serial No,Is Cancelled,Je zrušené
DocType: Student Group,Group Based On,Skupina založená na
DocType: Student Group,Group Based On,Skupina založená na
DocType: Journal Entry,Bill Date,Bill Datum
DocType: Healthcare Settings,Laboratory SMS Alerts,Laboratórne SMS upozornenia
DocType: Manufacturing Settings,Over Production for Sales and Work Order,Nad výroba pre predaj a zákazku
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, frekvencia a množstvo 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ériá analýzy rastlín
DocType: Cheque Print Template,Cheque Height,šek Výška
DocType: Supplier,Supplier Details,Detaily dodávateľa
DocType: Setup Progress,Setup Progress,Pokročilé nastavenie
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,Predvolené sklady na 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,Skontrolovať všetko
,Issued Items Against Work Order,Vydané položky proti pracovnému príkazu
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.js,Vacancies cannot be lower than the current openings,Počet voľných pracovných miest nemôže byť nižší ako súčasné
,BOM Stock Calculated,Výpočet zásob BOM
DocType: Vehicle Log,Invoice Ref,faktúra Ref
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non-GST outward supplies,Vonkajšie dodávky mimo GST
DocType: Company,Default Income Account,Predvolený účet príjmov
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Patient History,História pacientov
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Unclosed Fiscal Years Profit / Loss (Credit),Neuzavretý fiškálnych rokov Zisk / strata (Credit)
DocType: Sales Invoice,Time Sheets,Časové rozvrhy
DocType: Healthcare Service Unit Type,Change In Item,Zmeniť položku
DocType: Payment Gateway Account,Default Payment Request Message,Východzí Platba Request Message
DocType: Retention Bonus,Bonus Amount,Bonusová suma
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}),Zostatok ({0})
DocType: Loyalty Point Entry,Redeem Against,Späť na začiatok
apps/erpnext/erpnext/config/accounts.py,Banking and Payments,Bankovníctvo a platby
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Key,Zadajte prosím kľúč spotrebiteľského kľúča API
DocType: Issue,Service Level Agreement Fulfilled,Splnená dohoda o úrovni služieb
,Welcome to ERPNext,Vitajte v ERPNext
apps/erpnext/erpnext/config/crm.py,Lead to Quotation,Pretvorenie iniciatívy na ponuku
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Email Reminders will be sent to all parties with email contacts,Pripomienky e-mailu budú zaslané všetkým stranám s e-mailovými kontaktmi
DocType: Project,Twice Daily,Dva krát denne
DocType: Inpatient Record,A Negative,Negatívny
apps/erpnext/erpnext/templates/includes/product_list.js,Nothing more to show.,To je všetko
DocType: Lead,From Customer,Od Zákazníka
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Calls,Volania
DocType: Employee Tax Exemption Declaration,Declarations,vyhlásenie
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batches,Šarže
DocType: Appointment Booking Settings,Number of days appointments can be booked in advance,Počet dní schôdzky si môžete rezervovať vopred
DocType: Article,LMS User,Užívateľ LMS
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Place Of Supply (State/UT),Miesto dodania (štát / UT)
DocType: Purchase Order Item Supplied,Stock UOM,Skladová MJ
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Purchase Order {0} is not submitted,Vydaná objednávka {0} nie je odoslaná
DocType: Account,Expenses Included In Asset Valuation,Náklady zahrnuté do ocenenia majetku
DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normálny referenčný rozsah pre dospelého je 16-20 dych / minúta (RCP 2012)
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Set Response Time and Resolution for Priority {0} at index {1}.,Nastavte čas odozvy a rozlíšenie podľa priority {0} na index {1}.
DocType: Customs Tariff Number,Tariff Number,tarif Počet
DocType: Work Order Item,Available Qty at WIP Warehouse,Dostupné množstvo v WIP Warehouse
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 kontrolovať nad-dodávku a nad-rezerváciu pre Položku {0} , keďže množstvo alebo čiastka je 0"
DocType: Issue,Opening Date,Otvárací dátum
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please save the patient first,Najprv si pacienta uložte
apps/erpnext/erpnext/education/api.py,Attendance has been marked successfully.,Účasť bola úspešne označená.
DocType: Program Enrollment,Public Transport,Verejná doprava
DocType: Sales Invoice,GST Vehicle Type,Typ vozidla GST
DocType: Soil Texture,Silt Composition (%),Zloženie sklonu (%)
DocType: Journal Entry,Remark,Poznámka
DocType: Healthcare Settings,Avoid Confirmation,Vyhnite sa konfirmácii
DocType: Bank Account,Integration Details,Podrobnosti o integrácii
DocType: Purchase Receipt Item,Rate and Amount,Sadzba a množstvo
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Account Type for {0} must be {1},Typ účtu pre {0} musí byť {1}
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Cannot Calculate Arrival Time as Driver Address is Missing.,"Nie je možné vypočítať čas príchodu, pretože chýba adresa vodiča."
DocType: Education Settings,Current Academic Term,Aktuálny akademický výraz
DocType: Education Settings,Current Academic Term,Aktuálny akademický výraz
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Item added,Riadok # {0}: Položka bola pridaná
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Service Start Date cannot be greater than Service End Date,Riadok # {0}: Dátum začatia služby nemôže byť väčší ako dátum ukončenia služby
DocType: Sales Order,Not Billed,Nevyúč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,Predvolené pravidlá pre dovolenku
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ý platobný záznam by mal byť spojený s bankovou transakciou dlžníka
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é stredné časové pásmo
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Přistál Náklady Voucher Částka
,Item Balance (Simple),Zostatok položky (jednoduché)
apps/erpnext/erpnext/config/accounts.py,Bills raised by Suppliers.,Faktúry od dodávateľov
DocType: POS Profile,Write Off Account,Odepsat účet
DocType: Patient Appointment,Get prescribed procedures,Získajte predpísané postupy
DocType: Sales Invoice,Redemption Account,Účet spätného odkúpenia
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.js,First add items in the Item Locations table,Najskôr pridajte položky do tabuľky Umiestnenia položiek
DocType: Pricing Rule,Discount Amount,Čiastka zľavy
DocType: Pricing Rule,Period Settings,Nastavenie obdobia
DocType: Purchase Invoice,Return Against Purchase Invoice,Návrat proti nákupnej faktúry
DocType: Item,Warranty Period (in days),Záruční doba (ve dnech)
DocType: Shift Type,Enable Entry Grace Period,Povoliť obdobie odkladu vstupu
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian1,Súvislosť s Guardian1
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},"Prosím, vyberte položku BOM proti položke {0}"
DocType: Shopping Cart Settings,Show Stock Quantity,Zobraziť množstvo zásob
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Čistý peňažný tok z prevádzkovej
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},"Riadok č. {0}: Stav musí byť {1}, aby sa mohlo znížiť množstvo faktúr {2}"
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Bod 4
DocType: Student Admission,Admission End Date,Vstupné Dátum ukončenia
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,študent Group
DocType: Shopping Cart Settings,Quotation Series,Číselná rada ponúk
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 s rovnakým názvom už existuje ({0}), prosím, zmente názov skupiny položiek alebo premenujte položku"
DocType: Soil Analysis Criteria,Soil Analysis Criteria,Kritériá analýzy pôdy
DocType: Pricing Rule Detail,Pricing Rule Detail,Podrobnosti pravidla o cenách
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create BOM,Vytvorte kusovník
DocType: Pricing Rule,Apply Rule On Item Group,Použiť pravidlo pre skupinu položiek
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á suma
DocType: C-Form,I,ja
DocType: Company,Asset Depreciation Cost Center,Asset Odpisy nákladového strediska
apps/erpnext/erpnext/templates/generators/item/item_configure.js,{0} item found.,{0} nájdená položka.
DocType: Production Plan Sales Order,Sales Order Date,Dátum predajnej objednávky
DocType: Sales Invoice Item,Delivered Qty,Dodané množstvo
DocType: Assessment Plan,Assessment Plan,Plan Assessment
DocType: Travel Request,Fully Sponsored,Plne sponzorované
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Zadanie reverzného denníka
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Vytvorte kartu práce
DocType: Quotation,Referral Sales Partner,Sprostredkovateľský predajca
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 vytvorený.
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Momentálne niesu k dispozícii položky v žiadnom sklade
,Payment Period Based On Invoice Date,Platební období na základě data vystavení faktury
DocType: Sample Collection,No. of print,Počet potlače
apps/erpnext/erpnext/education/doctype/question/question.py,No correct answer is set for {0},Pre {0} nie je nastavená žiadna správna odpoveď
DocType: Issue,Response By,Odpoveď používateľom
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Birthday Reminder,Pripomenutie narodenín
DocType: Chart of Accounts Importer,Chart Of Accounts Importer,Dovozca účtovej osnovy
DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,Položka rezervácie izieb hotela
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ázov zdravotného poistenia
DocType: Assessment Plan,Examiner,skúšajúci
DocType: Student,Siblings,súrodenci
DocType: Journal Entry,Stock Entry,Pohyb zásob
DocType: Payment Entry,Payment References,platobné Referencie
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 intervalov pre intervalové pole, napr. Ak je Interval &quot;Dni&quot; a Interval fakturácie je 3, faktúry sa vygenerujú každých 3 dni"
DocType: Clinical Procedure Template,Allow Stock Consumption,Povoliť skladovú zásobu
DocType: Asset,Insurance Details,poistenie Podrobnosti
DocType: Account,Payable,Splatný
DocType: Share Balance,Share Type,Typ zdieľania
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter Repayment Periods,"Prosím, zadajte dobu splácania"
apps/erpnext/erpnext/shopping_cart/cart.py,Debtors ({0}),Dlžníci ({0})
DocType: Pricing Rule,Margin,Marža
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,Menovanie {0} a faktúra predaja {1} boli zrušené
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Opportunities by lead source,Príležitosti podľa zdroja olova
DocType: Appraisal Goal,Weightage (%),Weightage (%)
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Change POS Profile,Zmeniť profil POS
DocType: Bank Reconciliation Detail,Clearance Date,Výprodej Datum
DocType: Delivery Settings,Dispatch Notification Template,Šablóna oznámenia odoslania
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Report,Hodnotiaca správa
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Get Employees,Získajte zamestnancov
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Add your review,Pridajte svoju recenziu
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Gross Purchase Amount is mandatory,Gross Suma nákupu je povinná
apps/erpnext/erpnext/setup/doctype/company/company.js,Company name not same,Názov spoločnosti nie je rovnaký
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 hlavičky účtu v časti Nastavenia GST pre Compnay {0}
DocType: Course Topic,Topic Name,Názov témy
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Approval Notification in HR Settings.,Nastavte predvolenú šablónu pre upozornenie na povolenie na odchýlku v nastaveniach ľudských zdrojov.
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 zamestnanca, aby ste zamestnanca vopred."
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please select a valid Date,Vyberte platný dátum
apps/erpnext/erpnext/public/js/setup_wizard.js,Select the nature of your business.,Vyberte podstatu svojho podnikania.
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 pre výsledky, ktoré vyžadujú iba jeden vstup, výsledok UOM a normálnu hodnotu <br> Zlúčenina pre výsledky, ktoré vyžadujú viac vstupných polí so zodpovedajúcimi názvami udalostí, výsledok UOM a normálne hodnoty <br> Popisné pre testy, ktoré majú viaceré komponenty výsledkov a zodpovedajúce polia zadávania výsledkov. <br> Zoskupené pre testovacie šablóny, ktoré sú skupinou iných testovacích šablón. <br> Žiadny výsledok pre testy bez výsledkov. Taktiež nie je vytvorený žiadny test Lab. eg. Podskupiny pre zoskupené výsledky."
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Duplicate entry in References {1} {2},Riadok # {0}: Duplicitný záznam v referenciách {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,Ako skúšajúci
DocType: Company,Default Expense Claim Payable Account,Splatný účet s predpokladaným výdavkom
DocType: Appointment Type,Default Duration,Predvolená dĺžka trvania
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,Zdieľať knihu
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Sales Invoice {0} created,Faktúra predaja {0} bola vytvorená
DocType: Employee,Confirmation Date,Dátum potvrdenia
DocType: Inpatient Occupancy,Check Out,Odhlásiť sa
DocType: C-Form,Total Invoiced Amount,Celková fakturovaná čiastka
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Min Qty can not be greater than Max Qty,Min množstvo nemôže byť väčšie ako Max množstvo
DocType: Soil Texture,Silty Clay,Silty Clay
DocType: Account,Accumulated Depreciation,oprávky
DocType: Supplier Scorecard Scoring Standing,Standing Name,Stály názov
DocType: Stock Entry,Customer or Supplier Details,Zákazníka alebo dodávateľa Podrobnosti
DocType: Payment Entry,ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-
DocType: Asset Value Adjustment,Current Asset Value,Aktuálna hodnota aktív
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM recursion: {0} cannot be parent or child of {1},Rekurzia kusovníka: {0} nemôže byť rodičom alebo dieťaťom {1}
DocType: QuickBooks Migrator,Quickbooks Company ID,Identifikátor spoločnosti Quickbooks
DocType: Travel Request,Travel Funding,Cestovné financovanie
DocType: Employee Skill,Proficiency,zručnosť
DocType: Loan Application,Required by Date,Vyžadované podľa dátumu
DocType: Purchase Invoice Item,Purchase Receipt Detail,Detail dokladu o kúpe
DocType: Crop Cycle,A link to all the Locations in which the Crop is growing,"Odkaz na všetky lokality, v ktorých rastie plodina"
DocType: Lead,Lead Owner,Získateľ Obchodnej iniciatívy
DocType: Bin,Requested Quantity,požadované množstvo
DocType: Pricing Rule,Party Information,Informácie o večierku
DocType: Fees,EDU-FEE-.YYYY.-,EDU-FEE-.YYYY.-
DocType: Patient,Marital Status,Rodinný stav
DocType: Stock Settings,Auto Material Request,Auto materiálu Poptávka
DocType: Woocommerce Settings,API consumer secret,API spotrebiteľské tajomstvo
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,K dispozícii dávky Množstvo na Od Warehouse
,Received Qty Amount,Prijatá suma Množstvo
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Gross Pay - Total dedukcie - splátky
DocType: Bank Account,Last Integration Date,Dátum poslednej integrácie
DocType: Expense Claim,Expense Taxes and Charges,Dane a poplatky za výdavky
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 New 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,Viac variantov
DocType: Sales Invoice,Against Income Account,Proti účet příjmů
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Delivered,{0}% dodané
DocType: Subscription,Trial Period Start Date,Dátum začiatku skúšobného obdobia
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žstvo {1} nemôže byť nižšia ako minimálna Objednané množstvo {2} (definovanej v bode).
DocType: Certification Application,Certified,certifikované
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 byť iba jedným z
apps/erpnext/erpnext/regional/india/utils.py,Please mention Basic and HRA component in Company,"Uveďte, prosím, komponent Basic a HRA v spoločnosti"
DocType: Daily Work Summary Group User,Daily Work Summary Group User,Používateľ skupiny pre denné zhrnutie 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 nastaviť predvolený {0} vo firme {1}
DocType: Cheque Print Template,Starting position from top edge,Východisková poloha od horného okraja
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Same supplier has been entered multiple times,Rovnaký dodávateľ bol zadaný viackrát
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py,Gross Profit / Loss,Hrubý zisk / strata
,Warehouse wise Item Balance Age and Value,Skladové číslo Položka Stav veku a hodnoty
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Achieved ({}),Dosiahnuté ({})
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ázov spoločnosti nemôže byť Company
apps/erpnext/erpnext/support/doctype/issue/issue.py,{0} parameter is invalid,Parameter {0} je neplatný
apps/erpnext/erpnext/config/settings.py,Letter Heads for print templates.,Dopis hlavy na tiskových š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ôdza
DocType: Student Guardian,Student Guardian,študent Guardian
DocType: Member,Member Name,Meno člena
DocType: Stock Settings,Use Naming Series,Použiť pomenovacie série
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,No Action,Žiadna akcia
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Valuation type charges can not marked as Inclusive,Poplatky typu ocenenie môže nie je označený ako 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,Platobné ú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,Čítanie nahraného súboru
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Zastavenú pracovnú objednávku nemožno zrušiť, najskôr ju zrušte zrušením"
DocType: Coupon Code,Coupon Code,kód kupónu
DocType: Asset,Journal Entry for Scrap,Zápis do denníka 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},Riadok {0}: vyberte pracovnú stanicu proti operácii {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} už použité v účte {2}
apps/erpnext/erpnext/config/crm.py,"Record of all communications of type email, phone, chat, visit, etc.","Záznam všetkých oznámení typu e-mail, telefón, chát, návštevy, atď"
DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Hodnotenie skóre dodávateľa
DocType: Manufacturer,Manufacturers used in Items,Výrobcovia používané v bodoch
apps/erpnext/erpnext/accounts/general_ledger.py,Please mention Round Off Cost Center in Company,"Prosím, uveďte zaokrúhliť nákladové stredisko v spoločnosti"
DocType: Purchase Invoice,Terms,Podmínky
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Select Days,Vyberte dni
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},Riadok {0}: Nastavte správny kód v platobnom režime {1}
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Credit ({0}),Úver ({0})
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Creating Salary Slips...,Vytváranie platových taríf ...
apps/erpnext/erpnext/hr/doctype/department/department.js,You cannot edit root node.,Nemôžete upraviť koreňový uzol.
DocType: Buying Settings,Purchase Order Required,Vydaná objednávka je vyžadována
apps/erpnext/erpnext/public/js/projects/timer.js,Timer,časomerač
,Item-wise Sales History,Item-moudrý Sales History
DocType: Expense Claim,Total Sanctioned Amount,Celková částka potrestána
,Purchase Analytics,Analýza nákupu
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á flexibilná čiastka dávky {0} by nemala byť nižšia ako maximálna 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álna faktúra {0} chýba
apps/erpnext/erpnext/controllers/accounts_controller.py,Row {0}: user has not applied the rule {1} on the item {2},Riadok {0}: používateľ neuplatnil pravidlo {1} na položku {2}
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. ","Ak je vybratá, hodnota špecifikovaná alebo vypočítaná v tejto zložke neprispieva k výnosom alebo odpočtom. Avšak, jeho hodnota môže byť odkazovaná na iné komponenty, ktoré môžu byť pridané alebo odpočítané."
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. ","Ak je vybratá, hodnota špecifikovaná alebo vypočítaná v tejto zložke neprispieva k výnosom alebo odpočtom. Avšak, jeho hodnota môže byť odkazovaná na iné komponenty, ktoré môžu byť pridané alebo odpočítané."
,Stock Ledger,Súpis zásob
DocType: Company,Exchange Gain / Loss Account,Exchange Zisk / straty
DocType: Amazon MWS Settings,MWS Credentials,Poverenia MWS
apps/erpnext/erpnext/config/selling.py,Blanket Orders from Costumers.,Peňažné objednávky od zákazníkov.
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,Komunitné fórum
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Actual qty in stock,Aktuálne množstvo na sklade
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Actual qty in stock,Aktuálne množstvo na sklade
DocType: Homepage,"URL for ""All Products""",URL pre &quot;všetky produkty&quot;
DocType: Leave Application,Leave Balance Before Application,Nechte zůstatek před aplikací
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Send SMS,Poslať SMS
DocType: Supplier Scorecard Criteria,Max Score,Maximálny výsledok
DocType: Cheque Print Template,Width of amount in word,Šírka sumy v slove
DocType: Purchase Order,Get Items from Open Material Requests,Získať predmety z žiadostí Otvoriť 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,Spracovateľská schéma účtov a strán
DocType: Lab Test Template,Standard Selling Rate,Štandardné predajné kurz
DocType: Account,Rate at which this tax is applied,"Sadzba, pri ktorej sa použije táto daň"
DocType: Cash Flow Mapper,Section Name,Názov sekcie
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},Riadok odpisov {0}: Očakávaná hodnota po uplynutí životnosti musí byť väčšia alebo rovná {1}
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Current Job Openings,Aktuálne pracovné príležitosti
DocType: Company,Stock Adjustment Account,Reklamní Nastavení účtu
apps/erpnext/erpnext/public/js/payment/pos_payment.html,Write Off,Odpísať
apps/erpnext/erpnext/quality_management/doctype/quality_procedure/quality_procedure.py,{0} already has a Parent Procedure {1}.,{0} už má rodičovský postup {1}.
DocType: Healthcare Service Unit,Allow Overlap,Povoliť prekrytie
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Operation ID,Prevádzka 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,Zadajte podrobnosti o odpisoch
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,{0}: From {1},{0}: Z {1}
DocType: Bank Transaction Mapping,Column in Bank File,Stĺpec v bankovom súbore
apps/erpnext/erpnext/education/doctype/student_leave_application/student_leave_application.py,Leave application {0} already exists against the student {1},Ponechať aplikáciu {0} už existuje proti študentovi {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.,Naliehavá aktualizácia najnovšej ceny vo všetkých účtovných dokladoch. Môže to trvať niekoľko minút.
DocType: Pick List,Get Item Locations,Získajte informácie o položkách
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,"Názov nového účtu. Poznámka: Prosím, vytvárať účty pre zákazníkov a dodávateľmi"
DocType: POS Profile,Display Items In Stock,Zobraziť položky na sklade
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 platobný príkaz
DocType: Water Analysis,Appearance,vzhľad
DocType: HR Settings,Leave Status Notification Template,Opustiť šablónu oznamovania stavu
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Avg. Buying Price List Rate,Avg. Cena nákupného cenníka
DocType: Sales Order Item,Supplier delivers to Customer,Dodávateľ doručí zákazníkovi
apps/erpnext/erpnext/config/non_profit.py,Member information.,Informácie pre členov.
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}) nie je na sklade
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Maintenance,Údržba majetku
,Sales Payment Summary,Prehľad platieb z predaja
DocType: Restaurant,Restaurant,reštaurácie
DocType: Woocommerce Settings,API consumer key,API spotrebiteľský kľúč
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,Vyžaduje sa „dátum“
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 dát a export
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Ľutujeme, platnosť kódu kupónu vypršala"
DocType: Bank Account,Account Details,Údaje o účtu
DocType: Crop,Materials Required,Potrebné materiály
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Žiadni študenti Nájdené
DocType: Employee Tax Exemption Declaration,Monthly HRA Exemption,Mesačná výnimka pre HRA
DocType: Clinical Procedure,Medical Department,Lekárske oddelenie
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Early Exits,Celkový počet predčasných odchodov
DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Hodnotiace kritériá pre dodávateľa Scorecard
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,Invoice Posting Date,Faktúra Dátum zverejnenia
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Sell,Predať
DocType: Purchase Invoice,Rounded Total,Zaoblený Total
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Slots for {0} are not added to the schedule,Sloty pre {0} nie sú pridané 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},Cieľová poloha je vyžadovaná pri prenose diela {0}
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Not permitted. Please disable the Test Template,Nepovolené. Vypnite testovaciu šablónu
DocType: Sales Invoice,Distance (in km),Vzdialenosť (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 Dátum zverejnenia pred výberom Party"
apps/erpnext/erpnext/config/accounts.py,Payment Terms based on conditions,Platobné podmienky založené na podmienkach
DocType: Program Enrollment,School House,School House
DocType: Serial No,Out of AMC,Out of AMC
DocType: Opportunity,Opportunity Amount,Príležitostná suma
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Your Profile,Tvoj profil
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Počet Odpisy rezervované nemôže byť väčšia ako celkový počet Odpisy
DocType: Purchase Order,Order Confirmation Date,Dátum potvrdenia objednávky
DocType: Driver,HR-DRI-.YYYY.-,HR-DRI-.YYYY.-
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py,All Products,Všetky produkty
DocType: Employee Transfer,Employee Transfer Details,Podrobnosti o zamestnancovi
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úce
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žené na účasti tohto študenta
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,No Students in,Žiadni študenti v
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Add more items or open full form,Pridať ďalšie položky alebo otvorené plnej forme
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,Placená částka + odepsat Částka nesmí být větší než Grand Total
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} nie je platné číslo Šarže pre Položku {1}
apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Zadajte platný kupónový 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 úlohy
DocType: Training Event,Seminar,seminár
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,Zamestnanec
DocType: Employee Transfer,New Company,Nová spoločnost
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py,Transactions can only be deleted by the creator of the Company,Transakcie môžu byť vymazané len tvorca Spoloč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 Šírka
DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Overenie predajná cena výtlačku proti platbe alebo ocenenia Rate
DocType: Fee Schedule,Fee Schedule,poplatok Plán
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Column Labels : ,Štítky stĺpcov:
DocType: Bank Transaction,Settled,usadil
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Disbursement Date cannot be after Loan Repayment Start Date,Dátum vyplatenia nemôže byť po dátume začatia splácania úveru
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Cess,Cess
DocType: Quality Feedback,Parameters,parametre
DocType: Company,Create Chart Of Accounts Based On,Vytvorte účtový rozvrh založený na
apps/erpnext/erpnext/education/doctype/student/student.py,Date of Birth cannot be greater than today.,Dátum narodenia nemôže byť väčšia ako dnes.
,Stock Ageing,Starnutie zásob
DocType: Travel Request,"Partially Sponsored, Require Partial Funding","Čiastočne sponzorované, vyžadujú čiastočné financovanie"
apps/erpnext/erpnext/education/doctype/student/student.py,Student {0} exist against student applicant {1},Existujú Študent {0} proti uchádzač študent {1}
DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Úprava zaokrúhľovania (mena spoločnosti)
apps/erpnext/erpnext/projects/doctype/task/task.js,Timesheet,Pracovný výkaz
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Batch: ,šarže:
DocType: Volunteer,Afternoon,Popoludnie
DocType: Loyalty Program,Loyalty Program Help,Nápoveda vernostné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,Nastaviť ako Otvorené
DocType: Cheque Print Template,Scanned Cheque,skenovaných Šek
DocType: Timesheet,Total Billable Amount,Celková fakturovaná suma
DocType: Customer,Credit Limit and Payment Terms,Úverový limit a platobné podmienky
DocType: Loyalty Program,Collection Rules,Pravidlá zberu
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,Zadanie objednávky
DocType: Purchase Order,Customer Contact Email,Kontaktný e-mail zákazníka
DocType: Warranty Claim,Item and Warranty Details,Položka a Záruka Podrobnosti
DocType: Chapter,Chapter Members,Členovia kapitoly
DocType: Sales Team,Contribution (%),Príspevok (%)
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šetrujúci používateľ
DocType: Employee Benefit Application,Payroll Period,Mzdové obdobie
DocType: Plant Analysis,Plant Analysis Criterias,Kritériá analýzy rastlín
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Batch {1},Sériové číslo {0} nepatrí do dávky {1}
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Your email address...,Vaša emailová adresa...
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Responsibilities,Zodpovednosť
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Validity period of this quotation has ended.,Platnosť tejto ponuky sa skončila.
DocType: Expense Claim Account,Expense Claim Account,Náklady na poistné Account
DocType: Account,Capital Work in Progress,Kapitál Rozrobenosť
DocType: Accounts Settings,Allow Stale Exchange Rates,Povoliť stale kurzy výmeny
DocType: Sales Person,Sales Person Name,Meno predajcu
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,Nebol vytvorený žiadny laboratórny test
DocType: POS Item Group,Item Group,Položková skupina
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Student Group: ,Skupina študentov:
DocType: Depreciation Schedule,Finance Book Id,ID finančnej knihy
DocType: Item,Safety Stock,Bezpečnostná zásoba
DocType: Healthcare Settings,Healthcare Settings,Nastavenia zdravotnej starostlivosti
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Total Allocated Leaves,Celkové pridelené listy
apps/erpnext/erpnext/projects/doctype/task/task.py,Progress % for a task cannot be more than 100.,Pokrok% za úlohu nemôže byť viac ako 100.
DocType: Stock Reconciliation Item,Before reconciliation,Pred odsúhlasením
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í byť dlhodobý majetok položka
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,HSN,HSN
DocType: Item,Default BOM,Východzí BOM
DocType: Project,Total Billed Amount (via Sales Invoices),Celková fakturovaná suma (prostredníctvom faktúr za predaj)
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Debit Note Amount,Výška dlžnej sumy
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,"There are inconsistencies between the rate, no of shares and the amount calculated","Existujú nezrovnalosti medzi sadzbou, počtom akcií a vypočítanou sumou"
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,You are not present all day(s) between compensatory leave request days,Nie ste prítomní celý deň (dni) medzi náhradnými dovolenkovými dňami
apps/erpnext/erpnext/setup/doctype/company/company.js,Please re-type company name to confirm,Prosím re-typ názov spoločnosti na potvrdenie
DocType: Journal Entry,Printing Settings,Nastavenie tlače
DocType: Payment Order,Payment Order Type,Typ platobného príkazu
DocType: Employee Advance,Advance Account,Advance účet
DocType: Job Offer,Job Offer Terms,Podmienky ponuky práce
DocType: Sales Invoice,Include Payment (POS),Zahŕňajú platby (POS)
DocType: Shopify Settings,eg: frappe.myshopify.com,napr .: frappe.myshopify.com
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement tracking is not enabled.,Sledovanie dohody o úrovni služieb nie je povolené.
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,Poisťovňa
DocType: Asset Category Account,Fixed Asset Account,Fixed Asset Account
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Variable,premenlivý
apps/erpnext/erpnext/regional/italy/utils.py,"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","Fiškálny režim je povinný, láskavo nastavte fiškálny režim v spoločnosti {0}"
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js,From Delivery Note,Z Dodacího Listu
DocType: Chapter,Members,členovia
DocType: Student,Student Email Address,Študent E-mailová adresa
DocType: Item,Hub Warehouse,Hub Warehouse
DocType: Appointment Booking Slots,From Time,Času od
DocType: Hotel Settings,Hotel Settings,Nastavenia hotela
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html,In Stock: ,Na sklade:
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,Nastavenia LMS
DocType: Company,Discount Allowed Account,Zľavový účet
DocType: Loyalty Program,Multiple Tier Program,Viacvrstvový program
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Address,Adresa študenta
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Address,Adresa študenta
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šetky skupiny dodávateľov
DocType: Employee Boarding Activity,Required for Employee Creation,Požadované pre tvorbu zamestnancov
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dodávateľ&gt; Typ dodávateľa
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account Number {0} already used in account {1},Číslo účtu {0} už použité v účte {1}
DocType: GoCardless Mandate,Mandate,mandát
DocType: Hotel Room Reservation,Booked,rezervovaný
DocType: Detected Disease,Tasks Created,Vytvorené úlohy
DocType: Purchase Invoice Item,Rate,Sadzba
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Intern,Internovat
DocType: Coupon Code,"e.g. ""Summer Holiday 2019 Offer 20""","napr. „Letná dovolenka 2019, ponuka 20“"
DocType: Delivery Stop,Address Name,Meno adresy
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,Skladové transakcie pred {0} sú zmrazené
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álny č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 pri hodnotení kritéria kritérií
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čiatočný zostatok
DocType: Salary Slip,Salary Structure,Štruktúra platu
DocType: Account,Bank,Banka
DocType: Job Card,Job Started,Úloha sa začala
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,Pripojte službu Shopify s nástrojom ERPNext
DocType: Production Plan,For Warehouse,Pro Sklad
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,Delivery Notes {0} updated,Poznámky o doručení {0} boli aktualizované
DocType: Employee,Offer Date,Dátum Ponuky
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Quotations,Ponuky
DocType: Purchase Order,Inter Company Order Reference,Referencia objednávky medzi spoločnosťami
apps/erpnext/erpnext/accounts/page/pos/pos.js,You are in offline mode. You will not be able to reload until you have network.,"Ste v režime offline. Nebudete môcť znovu, kým nebudete mať sieť."
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Qty increased by 1,Riadok # {0}: Množstvo sa zvýšilo o 1
DocType: Account,Include in gross,Zahrnúť do brutto
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.,Žiadne študentské skupiny vytvorený.
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,Mesačné splátky suma nemôže byť vyššia ako suma úveru
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,Riadok # {0}: Predpokladaný dátum doručenia nemôže byť pred dátumom objednávky
DocType: Purchase Invoice,Print Language,Jazyk tlače
DocType: Salary Slip,Total Working Hours,Celkovej pracovnej 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},Nie ste prihlásení do programu {0}
DocType: Stock Entry,Including items for sub assemblies,Vrátane položiek pre montážnych podskupín
DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Dočasný úvodný účet
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods In Transit,Tovar v tranzite
apps/erpnext/erpnext/accounts/page/pos/pos.js,Enter value must be positive,Zadajte hodnota musí byť kladná
DocType: Asset,Finance Books,Finančné knihy
DocType: Employee Tax Exemption Declaration Category,Employee Tax Exemption Declaration Category,Vyhlásenie o oslobodení od dane zamestnancov
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py,All Territories,Všetky územia
DocType: Lost Reason Detail,Lost Reason Detail,Podrobnosti strateného dôvodu
apps/erpnext/erpnext/hr/utils.py,Please set leave policy for employee {0} in Employee / Grade record,Nastavte prosím politiku dovolenky pre zamestnanca {0} v zázname Employee / Grade
apps/erpnext/erpnext/public/js/controllers/transaction.js,Invalid Blanket Order for the selected Customer and Item,Neplatná objednávka prázdnej objednávky pre vybraného zákazníka a položku
apps/erpnext/erpnext/projects/doctype/task/task_tree.js,Add Multiple Tasks,Pridať viacero úloh
DocType: Purchase Invoice,Items,Položky
apps/erpnext/erpnext/crm/doctype/contract/contract.py,End Date cannot be before Start Date.,Dátum ukončenia nemôže byť pred dátumom začiatku.
apps/erpnext/erpnext/education/doctype/course_enrollment/course_enrollment.py,Student is already enrolled.,Študent je už zapísané.
DocType: Fiscal Year,Year Name,Meno 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,Nasledujúce položky {0} nie sú označené ako položka {1}. Môžete ich povoliť ako {1} položku z jeho položky Master
DocType: Production Plan Item,Product Bundle Item,Položka produktového balíčka
DocType: Sales Partner,Sales Partner Name,Meno predajného partnera
apps/erpnext/erpnext/hooks.py,Request for Quotations,Žiadosť o citátov
DocType: Payment Reconciliation,Maximum Invoice Amount,Maximálna suma faktúry
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() failed for empty IBAN,BankAccount.validate_iban () zlyhal pre prázdny IBAN
DocType: Normal Test Items,Normal Test Items,Normálne testované položky
DocType: QuickBooks Migrator,Company Settings,Nastavenia firmy
DocType: Additional Salary,Overwrite Salary Structure Amount,Prepísať sumu štruktúry platu
DocType: Leave Ledger Entry,Leaves,listy
DocType: Student Language,Student Language,študent 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,Odoslať dôkaz
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order/Quot %,Objednávka / kvóta%
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,Zaznamenajte vitálne hodnoty pacienta
DocType: Fee Schedule,Institution,inštitúcie
DocType: Asset,Partially Depreciated,čiastočne odpíše
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,Vyhľadávanie dokumentov
apps/erpnext/erpnext/stock/doctype/item/item.py,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Východzí merná jednotka varianty &#39;{0}&#39; musí byť rovnaký ako v Template &#39;{1}&#39;
DocType: Shipping Rule,Calculate Based On,Vypočítať na základe
DocType: Contract,Unfulfilled,nesplnený
DocType: Delivery Note Item,From Warehouse,Zo skladu
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,No employees for the mentioned criteria,Žiadni zamestnanci pre uvedené kritériá
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials to Manufacture,Žiadne položky s Bill of Materials Výroba
DocType: Shopify Settings,Default Customer,Predvolený zákazník
DocType: Sales Stage,Stage Name,Pseudonym
apps/erpnext/erpnext/config/getting_started.py,Data Import and Settings,Import a nastavenie údajov
DocType: Warranty Claim,SER-WRN-.YYYY.-,SER-WRN-.YYYY.-
DocType: Assessment Plan,Supervisor Name,Meno Supervisor
DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,"Nepotvrdzujú, či sa schôdzka vytvorí v ten istý deň"
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Ship To State,Loď do štátu
DocType: Program Enrollment Course,Program Enrollment Course,Program na zápis do programu
DocType: Program Enrollment Course,Program Enrollment Course,Program na zápis do programu
DocType: Invoice Discounting,Bank Charges,Bankové poplatky
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner.py,User {0} is already assigned to Healthcare Practitioner {1},Používateľ {0} je už pridelený zdravotnému lekárovi {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ávanie / Review
DocType: Leave Encashment,Encashment Amount,Suma 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,Vypršané dávky
DocType: Employee,This will restrict user access to other employee records,Tým sa obmedzí prístup používateľov k iným záznamom zamestnancov
DocType: Tax Rule,Shipping City,Mesto dodania
apps/erpnext/erpnext/regional/india/utils.py,GST HSN Code does not exist for one or more items,Kód GST HSN neexistuje pre jednu alebo viac položiek
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 ({}),Variácia ({})
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Rate or Discount is required for the price discount.,Na zľavu z ceny sa vyžaduje sadzba alebo zľava.
DocType: Purchase Invoice,Import Of Service,Import služieb
DocType: Education Settings,LMS Title,Názov LMS
DocType: Sales Invoice,Ship,loď
DocType: Staffing Plan Detail,Current Openings,Aktuálne otvorenia
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Operations,Cash flow z prevádzkových činností
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CGST Amount,CGST Suma
apps/erpnext/erpnext/utilities/activation.py,Create Student,Vytvorte študenta
DocType: Asset Movement Item,Asset Movement Item,Položka na presun majetku
DocType: Purchase Invoice,Shipping Rule,Prepravné pravidlo
DocType: Patient Relation,Spouse,manželka
DocType: Lab Test Groups,Add Test,Pridať test
DocType: Manufacturer,Limited to 12 characters,Obmedzené na 12 znakov
DocType: Journal Entry,Print Heading,Hlavička tlače
DocType: Quality Action Table,Quality Action Table,Tabuľka kvality
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Total cannot be zero,Suma nemôže byť nulová
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,'Days Since Last Order' must be greater than or equal to zero,"""Dní od poslednej objednávky"" musí byť väčšie alebo rovnajúce sa nule"
DocType: Plant Analysis Criteria,Maximum Permissible Value,Maximálna prípustná hodnota
apps/erpnext/erpnext/selling/report/item_wise_sales_history/item_wise_sales_history.py,Delivered Quantity,Dodané množstvo
DocType: Journal Entry Account,Employee Advance,Zamestnanec Advance
DocType: Payroll Entry,Payroll Frequency,mzdové frekvencia
DocType: Plaid Settings,Plaid Client ID,ID platného klienta
DocType: Lab Test Template,Sensitivity,citlivosť
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,"Synchronizácia bola dočasne zakázaná, pretože boli prekročené maximálne počet opakovaní"
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Raw Material,Surovina
DocType: Leave Application,Follow via Email,Sledovať e-mailom
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Plants and Machineries,Rastliny a strojné vybavenie
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Částka daně po slevě Částka
DocType: Patient,Inpatient Status,Stav lôžka
DocType: Asset Finance Book,In Percentage,V percentách
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Selected Price List should have buying and selling fields checked.,Vybraný cenník by mal kontrolovať pole nákupu a predaja.
apps/erpnext/erpnext/controllers/buying_controller.py,Please enter Reqd by Date,Zadajte Reqd podľa dátumu
DocType: Payment Entry,Internal Transfer,vnútorné Prevod
DocType: Asset Maintenance,Maintenance Tasks,Úlohy ú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 najprv Dátum zverejnenia"
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date should be before Closing Date,Dátum začatia by mala byť pred uzávierky
DocType: Travel Itinerary,Flight,Let
apps/erpnext/erpnext/public/js/hub/pages/NotFound.vue,Back to home,Späť domov
DocType: Leave Control Panel,Carry Forward,Preniesť
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í pri rezervácii skutočných výdavkov
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 integrácie
DocType: Crop Cycle,Detected Disease,Zistená choroba
,Produced,Produkoval
apps/erpnext/erpnext/stock/report/stock_and_account_value_comparison/stock_and_account_value_comparison.py,Stock Ledger ID,ID skladu
DocType: Issue,Raised By (Email),Vznesené (e-mail)
DocType: Issue,Service Level Agreement,Dohoda o úrovni služieb
DocType: Training Event,Trainer Name,Meno tréner
DocType: Mode of Payment,General,Všeobecný
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication,Posledná komunikácia
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication,Posledná komunikácia
,TDS Payable Monthly,TDS splatné mesačne
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Namiesto výmeny kusovníka. Môže to trvať niekoľko minút.
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,Spárovať úhrady s faktúrami
DocType: Payment Entry,Get Outstanding Invoice,Získajte vynikajúcu faktúru
DocType: Journal Entry,Bank Entry,Bank Entry
apps/erpnext/erpnext/stock/doctype/item/item.py,Updating Variants...,Aktualizácia variantov ...
DocType: Authorization Rule,Applicable To (Designation),Vztahující se na (označení)
,Profitability Analysis,Analýza ziskovosti
DocType: Fees,Student Email,Študentský e-mail
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Disburse Loan,Vyplatiť pôžičku
DocType: Supplier,Prevent POs,Zabráňte organizáciám výrobcov
DocType: Patient,"Allergies, Medical and Surgical History","Alergie, lekárske a chirurgické dejepisy"
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Add to Cart,Pridať do košíka
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,Nepodarilo sa odoslať niektoré platobné pásky
DocType: Project Template,Project Template,Šablóna projektu
DocType: Exchange Rate Revaluation,Get Entries,Získajte záznamy
DocType: Production Plan,Get Material Request,Získať 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,Súhrn predajov
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čte / vytvorte účet (skupinu) pre typ - {0}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Entertainment & Leisure,Entertainment & Leisure
,Item Variant Details,Podrobnosti o variantoch položky
DocType: Quality Inspection,Item Serial No,Položka Výrobní číslo
DocType: Payment Request,Is a Subscription,Je predplatné
apps/erpnext/erpnext/utilities/activation.py,Create Employee Records,Vytvoriť zamestnanecké záznamy
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á faktúra predaja
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select Qty against item {0},Vyberte položku Qty v položke {0}
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Latest Age,Najnovší vek
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py,Scheduled and Admitted dates can not be less than today,Plánované a prijaté dátumy nemôžu byť nižšie ako dnes
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Transfer Material to Supplier,Preneste materiál Dodávateľovi
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,"New Pořadové číslo nemůže mít Warehouse. Warehouse musí být nastaveny Stock vstupním nebo doklad o koupi,"
DocType: Lead,Lead Type,Typ Iniciatívy
apps/erpnext/erpnext/utilities/activation.py,Create Quotation,Vytvoriť Ponuku
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,You are not authorized to approve leaves on Block Dates,Nie ste oprávnení schvaľovať lístie na bloku Termíny
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} Request for {1},{0} Žiadosť 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} sa nenašli žiadne nevyrovnané faktúry, ktoré by spĺňali zadané filtre."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Set New Release Date,Nastavte nový dátum vydania
DocType: Company,Monthly Sales Target,Mesačný cieľ predaja
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,No outstanding invoices found,Nenašli sa žiadne neuhradené faktúry
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Can be approved by {0},Môže byť schválené kým: {0}
DocType: Hotel Room,Hotel Room Type,Typ izby hotela
DocType: Customer,Account Manager,Account Manager
DocType: Issue,Resolution By Variance,Rozlíšenie podľa odchýlky
DocType: Leave Allocation,Leave Period,Opustiť obdobie
DocType: Item,Default Material Request Type,Predvolený typ materiálovej požiadavky
DocType: Supplier Scorecard,Evaluation Period,Hodnotiace obdobie
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js,Unknown,nevedno
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order not created,Pracovná objednávka nebola vytvorená
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}","Suma {0}, ktorá už bola požadovaná pre komponent {1}, \ nastavila čiastku rovnú alebo väčšiu ako {2}"
DocType: Shipping Rule,Shipping Rule Conditions,Přepravní Článek Podmínky
DocType: Salary Slip Loan,Salary Slip Loan,Úverový splátkový úver
DocType: BOM Update Tool,The new BOM after replacement,Nový BOM po výměně
,Point of Sale,Miesto predaja
DocType: Payment Entry,Received Amount,Prijatá suma
DocType: Patient,Widow,vdova
DocType: GST Settings,GSTIN Email Sent On,GSTIN E-mail odoslaný na
DocType: Program Enrollment,Pick/Drop by Guardian,Pick / Drop od Guardian
DocType: Bank Account,SWIFT number,SWIFT číslo
DocType: Payment Entry,Party Name,Meno Party
DocType: POS Closing Voucher,Total Collected Amount,Celková vyzbieraná suma
DocType: Employee Benefit Application,Benefits Applied,Výhody aplikované
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,Časová lehota odozvy
DocType: Contract,Signed,podpísaný
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices Summary,Otvorenie súhrnu faktúr
DocType: Member,NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-
DocType: Education Settings,Education Manager,Správca vzdelávania
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inter-State Supplies,Medzištátne dodávky
DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Minimálna dĺžka medzi jednotlivými rastlinami v teréne pre optimálny rast
DocType: Quality Inspection,Report Date,Datum Reportu
DocType: BOM,Routing,Smerovanie
DocType: Serial No,Asset Details,Podrobnosti o majetku
DocType: Employee Tax Exemption Declaration Category,Declared Amount,Deklarovaná suma
DocType: Bank Statement Transaction Payment Item,Invoices,Faktúry
DocType: Water Analysis,Type of Sample,Typ vzorky
DocType: Batch,Source Document Name,Názov zdrojového dokumentu
DocType: Batch,Source Document Name,Názov zdrojového dokumentu
DocType: Production Plan,Get Raw Materials For Production,Získajte suroviny pre výrobu
DocType: Job Opening,Job Title,Názov pozície
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Budúca platba Ref
DocType: Quotation,Additional Discount and Coupon Code,Dodatočný zľavový a kupónový 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 ponuku, ale boli citované všetky položky \. Aktualizácia stavu ponuky 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álne vzorky - {0} už boli zadržané pre dávku {1} a položku {2} v dávke {3}.
DocType: Manufacturing Settings,Update BOM Cost Automatically,Automaticky sa aktualizuje cena kusovníka
DocType: Lab Test,Test Name,Názov testu
DocType: Healthcare Settings,Clinical Procedure Consumable Item,Klinický postup Spotrebný bod
apps/erpnext/erpnext/utilities/activation.py,Create Users,Vytvoriť používateľov
DocType: Employee Tax Exemption Category,Max Exemption Amount,Maximálna suma výnimky
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,Subscriptions,odbery
DocType: Quality Review Table,Objective,objektívny
DocType: Supplier Scorecard,Per Month,Za mesiac
DocType: Education Settings,Make Academic Term Mandatory,Akademický termín je povinný
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Quantity to Manufacture must be greater than 0.,"Množstvo, ktoré má výroba musí byť väčšia ako 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,Obnovovaciu rýchlosť a dostupnosť
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.,"Percento, ktoré máte možnosť prijať alebo dodať naviac oproti objednanému množstvu. Napríklad: Keď ste si objednali 100 kusov a váša tolerancia je 10%, tak máte možnosť prijať 110 kusov."
DocType: Shopping Cart Settings,Show Contact Us Button,Zobraziť tlačidlo Kontaktujte nás
DocType: Loyalty Program,Customer Group,Zákaznícka skupina
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch ID (Optional),Nové číslo dávky (voliteľné)
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch ID (Optional),Nové číslo dávky (voliteľné)
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,Dátum vydania musí byť v budúcnosti
DocType: BOM,Website Description,Popis webu
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Equity,Čistá zmena vo vlastnom imaní
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py,Not permitted. Please disable the Service Unit Type,Nepovolené. Zakážte typ servisnej jednotky
apps/erpnext/erpnext/crm/doctype/lead/lead.py,"Email Address must be unique, already exists for {0}","E-mailová adresa musí byť jedinečná, už existuje pre {0}"
DocType: Serial No,AMC Expiry Date,AMC Datum vypršení platnosti
DocType: Asset,Receipt,Potvrdenka
,Sales Register,Sales Register
DocType: Daily Work Summary Group,Send Emails At,Posielať e-maily At
DocType: Quotation Lost Reason,Quotation Lost Reason,Dôvod neúspešnej ponuky
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é transakcie no {0} z {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,Zobrazenie formulára
DocType: HR Settings,Expense Approver Mandatory In Expense Claim,Povinnosť priraďovania nákladov v nárokoch na výdavky
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Summary for this month and pending activities,Zhrnutie pre tento mesiac a prebiehajúcim činnostiam
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 v spoloč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}),Riadok {0}: Množstvo nie je k dispozícii pre {4} v sklade {1} v čase účtovania vstupu ({2} {3})
apps/erpnext/erpnext/public/js/pos/pos.html,No Customers yet!,Zatiaľ žiadni zákazníci!
DocType: Quality Procedure Process,Link existing Quality Procedure.,Prepojiť existujúci postup kvality.
apps/erpnext/erpnext/config/hr.py,Loans,pôžičky
DocType: Healthcare Service Unit,Healthcare Service Unit,Útvar zdravotníckej služby
,Customer-wise Item Price,Cena tovaru podľa priania zákazníka
apps/erpnext/erpnext/public/js/financial_statements.js,Cash Flow Statement,Prehľad o peňažných tokoch
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No material request created,Žiadna materiálová žiadosť nebola vytvorená
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.py,Loan Amount cannot exceed Maximum Loan Amount of {0},Výška úveru nesmie prekročiť maximálnu úveru Suma {0}
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,License,licencie
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),Telefón (R)
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Time slots added,Pridané časové úseky
DocType: Products Settings,Attributes,Atribúty
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Enable Template,Povoliť šablónu
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,Posledná Dátum objednávky
DocType: Accounts Settings,Unlink Advance Payment on Cancelation of Order,Odpojte zálohovú platbu pri zrušení objednávky
DocType: Salary Component,Is Payable,Je splatné
DocType: Inpatient Record,B Negative,B Negatívny
DocType: Pricing Rule,Price Discount Scheme,Schéma zníženia ceny
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í byť zrušený alebo dokončený na odoslanie
DocType: Amazon MWS Settings,US,US
DocType: Holiday List,Add Weekly Holidays,Pridajte týždenné sviatky
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Report Item,Položka správy
DocType: Staffing Plan Detail,Vacancies,voľné miesta
DocType: Hotel Room,Hotel Room,Hotelová izba
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} does not belongs to company {1},Účet {0} nie je patria spoločnosti {1}
DocType: Homepage Section,Use this field to render any custom HTML in the section.,Toto pole slúži na vykreslenie vlastného HTML v tejto sekcii.
DocType: Leave Type,Rounding,zaokrúhľovania
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 riadku {0} sa nezhodujú s dodacím listom
DocType: Employee Benefit Application,Dispensed Amount (Pro-rated),Vyčlenená čiastka (premenná)
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! Prvé dve číslice GSTIN by sa mali zhodovať s číslom štátu {0}.
DocType: Agriculture Task,Start Day,Deň začiatku
DocType: Vehicle,Chassis No,Číslo podvozku
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ík
DocType: Purchase Invoice,Availed ITC Integrated Tax,Využil integrovanú daň z ITC
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Repayment Entry,Založenie záznamu o vrátení
DocType: Purchase Order Item,Blanket Order Rate,Dekoračná objednávka
,Customer Ledger Summary,Zhrnutie knihy odberateľov
apps/erpnext/erpnext/hooks.py,Certification,osvedčenie
DocType: Bank Guarantee,Clauses and Conditions,Doložky a podmienky
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ískajte faktúry
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čiť
DocType: Project,Expected End Date,Očekávané datum ukončení
DocType: Budget Account,Budget Amount,rozpočet Suma
DocType: Donor,Donor Name,Názov darcu
DocType: Journal Entry,Inter Company Journal Entry Reference,Inter Company Entry Reference
DocType: Course,Topics,témy
DocType: Tally Migration,Is Day Book Data Processed,Spracovávajú sa údaje dennej knihy
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 Súčasné použitie
DocType: Employee Tax Exemption Proof Submission,House Rent Payment Amount,Dom Prenájom Platba Suma
DocType: Student Admission Program,Student Admission Program,Prijímací program pre študentov
DocType: Employee Tax Exemption Sub Category,Tax Exemption Category,Kategória oslobodenia od dane
DocType: Payment Entry,Account Paid To,účet Venovaná
DocType: Subscription Settings,Grace Period,Doba odkladu
DocType: Item Alternative,Alternative Item Name,Alternatívny názov položky
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py,Parent Item {0} must not be a Stock Item,Parent Item {0} nesmie byť skladom
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Cannot create a Delivery Trip from Draft documents.,Z koncepčných dokumentov nie je možné vytvoriť doručovací výlet.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Website Listing,Výpis webových stránok
apps/erpnext/erpnext/config/buying.py,All Products or Services.,Všechny výrobky nebo služby.
DocType: Email Digest,Open Quotations,Otvorené citácie
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 presahovať o {5}
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Creating bank entries...,Vytvárajú sa bankové záznamy ...
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,Študentská karta
apps/erpnext/erpnext/config/projects.py,Types of activities for Time Logs,Typy činností pre Time Záznamy
DocType: Opening Invoice Creation Tool,Sales,Predaj
DocType: Stock Entry Detail,Basic Amount,Základná čiastka
DocType: Training Event,Exam,skúš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,Sťažnosť
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šetky oddelenia
DocType: Healthcare Service Unit,Vacant,prázdny
DocType: Patient,Alcohol Past Use,Použitie alkoholu v minulosti
DocType: Fertilizer Content,Fertilizer Content,Obsah hnojiva
apps/erpnext/erpnext/public/js/hub/pages/Seller.vue,No description,žiadny popis
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Cr,Cr
DocType: Tax Rule,Billing State,Fakturačný štát
DocType: Quality Goal,Monitoring Frequency,Frekvencia monitorovania
DocType: Share Transfer,Transfer,Převod
DocType: Quality Action,Quality Feedback,Spätná väzba kvality
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Work Order {0} must be cancelled before cancelling this Sales Order,Pred zrušením tejto objednávky musí byť pracovná objednávka {0} zrušená
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,Dátum splatnosti je povinný
apps/erpnext/erpnext/controllers/accounts_controller.py,Cannot set quantity less than received quantity,Nie je možné nastaviť množstvo menšie ako prijaté množstvo
apps/erpnext/erpnext/controllers/item_variant.py,Increment for Attribute {0} cannot be 0,Prírastok pre atribút {0} nemôže byť 0
DocType: Employee Benefit Claim,Benefit Type and Amount,Druh dávky a výška dávky
DocType: Delivery Stop,Visited,navštívil
apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py,Rooms Booked,Izby boli rezervované
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Ends On date cannot be before Next Contact Date.,Koniec dátumu nemôže byť pred dátumom nasledujúceho kontaktu.
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batch Entries,Dávky šarže
DocType: Journal Entry,Pay To / Recd From,Platit K / Recd Z
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Unpublish Item,Zverejniť položku
DocType: Naming Series,Setup Series,Řada Setup
DocType: Payment Reconciliation,To Invoice Date,Ak chcete dátumu vystavenia faktúry
DocType: Bank Account,Contact HTML,Kontakt HTML
DocType: Support Settings,Support Portal,Podporný portál
apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py,Registration fee can not be Zero,Registračný poplatok nemôže byť nula
DocType: Disease,Treatment Period,Liečebné obdobie
DocType: Travel Itinerary,Travel Itinerary,Cestovný itinerár
apps/erpnext/erpnext/education/api.py,Result already Submitted,Výsledok už bol odoslaný
apps/erpnext/erpnext/controllers/buying_controller.py,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Vyhradený sklad je povinný pre položku {0} v dodávaných surovinách
,Inactive Customers,Neaktívni zákazníci
DocType: Student Admission Program,Maximum Age,Maximálny vek
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Please wait 3 days before resending the reminder.,"Počkajte, prosím, 3 dni pred odoslaním pripomienky."
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","Odovzdajte bankový výpis, prepojte bankový účet alebo ho zladte"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,How Pricing Rule is applied?,Jak Ceny pravidlo platí?
DocType: Stock Entry,Delivery Note No,Číslo dodacieho listu
DocType: Cheque Print Template,Message to show,správa ukázať
apps/erpnext/erpnext/public/js/setup_wizard.js,Retail,Maloobchod
DocType: Student Attendance,Absent,Nepřítomný
DocType: Staffing Plan,Staffing Plan Detail,Podrobný plán personálneho plánu
DocType: Employee Promotion,Promotion Date,Dátum propagácie
apps/erpnext/erpnext/hr/doctype/leave_ledger_entry/leave_ledger_entry.py,Leave allocation %s is linked with leave application %s,Pridelenie dovolenky% s je spojené s aplikáciou dovolenky% s
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Product Bundle,Produktový balíček
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,Nepodarilo sa nájsť skóre od {0}. Musíte mať stály počet bodov od 0 do 100
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Invalid reference {1},Riadok {0}: Neplatné referencie {1}
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Please set valid GSTIN No. in Company Address for company {0},Zadajte platné číslo GSTIN v adrese spoločnosti pre spoločnosť {0}
apps/erpnext/erpnext/assets/doctype/location/location_tree.js,New Location,Nová poloha
DocType: Purchase Invoice,Purchase Taxes and Charges Template,Kúpte Dane a poplatky šablóny
DocType: Additional Salary,Date on which this component is applied,"Dátum, kedy sa táto zložka použije"
DocType: Subscription,Current Invoice Start Date,Aktuálny dátum začiatku faktúry
DocType: Designation Skill,Designation Skill,Označenie Zručnosť
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of goods,Dovoz tovaru
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ď debetnou alebo kreditnou čiastku je nutné pre {2}
DocType: GL Entry,Remarks,Poznámky
DocType: Support Settings,Track Service Level Agreement,Dohoda o úrovni sledovania služieb
DocType: Hotel Room Amenity,Hotel Room Amenity,Hotel Amenity
apps/erpnext/erpnext/erpnext_integrations/connectors/woocommerce_connection.py,woocommerce - {0},woocommerce - {0}
DocType: Budget,Action if Annual Budget Exceeded on MR,Opatrenie v prípade prekročenia ročného rozpočtu na MR
DocType: Course Enrollment,Course Enrollment,Zápis do kurzu
DocType: Payment Entry,Account Paid From,Účet sú platení z prostriedkov
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,Zo šablóny
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,Tlač a papiernictva
DocType: Stock Settings,Show Barcode Field,Show čiarového kódu Field
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Send Supplier Emails,Poslať Dodávateľ 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 už spracované pre obdobie medzi {0} a {1}, ponechajte dobu použiteľnosti nemôže byť medzi tomto časovom období."
DocType: Fiscal Year,Auto Created,Automatické vytvorenie
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,Submit this to create the Employee record,"Odošlite toto, aby ste vytvorili záznam zamestnanca"
DocType: Item Default,Item Default,Položka Predvolená
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Intra-State Supplies,Vnútroštátne dodávky
DocType: Chapter Member,Leave Reason,Nechajte dôvod
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py,IBAN is not valid,IBAN nie je platný
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Invoice {0} no longer exists,Faktúra {0} už neexistuje
DocType: Guardian Interest,Guardian Interest,Guardian Záujem
DocType: Volunteer,Availability,Dostupnosť
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,Aplikácia na opustenie je spojená s pridelením dovolenky {0}. Žiadosť o odchod nie je možné nastaviť ako dovolenku bez platenia
apps/erpnext/erpnext/config/retail.py,Setup default values for POS Invoices,Nastavte predvolené hodnoty POS faktúr
DocType: Employee Training,Training,výcvik
DocType: Project,Time to send,Čas odoslania
apps/erpnext/erpnext/public/js/hub/pages/Selling.vue,This page keeps track of your items in which buyers have showed some interest.,"Táto stránka sleduje vaše položky, o ktoré kupujúci prejavili určitý záujem."
DocType: Timesheet,Employee Detail,Detail zamestnanca
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.py,Set warehouse for Procedure {0} ,Nastaviť sklad pre 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/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á séria
DocType: Lab Prescription,Test Code,Testovací kód
apps/erpnext/erpnext/config/website.py,Settings for website homepage,Nastavenie titulnej stránky webu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} je pozastavená 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},RFQ nie sú povolené pre {0} kvôli postaveniu skóre {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žíva sa kupón {1}. Povolené množstvo je vyčerpané
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Chcete odoslať žiadosť o materiál
DocType: Job Offer,Awaiting Response,Čaká odpoveď
DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Above,Vyššie
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á čiastka {0}
apps/erpnext/erpnext/controllers/item_variant.py,Invalid attribute {0} {1},Neplatný atribút {0} {1}
DocType: Supplier,Mention if non-standard payable account,"Uveďte, či je neštandardný splatný účet"
DocType: Employee,Emergency Contact Name,Núdzové kontaktné meno
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 inú hodnotiacu skupinu ako &quot;Všetky hodnotiace skupiny&quot;
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Row {0}: Cost center is required for an item {1},Riadok {0}: Pre položku {1} sa vyžaduje nákladové centrum.
DocType: Training Event Employee,Optional,voliteľný
DocType: Salary Slip,Earning & Deduction,Príjem a odpočty
DocType: Agriculture Analysis Criteria,Water Analysis,Analýza vody
DocType: Sales Order,Skip Delivery Note,Preskočiť dodací list
DocType: Price List,Price Not UOM Dependent,Cena nie je závislá od UOM
apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} vytvorené varianty.
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Predvolená dohoda o úrovni služieb už existuje.
DocType: Quality Objective,Quality Objective,Cieľ 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í Rate není povoleno
DocType: Holiday List,Weekly Off,Týdenní Off
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js,Reload Linked Analysis,Znova načítať prepojenú analýzu
DocType: Fiscal Year,"For e.g. 2012, 2012-13","Pro např 2012, 2012-13"
DocType: Purchase Order,Purchase Order Pricing Rule,Pravidlo stanovenia 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 predajnej faktúre
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 5,Bod 5
DocType: Serial No,Creation Time,Čas vytvorenia
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Total Revenue,Celkový příjem
DocType: Patient,Other Risk Factors,Ďalšie rizikové faktory
DocType: Sales Invoice,Product Bundle Help,Product Bundle Help
,Monthly Attendance Sheet,Měsíční Účast Sheet
DocType: Homepage Section Card,Subtitle,podtitul
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 vyradené aktíva
DocType: Employee Checkin,OUT,VON
apps/erpnext/erpnext/controllers/stock_controller.py,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Nákladové stredisko je povinné pre položku {2}
DocType: Vehicle,Policy No,nie politika
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get Items from Product Bundle,Získať predmety z Bundle Product
DocType: Asset,Straight Line,Priamka
DocType: Project User,Project User,projekt Užívateľ
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split,Rozdeliť
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split,Rozdeliť
DocType: Tally Migration,Master Data,Hlavné dáta
DocType: Employee Transfer,Re-allocate Leaves,Prerozdeľte listy
DocType: GL Entry,Is Advance,Je Zálohová
DocType: Job Offer,Applicant Email Address,E-mailová adresa žiadateľa
apps/erpnext/erpnext/config/hr.py,Employee Lifecycle,Životný cyklus zamestnancov
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,Predvolená nákupná merná jednotka
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication Date,Dátum poslednej komunikácie
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication Date,Dátum poslednej komunikácie
DocType: Clinical Procedure Item,Clinical Procedure Item,Položka klinickej procedúry
DocType: Coupon Code,unique e.g. SAVE20  To be used to get discount,"jedinečný, napr. SAVE20 Používa sa na získanie zľavy"
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 rovnaká ako dodacia adresa
DocType: Bank Reconciliation,Payment Entries,platobné Príspevky
DocType: Location,Latitude,zemepisná šírka
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}","Požadovaný sklad v riadku Nie {0}, nastavte prosím predvolený sklad pre položku {1} pre spoločnosť {2}"
DocType: Work Order,Check if material transfer entry is not required,"Skontrolujte, či sa nepožaduje zadávanie materiálu"
DocType: Work Order,Check if material transfer entry is not required,"Skontrolujte, či sa nepožaduje zadávanie materiálu"
DocType: Program Enrollment Tool,Get Students From,Získať študentov z
apps/erpnext/erpnext/config/help.py,Publish Items on Website,Publikovať položky na webových stránkach
apps/erpnext/erpnext/utilities/activation.py,Group your students in batches,Skupina vaši študenti v dávkach
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be greater than unadjusted amount,Pridelená suma nemôže byť vyššia ako neupravená suma
DocType: Authorization Rule,Authorization Rule,Autorizační pravidlo
apps/erpnext/erpnext/projects/doctype/project/project.py,Status must be Cancelled or Completed,Stav musí byť zrušený alebo dokončený
DocType: Sales Invoice,Terms and Conditions Details,Podmínky podrobnosti
DocType: Sales Invoice,Sales Taxes and Charges Template,Predaj Dane a poplatky šablóny
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Total (Credit),Celkový (Credit)
DocType: Repayment Schedule,Payment Date,Dátum platby
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch Qty,Nová dávková dávka
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žstvo položky nemôže byť 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.,"Funkciu váženého skóre sa nepodarilo vyriešiť. Skontrolujte, či je vzorec platný."
DocType: Invoice Discounting,Loan Period (Days),Úverové obdobie (dni)
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Purchase Order Items not received on time,Položky objednávok neboli prijaté 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í na první místo v seznamu výrobků."
DocType: Shipping Rule,Specify conditions to calculate shipping amount,Stanovte podmienky na výpočet výšky prepravných nákladov
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,"Transakcie, ktoré už boli z výkazu prevzaté"
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Opening Value,otvorenie 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žstvo
DocType: Lab Test Template,Lab Test Template,Šablóna testu laboratória
apps/erpnext/erpnext/accounts/doctype/accounting_period/accounting_period.py,Accounting Period overlaps with {0},Účtovné obdobie sa prekrýva s {0}
apps/erpnext/erpnext/setup/doctype/company/company.py,Sales Account,Predajný účet
DocType: Purchase Invoice Item,Total Weight,Celková váha
DocType: Pick List Item,Pick List Item,Vyberte položku zoznamu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Commission on Sales,Provizia z prodeja
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}","Riadok # {0}: Asset {1} nemôže byť predložený, je už {2}"
DocType: Tax Rule,Billing Country,Fakturačná krajina
DocType: Purchase Order Item,Expected Delivery Date,Očekávané datum dodání
DocType: Restaurant Order Entry,Restaurant Order Entry,Vstup do objednávky reštaurácie
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}. Rozdiel je v tom {2}.
DocType: Clinical Procedure Item,Invoice Separately as Consumables,Faktúra samostatne ako spotrebný materiál
DocType: Budget,Control Action,Kontrolná akcia
DocType: Asset Maintenance Task,Assign To Name,Priradiť 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},Otvorená Položka {0}
DocType: Asset Finance Book,Written Down Value,Písomná hodnota
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,Fakturovaná čiastka
DocType: Cash Flow Mapping,Select Maximum Of 1,Vyberte možnosť Maximálne 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žstvo uvedené pre položku {0}. Množstvo by malo byť väčšie než 0.
DocType: Company,Default Employee Advance Account,Predvolený účet predvoleného zamestnanca
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Search Item (Ctrl + i),Vyhľadávacia položka (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 existujúcimi transakciami nemôže byť zmazaný
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Why do think this Item should be removed?,"Prečo si myslíte, že by sa táto položka mala odstrániť?"
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ýdavky na právne služby
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Vyberte prosím množstvo na riadku
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Pracovný príkaz {0}: karta úlohy nebola pre operáciu nájdená {1}
DocType: Purchase Invoice,Posting Time,Čas zadání
DocType: Timesheet,% Amount Billed,% Fakturovanej čiastky
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,Otvorené Oznámenie
DocType: Payment Entry,Difference Amount (Company Currency),Rozdiel Suma (Company mena)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Expenses,Priame náklady
DocType: Pricing Rule Detail,Child Docname,Názov dieťaťa
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žieb.
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án
DocType: Patient Encounter,Encounter Date,Dátum stretnutia
DocType: Work Order,Update Consumed Material Cost In Project,Aktualizácia spotrebovaných materiálových nákladov v projekte
apps/erpnext/erpnext/controllers/accounts_controller.py,Account: {0} with currency: {1} can not be selected,Účet: {0} s menou: {1} nemožno vybrať
DocType: Bank Statement Transaction Settings Item,Bank Data,Bankové údaje
DocType: Purchase Receipt Item,Sample Quantity,Množstvo vzoriek
DocType: Bank Guarantee,Name of Beneficiary,Názov príjemcu
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 prostredníctvom Plánovača na základe najnovšej sadzby ocenenia / cien / posledného nákupu surovín.
DocType: Supplier,SUP-.YYYY.-,SUP-.YYYY.-
,BOM Items and Scraps,Položky a útržky kusovníka
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!,Úspešne vypúšťa všetky transakcie súvisiace s týmto spoločnosti!
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,As on Date,Rovnako ako u Date
DocType: Additional Salary,HR,HR
DocType: Course Enrollment,Enrollment Date,zápis Dátum
DocType: Healthcare Settings,Out Patient SMS Alerts,SMS upozorňovanie na pacientov
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Probation,Skúšobná lehota
DocType: Company,Sales Settings,Nastavenia predaja
DocType: Program Enrollment Tool,New Academic Year,Nový akademický rok
DocType: Supplier Scorecard,Load All Criteria,Načítať všetky kritériá
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,Automaticky vložiť cenníkovú cenu ak neexistuje
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ý platobný záznam by mal byť prepojený s veriteľskou bankovou transakciou
DocType: POS Closing Voucher,Amount in Custody,Suma vo väzbe
apps/erpnext/erpnext/config/help.py,Navigating,Navigácia
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 týkajúce sa hesiel nemôžu obsahovať medzery ani súčasné spojovníky. Formát bude automaticky reštrukturalizovaný
DocType: Quotation Item,Planning,Plánování
DocType: Salary Component,Depends on Payment Days,Závisí od platobných dní
DocType: Contract,Signee,Signee
DocType: Share Balance,Issued,Vydané
DocType: Loan,Repayment Start Date,Dátum začiatku splácania
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Student Activity,Aktivita študentov
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Supplier Id,Dodavatel Id
DocType: Payment Request,Payment Gateway Details,Platobná brána Podrobnosti
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity should be greater than 0,Množstvo by mala byť väčšia ako 0
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Price or product discount slabs are required,Vyžadujú sa dosky na zníženie ceny alebo 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,Podriadené uzly môžu byť vytvorené len na základe typu uzly &quot;skupina&quot;
DocType: Attendance Request,Half Day Date,Half Day Date
DocType: Academic Year,Academic Year Name,Akademický rok Meno
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} not allowed to transact with {1}. Please change the Company.,{0} nesmie transakcie s {1}. Zmeňte spoločnosť.
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álna suma oslobodenia nemôže byť vyššia ako maximálna výška oslobodenia {0} kategórie oslobodenia od dane {1}
DocType: Sales Partner,Contact Desc,Opis kontaktu
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 nastaviť predvolený úč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,Meno študenta
DocType: Hub Tracked Item,Item Manager,Manažér položiek
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,apríl
apps/erpnext/erpnext/config/crm.py,Helps you manage appointments with your leads,Pomáha vám spravovať schôdzky s vašimi potenciálnymi zákazníkmi
DocType: Plant Analysis,Collection Datetime,Dátum zberu
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,Uzavreté dokumenty
DocType: Healthcare Settings,Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Spravujte faktúru odstupňovania a automaticky zrušte za stretnutie pacienta
apps/erpnext/erpnext/config/website.py,Add cards or custom sections on homepage,Pridajte karty alebo vlastné sekcie na domovskú stránku
DocType: Patient Appointment,Referring Practitioner,Odporúčajúci lekár
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html,Training Event:,Školenie:
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation,Skratka názvu spoločnosti
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,Deň (dni) po dátume fakturácie
apps/erpnext/erpnext/setup/doctype/company/company.js,Date of Commencement should be greater than Date of Incorporation,Dátum začiatku by mal byť väčší ako dátum založenia
DocType: Contract,Signed On,Zapnuté
DocType: Bank Account,Party Type,Typ Party
DocType: Discounted Invoice,Discounted Invoice,Zľavnená faktúra
DocType: Payment Schedule,Payment Schedule,Rozvrh platieb
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,No Employee found for the given employee field value. '{}': {},Pre danú hodnotu poľa zamestnanca sa nenašiel žiaden zamestnanec. &#39;{}&#39;: {}
DocType: Item Attribute Value,Abbreviation,Zkratka
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry already exists,Platba Entry už existuje
DocType: Course Content,Quiz,kvíz
DocType: Subscription,Trial Period End Date,Dátum ukončenia skúšobného obdobia
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čnite zadávať údaje odtiaľto:
DocType: Serial No,Asset Status,Stav majetku
DocType: Sales Invoice,Over Dimensional Cargo (ODC),Rozmerový náklad (ODC)
DocType: Restaurant Order Entry,Restaurant Table,Reštaurácia Tabuľka
DocType: Hotel Room,Hotel Manager,Hotelový manažér
apps/erpnext/erpnext/utilities/activation.py,Create Student Batch,Vytvorenie šarže pre študentov
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Set Tax Rule for shopping cart,Sada Daňové Pravidlo pre nákupného košíka
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.py,There are no vacancies under staffing plan {0},Podľa personálneho plánu nie sú žiadne voľné miesta {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ý riadok {0}: Nasledujúci dátum odpisovania nemôže byť pred dátumom k dispozícii na použitie
,Sales Funnel,Predajný lievik
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Skratka je povinná
DocType: Project,Task Progress,pokrok úloha
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Košík
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.py,Bank account {0} already exists and could not be created again,Bankový účet {0} už existuje a nedá sa znova vytvoriť
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Missed,Zmeškaný hovor
DocType: Certified Consultant,GitHub ID,Identifikátor GitHub
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.,Ponuka z Obchodnej Iniciatívy alebo pre Zákazníka
DocType: Stock Settings,Role Allowed to edit frozen stock,"Rola, ktorá má oprávnenie upravovať 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,nahromadené za mesiac
DocType: Attendance Request,On Duty,V službe
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žno nie je vytvorený záznam Zmeny meny pre {1} až {2}.
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,Staffing Plan {0} already exist for designation {1},Personálny plán {0} už existuje pre označenie {1}
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Template is mandatory.,Daňová šablóna je povinné.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Goods are already received against the outward entry {0},Tovar je už prijatý proti vonkajšiemu vstupu {0}
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Last Issue,Posledné vydanie
apps/erpnext/erpnext/regional/doctype/import_supplier_invoice/import_supplier_invoice.py,XML Files Processed,Spracované súbory XML
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,maskovať
DocType: POS Closing Voucher,Period Start Date,Dátum začiatku obdobia
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Cenníková cena (mena firmy)
DocType: Products Settings,Products Settings,nastavenie Produkty
,Item Price Stock,Položka Cena Sklad
apps/erpnext/erpnext/config/retail.py,To make Customer based incentive schemes.,Vytváranie motivačných schém založených na zákazníkoch.
DocType: Lab Prescription,Test Created,Test bol vytvorený
DocType: Healthcare Settings,Custom Signature in Print,Vlastný podpis v tlači
DocType: Account,Temporary,Dočasný
DocType: Material Request Plan Item,Customer Provided,Poskytnuté zákazníkom
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Customer LPO No.,Číslo zákazníka LPO
DocType: Amazon MWS Settings,Market Place Account Group,Skupina účtov na trhu
DocType: Program,Courses,predmety
DocType: Monthly Distribution Percentage,Percentage Allocation,Procento přidělení
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Secretary,Sekretárka
apps/erpnext/erpnext/regional/india/utils.py,House rented dates required for exemption calculation,Požadované dátumy pre výpočet výnimky
DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Pokiaľ zakázať, &quot;v slovách&quot; poli nebude viditeľný v akejkoľvek transakcie"
DocType: Quality Review Table,Quality Review Table,Tabuľka na 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?,Táto akcia zastaví budúcu fakturáciu. Naozaj chcete zrušiť tento odber?
DocType: Serial No,Distinct unit of an Item,Samostatnou jednotku z položky
DocType: Supplier Scorecard Criteria,Criteria Name,Názov kritéria
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.js,Please set Company,Nastavte spoločnosť
DocType: Procedure Prescription,Procedure Created,Postup bol vytvorený
DocType: Pricing Rule,Buying,Nákupy
apps/erpnext/erpnext/config/agriculture.py,Diseases & Fertilizers,Choroby a hnojivá
DocType: HR Settings,Employee Records to be created by,Zamestnanecké záznamy na vytvorenie kým
DocType: Inpatient Record,AB Negative,AB Negatívny
DocType: POS Profile,Apply Discount On,Použiť Zľava na
DocType: Member,Membership Type,Typ členstva
,Reqd By Date,Pr p Podľa dátumu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Creditors,Veritelia
DocType: Assessment Plan,Assessment Name,Názov Assessment
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No is mandatory,Riadok # {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,Ponuka práce
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Abbreviation,inštitút Skratka
,Item-wise Price List Rate,Item-moudrý Ceník Rate
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Supplier Quotation,Dodávateľská ponuka
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,Rozdiel medzi časom a časom musí byť násobkom stretnutia
apps/erpnext/erpnext/config/support.py,Issue Priority.,Priorita vydania.
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žstvo ({0}) nemôže byť zlomkom v riadku {1}
apps/erpnext/erpnext/utilities/transaction_base.py,Quantity ({0}) cannot be a fraction in row {1},Množstvo ({0}) nemôže byť zlomkom v riadku {1}
DocType: Contract,Unsigned,nepodpísaný
DocType: Selling Settings,Each Transaction,Každá Transakcia
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 pred ukončením zmeny, keď sa check-out považuje za skorý (v minútach)."
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 prístelky
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 pripojení súboru zip k dokumentu kliknite na tlačidlo Importovať faktúry. Všetky chyby týkajúce sa spracovania sa zobrazia v protokole chýb.
DocType: Item,Opening Stock,otvorenie Sklad
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Customer is required,Je nutná zákazník
DocType: Lab Test,Result Date,Dátum výsledku
DocType: Purchase Order,To Receive,Obdržať
DocType: Leave Period,Holiday List for Optional Leave,Dovolenkový zoznam pre voliteľnú dovolenku
DocType: Item Tax Template,Tax Rates,Daňové sadzby
DocType: Asset,Asset Owner,Majiteľ majetku
DocType: Item,Website Content,Obsah webových stránok
DocType: Bank Account,Integration ID,Integračné ID
DocType: Purchase Invoice,Reason For Putting On Hold,Dôvod pre pozastavenie
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 () akceptoval 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,Účasť na zamestnancov {0} je už označený pre tento deň
DocType: Work Order Operation,"in Minutes
Updated via 'Time Log'","v minútach 
 aktualizované pomocou ""Time Log"""
DocType: Customer,From Lead,Od Obchodnej iniciatívy
DocType: Amazon MWS Settings,Synch Orders,Synch objednávky
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 fiškálny rok ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,"POS Profile požadované, 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.",Vernostné body sa vypočítajú z vynaloženej hotovosti (prostredníctvom faktúry predaja) na základe zmieneného faktora zberu.
DocType: Program Enrollment Tool,Enroll Students,zapísať študenti
DocType: Pricing Rule,Coupon Code Based,Na základe kódu kupónu
DocType: Company,HRA Settings,Nastavenia HRA
DocType: Homepage,Hero Section,Sekcia hrdinov
DocType: Employee Transfer,Transfer Date,Dátum prenosu
DocType: Lab Test,Approved Date,Schválený dátum
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Selling,Štandardný predaj
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.","Konfigurácia polí položiek ako UOM, skupina položiek, popis a počet hodín."
DocType: Certification Application,Certification Status,Stav certifikácie
apps/erpnext/erpnext/public/js/hub/marketplace.js,Marketplace,Marketplace
DocType: Travel Itinerary,Travel Advance Required,Cestovanie Advance Povinné
DocType: Subscriber,Subscriber Name,Názov účastníka
DocType: Serial No,Out of Warranty,Out of záruky
DocType: Bank Statement Transaction Settings Item,Mapped Data Type,Mapovaný typ údajov
DocType: BOM Update Tool,Replace,Vyměnit
apps/erpnext/erpnext/templates/includes/product_list.js,No products found.,Nenašli sa žiadne produkty.
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,Publish More Items,Zverejniť viac položiek
apps/erpnext/erpnext/support/doctype/issue/issue.py,This Service Level Agreement is specific to Customer {0},Táto dohoda o úrovni služieb je špecifická pre zákazníka {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Invoice {1},{0} proti Predajnej Faktúre {1}
DocType: Antibiotic,Laboratory User,Laboratórny používateľ
DocType: Request for Quotation Item,Project Name,Názov projektu
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Customer Address,Nastavte adresu zákazníka
DocType: Customer,Mention if non-standard receivable account,Zmienka v prípade neštandardnej pohľadá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,Pridajte zvyšné výhody {0} k ľubovoľnému existujúcemu komponentu
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},Potvrdenie o konečnej platbe POS už existuje pre {0} od dátumu {1} do {2}
DocType: Bank Statement Transaction Entry,Matching Invoices,Zodpovedajúce faktúry
DocType: Work Order,Required Items,povinné predmety
DocType: Stock Ledger Entry,Stock Value Difference,Rozdiel v hodnote zásob
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 Riadok {0}: {1} {2} neexistuje v tabuľke nad {1}
apps/erpnext/erpnext/config/help.py,Human Resource,Ľudské Zdroje
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Platba Odsouhlasení Platba
DocType: Disease,Treatment Task,Liečebná úloha
DocType: Payment Order Reference,Bank Account Details,Podrobnosti o bankovom účte
DocType: Purchase Order Item,Blanket Order,Objednávka prikrývky
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.py,Repayment Amount must be greater than ,Suma splácania musí byť vyššia ako
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,BOM No
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é zariadenia
DocType: Asset,Maintenance Required,Požadovaná ú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,"Listy 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,Identifikácia rozhodovacích orgánov
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,Platba objednaná
DocType: Asset Maintenance Team,Maintenance Team Name,Názov tímu údržby
DocType: Driving License Category,Driver licence class,Trieda vodičského preukazu
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,Fiškálny 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,Druh platobné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},Miera predaja pre položku {0} je nižšia ako {1}. Miera predaja by mala byť najmenej {2}
apps/erpnext/erpnext/controllers/selling_controller.py,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Miera predaja pre položku {0} je nižšia ako {1}. Miera predaja by mala byť najmenej {2}
DocType: Designation Skill,Skill,zručnosť
DocType: Subscription,Taxes,Daně
DocType: Purchase Invoice Item,Weight Per Unit,Hmotnosť na jednotku
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Paid and Not Delivered,Platená a nie je doručenie
DocType: QuickBooks Migrator,Default Cost Center,Predvolené nákladové stredisko
apps/erpnext/erpnext/www/all-products/index.html,Toggle Filters,Prepnúť filtre
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in company {1},Set {0} v spoločnosti {1}
apps/erpnext/erpnext/config/stock.py,Stock Transactions,Transackia na zásobách
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é transakcie
DocType: Depreciation Schedule,Accumulated Depreciation Amount,oprávky Suma
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Private Equity,Private Equity
DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Premenná ukazovateľa tabuľky dodávateľov
DocType: Shift Type,Working Hours Threshold for Half Day,Prah pracovných hodín na pol dňa
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please create purchase receipt or purchase invoice for the item {0},Vytvorte doklad o kúpe alebo nákupnú faktúru pre položku {0}
DocType: Job Card,Material Transferred,Prevedený materiál
DocType: Employee Advance,Due Advance Amount,Splatná výška zálohy
DocType: Maintenance Visit,Customer Feedback,Zpätná väzba od zákazníkov
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 byť väčšia ako maximum bodov
DocType: Support Search Source,Source Type,typ zdroja
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 rýchlosť položky podsúboru na základe kusovníka
DocType: Inpatient Occupancy,Invoiced,fakturovaná
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,WooCommerce Products,Produkty spoločnosti WooCommerce
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in formula or condition: {0},syntaktická chyba vo vzorci alebo stave: {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,Deň (dni) po skončení fakturačného mesiaca
DocType: Assessment Group,Parent Assessment Group,Materská skupina Assessment
DocType: Employee Checkin,Shift Actual End,Presunúť skutočný koniec
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íka č.&quot; pole nesmie byť prázdne ani jeho hodnota nižšia ako 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},Zdravotnícky lekár nie je k dispozícii na {0}
DocType: Stock Entry Detail,Additional Cost,Dodatoč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.,Predvolené daňové šablóny pre predaj a nákup sú vytvorené.
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py,Assessment Result record {0} already exists.,Hodnotenie výsledkov {0} už 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.","Príklad: ABCD. #####. Ak je nastavená séria a v transakciách sa neuvádza dávka, potom sa na základe tejto série vytvorí automatické číslo dávky. Ak chcete vždy výslovne uviesť číslo dávky pre túto položku, ponechajte prázdne. Poznámka: Toto nastavenie bude mať prednosť pred prefixom série Naming v nastaveniach zásob."
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Outward taxable supplies(zero rated),Dodávky podliehajúce zdaneniu (hodnotené nulovou hodnotou)
DocType: BOM,Materials Required (Exploded),Potřebný materiál (Rozložený)
apps/erpnext/erpnext/buying/report/purchase_analytics/purchase_analytics.js,based_on,založené na
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Submit Review,Odoslať recenziu
DocType: Contract,Party User,Používateľ strany
apps/erpnext/erpnext/controllers/buying_controller.py,Assets not created for <b>{0}</b>. You will have to create asset manually.,Diela neboli vytvorené pre <b>{0}</b> . Prvok budete musieť vytvoriť ručne.
apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',"Filtrovanie spoločnosti nastavte prázdne, ak je položka Skupina pod skupinou &quot;Spoločnosť&quot;"
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Vysielanie dátum nemôže byť budúci dátum
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Riadok # {0}: Výrobné číslo {1} nezodpovedá {2} {3}
DocType: Stock Entry,Target Warehouse Address,Adresa cieľového skladu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Bežná priepustka
DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"Čas pred začiatkom zmeny, počas ktorého sa za účasť považuje registrácia zamestnancov."
DocType: Agriculture Task,End Day,Koniec dňa
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,"Akcia, ak nebola predložená kontrola kvality"
,Delivery Note Trends,Dodací list Trendy
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,This Week's Summary,Tento týždeň Zhrnutie
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,In Stock Qty,Na sklade Množstvo
,Daily Work Summary Replies,Denné zhrnutie pracovných odpovedí
DocType: Delivery Trip,Calculate Estimated Arrival Times,Vypočítať odhadované časy príchodu
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ískať kurzy
DocType: Tally Migration,ERPNext Company,ERPĎalšia spoločnosť
DocType: Shopify Settings,Webhooks,Webhooks
DocType: Bank Account,Party,Strana
DocType: Healthcare Settings,Patient Name,Názov pacienta
DocType: Variant Field,Variant Field,Variantné pole
DocType: Asset Movement Item,Target Location,Miesto zacielenia
DocType: Sales Order,Delivery Date,Dodávka Datum
DocType: Opportunity,Opportunity Date,Příležitost Datum
DocType: Employee,Health Insurance Provider,Poskytovateľ zdravotného poistenia
DocType: Service Level,Holiday List (ignored during SLA calculation),Zoznam sviatkov (ignorovaný počas výpočtu SLA)
DocType: Products Settings,Show Availability Status,Zobraziť stav dostupnosti
DocType: Purchase Receipt,Return Against Purchase Receipt,Návrat Proti doklad o kúpe
DocType: Water Analysis,Person Responsible,Zodpovedná osoba
DocType: Request for Quotation Item,Request for Quotation Item,Žiadosť o cenovú ponuku výtlačku
DocType: Purchase Order,To Bill,K fakturácii
DocType: Material Request,% Ordered,% Objednané
DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",V prípade kurzov študentskej skupiny bude kurz potvrdený pre každého študenta z prihlásených kurzov pri zaradení do programu.
DocType: Employee Grade,Employee Grade,Zamestnanec stupeň
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Úkolová práce
DocType: GSTR 3B Report,June,jún
DocType: Share Balance,From No,Od č
DocType: Shift Type,Early Exit Grace Period,Predčasné ukončenie odkladu
DocType: Task,Actual Time (in Hours),Skutočná doba (v hodinách)
DocType: Employee,History In Company,Historie ve Společnosti
DocType: Customer,Customer Primary Address,Primárna adresa zákazníka
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Connected,Hovor bol spojený
apps/erpnext/erpnext/config/crm.py,Newsletters,Newslettery
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Reference No.,Referenčné číslo
DocType: Drug Prescription,Description/Strength,Opis / Sila
apps/erpnext/erpnext/config/hr.py,Energy Point Leaderboard,Leaderboard Energy Point
DocType: Bank Statement Transaction Entry,Create New Payment/Journal Entry,Vytvorte novú položku Platba / denník
DocType: Certification Application,Certification Application,Certifikačná aplikácia
DocType: Leave Type,Is Optional Leave,Je voliteľná dovolenka
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Declare Lost,Vyhlásiť za stratené
DocType: Share Balance,Is Company,Je spoločnosť
DocType: Pricing Rule,Same Item,Rovnaká položka
DocType: Stock Ledger Entry,Stock Ledger Entry,Zápis do súpisu zásob
DocType: Quality Action Resolution,Quality Action Resolution,Kvalitné akčné rozlíšenie
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Half day Leave on {1},{0} na poldňovú dovolenku 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,"Ak je spôsob dopravy cestná, vyžaduje sa ID prepravcu GST alebo číslo vozidla"
DocType: Accounts Settings,Accounts Settings,Nastavenie účtu
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Approve,schvaľovať
DocType: Loyalty Program,Customer Territory,Oblasť zákazníka
DocType: Email Digest,Sales Orders to Deliver,Predajné príkazy na dodanie
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 zahrnuté do názvu účtu ako predpona"
DocType: Maintenance Team Member,Team Member,Člen tímu
DocType: GSTR 3B Report,Invoices with no Place Of Supply,Faktúry bez miesta dodania
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,No Result to submit,Žiadny výsledok na odoslanie
DocType: Customer,Sales Partner and Commission,Partner predaja a provízia
DocType: Loan,Rate of Interest (%) / Year,Úroková sadzba (%) / rok
,Project Quantity,projekt Množstvo
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'","Total {0} u všetkých položiek je nulová, môže byť by ste mali zmeniť, Distribuovať poplatkov na základe &#39;"
apps/erpnext/erpnext/hr/utils.py,To date can not be less than from date,K dnešnému dňu nemôže byť menej ako od dátumu
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} jednotiek {1} potrebná {2} pre dokončenie tejto transakcie.
DocType: Loan Type,Rate of Interest (%) Yearly,Úroková sadzba (%) Ročné
apps/erpnext/erpnext/config/quality_management.py,Quality Goal.,Cieľ kvality.
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},Umiestnenie zdroja sa vyžaduje pre majetok {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Black,Čierna
DocType: BOM Explosion Item,BOM Explosion Item,BOM Explosion Item
DocType: Shareholder,Contact List,Zoznam kontaktov
DocType: Account,Auditor,Auditor
DocType: Project,Frequency To Collect Progress,Frekvencia na zhromažďovanie pokroku
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items produced,{0} predmety vyrobené
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} is not added in the table,{0} sa do tabuľky nepridáva
DocType: Payment Entry,Party Bank Account,Bankový účet strany
DocType: Cheque Print Template,Distance from top edge,Vzdialenosť od horného okraja
DocType: POS Closing Voucher Invoices,Quantity of Items,Množstvo položiek
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py,Price List {0} is disabled or does not exist,Cenníková cena {0} je zakázaná alebo neexistuje
DocType: Purchase Invoice,Return,Spiatočná
DocType: Account,Disable,Vypnúť
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Mode of payment is required to make a payment,Spôsob platby je povinný vykonať 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 celú stránku pre ďalšie možnosti, ako sú aktíva, sériové nosiče, dávky atď."
DocType: Leave Type,Maximum Continuous Days Applicable,Maximálne nepretržité dni
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 4,Rozsah starnutia 4
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Batch {2},{0} - {1} nie je zapísaná v dávke {2}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,"Asset {0} cannot be scrapped, as it is already {1}","Aktíva {0} nemôže byť vyhodený, ako je to už {1}"
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Cheques Required,Potrebné 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,Označiť ako neprítomný
DocType: Job Applicant Source,Job Applicant Source,Zdroj žiadateľa o zamestnanie
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,IGST Amount,Suma IGST
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup company,Nepodarilo sa nastaviť spoločnosť
DocType: Asset Repair,Asset Repair,Oprava majetku
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},Riadok {0}: Mena BOM # {1} by sa mala rovnať vybranej mene {2}
DocType: Journal Entry Account,Exchange Rate,Výmenný kurz
DocType: Patient,Additional information regarding the patient,Ďalšie informácie týkajúce sa 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,poplatok 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,Povoliť ukončovacie obdobie odkladu
DocType: Cheque Print Template,Regular,pravidelný
DocType: Fertilizer,Density (if liquid),Hustota (ak je kvapalná)
apps/erpnext/erpnext/education/doctype/course/course.py,Total Weightage of all Assessment Criteria must be 100%,Celkový weightage všetkých hodnotiacich kritérií musí byť 100%
DocType: Purchase Order Item,Last Purchase Rate,Posledná nákupná cena
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",Majetok {0} nie je možné prijať na mieste a \ \ dať zamestnancovi jediným pohybom
DocType: GSTR 3B Report,August,august
DocType: Account,Asset,Majetek
DocType: Quality Goal,Revised On,Revidované dňa
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock cannot exist for Item {0} since has variants,"Zásoba nemôže byť na položke {0}, protože má varianty"
DocType: Healthcare Practitioner,Mobile,Mobilné
DocType: Issue,Reset Service Level Agreement,Obnoviť dohodu o úrovni služieb
,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,starostlivosť
DocType: Employee Tax Exemption Proof Submission Detail,Employee Tax Exemption Proof Submission Detail,Podrobnosti o predložení dokladu o oslobodení od dane zamestnanca
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 mať dávku
DocType: Delivery Note,% of materials delivered against this Delivery Note,% materiálov dodaných proti tomuto dodaciemu listu
DocType: Asset Maintenance Log,Has Certificate,Má certifikát
DocType: Appointment,Customer Details,Podrobnosti zákazníkov
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.js,Print IRS 1099 Forms,Tlačte formuláre IRS 1099
DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,"Skontrolujte, či si aktívum vyžaduje preventívnu údržbu alebo kalibráciu"
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation cannot have more than 5 characters,Skratka firmy nemôže mať viac ako 5 znakov
DocType: Employee,Reports to,Zprávy
,Unpaid Expense Claim,Neplatené Náklady nárok
DocType: Payment Entry,Paid Amount,Uhradená čiastka
DocType: Assessment Plan,Supervisor,Nadriadený
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Retention Stock Entry,Retenčný záznam
,Available Stock for Packing Items,K dispozici skladem pro balení položek
DocType: Item Variant,Item Variant,Variant Položky
DocType: Employee Skill Map,Trainings,tréningy
,Work Order Stock Report,Správa o stave pracovnej objednávky
DocType: Purchase Receipt,Auto Repeat Detail,Podrobnosti o automatickom opakovaní
DocType: Assessment Result Tool,Assessment Result Tool,Assessment Tool Výsledok
apps/erpnext/erpnext/education/doctype/instructor/instructor.js,As Supervisor,Ako školiteľ
DocType: Leave Policy Detail,Leave Policy Detail,Zanechať podrobnosti o pravidlách
DocType: BOM Scrap Item,BOM Scrap Item,BOM Scrap Item
apps/erpnext/erpnext/accounts/page/pos/pos.js,Submitted orders can not be deleted,Predložené objednávky nemožno zmazať
DocType: Leave Control Panel,Department (optional),Oddelenie (voliteľné)
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.
				","Ak {0} {1} stojí za položku <b>{2}</b> , na položku sa použije schéma <b>{3}</b> ."
DocType: Customer Feedback,Quality Management,Riadenie kvality
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} has been disabled,Item {0} bol zakázaný
DocType: Project,Total Billable Amount (via Timesheets),Celková fakturovaná suma (prostredníctvom dochádzky)
DocType: Agriculture Task,Previous Business Day,Predchádzajúci pracovný deň
DocType: Loan,Repay Fixed Amount per Period,Splácať paušálna čiastka za obdobie
DocType: Employee,Health Insurance No,Zdravotné poistenie č
DocType: Employee Tax Exemption Proof Submission,Tax Exemption Proofs,Dôkazy o oslobodení od dane
apps/erpnext/erpnext/buying/utils.py,Please enter quantity for Item {0},Zadajte prosím množstvo pre Položku {0}
DocType: Quality Procedure,Processes,Procesy
DocType: Shift Type,First Check-in and Last Check-out,Prvé prihlásenie a posledné prihlásenie
apps/erpnext/erpnext/regional/report/hsn_wise_summary_of_outward_supplies/hsn_wise_summary_of_outward_supplies.py,Total Taxable Amount,Celková zdaniteľná suma
DocType: Employee External Work History,Employee External Work History,Externá pracovná história zamestnanca
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Job card {0} created,Vytvorila sa pracovná 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,Zostatkové množstvo
DocType: Pricing Rule,Conditions will be applied on all the selected items combined. ,Na všetky vybrané položky sa použijú podmienky spolu.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Goals cannot be empty,Bránky nemôže byť prázdny
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js,Enrolling students,Zapisovanie študentov
DocType: Item Group,Parent Item Group,Parent Item Group
DocType: Appointment Type,Appointment Type,Typ schôdze
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,{0} for {1},{0} pre {1}
DocType: Healthcare Settings,Valid number of days,Platný počet dní
apps/erpnext/erpnext/setup/doctype/company/company.js,Cost Centers,Nákladové strediská
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Restart Subscription,Reštartujte odber
DocType: Linked Plant Analysis,Linked Plant Analysis,Analýza prepojených rastlín
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Transporter ID,ID prepravcu
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,Dátum ukončenia 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,Povoliť sadzbu nulového oceňovania
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Povoliť sadzbu nulového oceňovania
DocType: Bank Guarantee,Receiving,Príjem
DocType: Training Event Employee,Invited,pozvaný
apps/erpnext/erpnext/config/accounts.py,Setup Gateway accounts.,Nastavenia brány účty.
apps/erpnext/erpnext/config/integrations.py,Connect your bank accounts to ERPNext,Pripojte svoje bankové účty k ERPĎalším
DocType: Employee,Employment Type,Typ zaměstnání
apps/erpnext/erpnext/config/projects.py,Make project from a template.,Vytvorte projekt zo šablóny.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Fixed Assets,Dlhodobý majetok
DocType: Payment Entry,Set Exchange Gain / Loss,Set Exchange zisk / strata
,GST Purchase Register,Registrácia nákupov GST
,Cash Flow,Cash Flow
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á časť faktúry sa musí rovnať 100%
DocType: Item Default,Default Expense Account,Výchozí výdajového účtu
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,Študent ID e-mailu
DocType: Employee,Notice (days),Oznámenie (dni)
DocType: POS Closing Voucher Invoices,POS Closing Voucher Invoices,Faktúry POS uzatváracieho dokladu
DocType: Tax Rule,Sales Tax Template,Daň z predaja Template
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Download JSON,Stiahnite 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,Aktualizovať číslo Centra nákladov
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select items to save the invoice,"Vyberte položky, ktoré chcete uložiť faktúru"
DocType: Employee,Encashment Date,Inkaso Datum
DocType: Training Event,Internet,internet
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Seller Information,Informácie o predajcovi
DocType: Special Test Template,Special Test Template,Špeciálna šablóna testu
DocType: Account,Stock Adjustment,Úprava skladových zásob
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,Default Activity Cost exists for Activity Type - {0},Existuje Náklady Predvolené aktivity pre Typ aktivity - {0}
DocType: Work Order,Planned Operating Cost,Plánované provozní náklady
DocType: Academic Term,Term Start Date,Termín Dátum začatia
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Authentication Failed,Overenie zlyhalo
apps/erpnext/erpnext/config/accounts.py,List of all share transactions,Zoznam všetkých transakcií s akciami
DocType: Supplier,Is Transporter,Je Transporter
DocType: Shopify Settings,Import Sales Invoice from Shopify if Payment is marked,"Importovať faktúru z predaja, ak je platba označená"
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp Count,Opp Count
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í sa nastaviť dátum spustenia skúšobného obdobia a dátum ukončenia skúšobného obdobia
apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py,Average Rate,Priemerná hodnota
apps/erpnext/erpnext/controllers/accounts_controller.py,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Celková čiastka platby v pláne platieb sa musí rovnať veľkému / zaokrúhlenému súčtu
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot have Valuation Rate",„Položka poskytovaná zákazníkom“ nemôže mať mieru ocenenia
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,Bankový zostatok podľa hlavnej knihy
DocType: Job Applicant,Applicant Name,Meno žiadateľa
DocType: Authorization Rule,Customer / Item Name,Názov zákazníka/položky
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","Súhrnný skupina ** položiek ** do iného ** Položka **. To je užitočné, ak sa zväzovanie niektoré položky ** ** do balíka a budete udržiavať zásoby balených ** Položky ** a nie agregát ** položky **. Balíček ** Položka ** bude mať &quot;Je skladom,&quot; ako &quot;Nie&quot; a &quot;Je predaja Item&quot; ako &quot;Yes&quot;. Napríklad: Ak predávate notebooky a batohy oddelene a majú špeciálnu cenu, ak zákazník kúpi obidva, potom Laptop + Backpack bude nový Bundle Product Item. Poznámka: BOM = Nomenklatúra"
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,Atribút
DocType: Staffing Plan Detail,Current Count,Aktuálny počet
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Please specify from/to range,Uveďte z / do rozmedzie
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Opening {0} Invoice created,Otvorenie {0} Vytvorená faktúra
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 ,Guardian Of
DocType: Grading Scale Interval,Threshold,Prah
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Filter Employees By (Optional),Filtrovať zamestnancov podľa (voliteľné)
DocType: BOM Update Tool,Current BOM,Aktuální BOM
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Balance (Dr - Cr),Zostatok (Dr - Cr)
DocType: Pick List,Qty of Finished Goods Item,Množstvo dokončeného tovaru
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žstvo v zdrojovom sklade
apps/erpnext/erpnext/config/support.py,Warranty,záruka
DocType: Purchase Invoice,Debit Note Issued,vydanie dlhopisu
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,"Search by item code, serial number, batch no or barcode","Vyhľadajte podľa kódu položky, sériového čísla, šarže alebo čiarového kódu"
DocType: Work Order,Warehouses,Sklady
DocType: Shift Type,Last Sync of Checkin,Posledná synchronizácia Checkin
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Add a new address,Pridajte novú adresu
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,{0} asset cannot be transferred,{0} pohľadávku nemôže byť prevedená
DocType: Hotel Room Pricing,Hotel Room Pricing,Ceny izieb v hoteli
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py,"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Nemožno označiť Vypustený záznam pacienta, existujú nevyfakturné faktúry {0}"
DocType: Subscription,Days Until Due,Dni až do splatnosti
apps/erpnext/erpnext/stock/doctype/item/item.js,This Item is a Variant of {0} (Template).,Táto položka je variantom {0} (šablóna).
DocType: Workstation,per hour,za hodinu
DocType: Blanket Order,Purchasing,nákup
DocType: Announcement,Announcement,oznámenia
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.",V prípade dávkovej študentskej skupiny bude študentská dávka schválená pre každého študenta zo 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,Distribúcia
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 zamestnanca nie je možné nastaviť na „Zľava“, pretože tento zamestnanec v súčasnosti podáva správy tomuto zamestnancovi:"
DocType: Journal Entry Account,Loan,pôžička
DocType: Expense Claim Advance,Expense Claim Advance,Nároky na nárok na výdavky
DocType: Lab Test,Report Preference,Preferencia prehľadu
apps/erpnext/erpnext/config/non_profit.py,Volunteer information.,Informácie o dobrovoľníkoch.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Project Manager,Project Manager
,Quoted Item Comparison,Citoval Položka Porovnanie
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Overlap in scoring between {0} and {1},Prekrývajúci sa bodovanie medzi {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 aktív aj na
DocType: Crop,Produce,vyrobiť
DocType: Hotel Settings,Default Taxes and Charges,Východiskové Dane a poplatky
DocType: Account,Receivable,Pohľadávky
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,"Riadok # {0}: Nie je povolené meniť dodávateľa, objednávky už existuje"
DocType: Stock Entry,Material Consumption for Manufacture,Spotreba materiálu na výrobu
DocType: Item Alternative,Alternative Item Code,Kód alternatívnej položky
DocType: Appointment Booking Settings,Notify Via Email,Upozorniť e-mailom
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ýroby
DocType: Delivery Stop,Delivery Stop,Zastavenie doručenia
apps/erpnext/erpnext/accounts/page/pos/pos.js,"Master data syncing, it might take some time","Kmeňové dáta synchronizácia, môže to trvať nejaký č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 nie je stanovená v cenovom 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},Zamestnanec {0} nepatrí do spoločnosti {1}
DocType: BOM,Show Items,Zobraziť položky
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.py,Duplicate Tax Declaration of {0} for period {1},Duplikát daňového priznania z {0} za obdobie {1}
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py,From Time cannot be greater than To Time.,Od doby nemôže byť väčšia ako na čas.
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Do you want to notify all the customers by email?,Chcete upozorniť všetkých zákazníkov e-mailom?
DocType: Subscription Plan,Billing Interval,Fakturačný interval
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,Pokračovať
DocType: Salary Detail,Component,komponentov
DocType: Video,YouTube,YouTube
apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py,Row {0}: {1} must be greater than 0,Riadok {0}: {1} musí byť väčší ako 0
DocType: Assessment Criteria,Assessment Criteria Group,Hodnotiace kritériá Group
DocType: Healthcare Settings,Patient Name By,Názov pacienta
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Accrual Journal Entry for salaries from {0} to {1},Záznam o účtovaní časového rozlíšenia pre platy od {0} do {1}
DocType: Sales Invoice Item,Enable Deferred Revenue,Povoliť odložené výnosy
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Opening Accumulated Depreciation must be less than equal to {0},Otvorenie Oprávky musí byť menšia ako rovná {0}
DocType: Appointment Booking Settings,Appointment Details,Podrobnosti o schôdzke
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Finished Product,Hotový výrobok
DocType: Warehouse,Warehouse Name,Názov 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žieb s typom entity {0} a entitou {1} už existuje.
DocType: Journal Entry,Write Off Entry,Odepsat Vstup
DocType: BOM,Rate Of Materials Based On,Hodnotit materiálů na bázi
DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Ak je povolené, pole Akademický termín bude povinné v programe Program registrácie."
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Values of exempt, nil rated and non-GST inward supplies","Hodnoty vyňatých, nulových a nemateriálnych vnútorných dodávok"
apps/erpnext/erpnext/regional/report/datev/datev.py,<b>Company</b> is a mandatory filter.,<b>Spoločnosť</b> je povinný filter.
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Uncheck all,Zrušte zaškrtnutie políčka všetko
DocType: Purchase Taxes and Charges,On Item Quantity,Na množstvo položky
DocType: POS Profile,Terms and Conditions,Podmínky
DocType: Asset,Booked Fixed Asset,Rezervovaný dlhodobý majetok
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 si můžete udržet 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áranie účtov ...
DocType: Leave Block List,Applies to Company,Platí pre firmu
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Cannot cancel because submitted Stock Entry {0} exists,"Nie je možné zrušiť, pretože existuje potvrdený zápis zásoby {0}"
DocType: Loan,Disbursement Date,vyplatenie Date
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.,Dátum začatia dohody nemôže byť väčší alebo rovný dátumu ukončenia.
DocType: BOM Update Tool,Update latest price in all BOMs,Aktualizujte najnovšiu cenu vo všetkých kusovníkoch
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 dňu musí byť pred dátumom
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the name of the bank or lending institution before submittting.,Pred odoslaním zadajte názov banky alebo inštitúcie poskytujúcej pôžičku.
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py,{0} must be submitted,{0} musí byť odoslaná
DocType: POS Profile,Item Groups,Skupiny položiek
DocType: Company,Standard Working Hours,Štandardná 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,Zostatok v mene úč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,Pridajte účet dočasného otvorenia v účtovej tabuľke
DocType: Customer,Customer Primary Contact,Primárny kontakt zákazníka
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp/Lead %,Opp / Olovo%
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp/Lead %,Opp / Olovo%
DocType: Bank Guarantee,Bank Account Info,Informácie o bankovom účte
DocType: Bank Guarantee,Bank Guarantee Type,Typ bankovej záruky
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() failed for valid IBAN {},BankAccount.validate_iban () zlyhal pre platný IBAN {}
DocType: Payment Schedule,Invoice Portion,Časť faktúry
,Asset Depreciations and Balances,Asset Odpisy a zostatkov
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} transferred from {2} to {3},Množstvo {0} {1} prevedená 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 zdravotníckych pracovníkov. Pridajte ho do programu Master of Health Practitioner
DocType: Sales Invoice,Get Advances Received,Získat přijaté zálohy
DocType: Email Digest,Add/Remove Recipients,Pridať / Odobrať príjemcu
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,Výška odpočítanej TDS
DocType: Production Plan,Include Subcontracted Items,Zahrňte subdodávateľné položky
apps/erpnext/erpnext/projects/doctype/project/project.py,Join,pripojiť
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Shortage Qty,Nedostatek Množství
DocType: Purchase Invoice,Input Service Distributor,Distribútor vstupných služieb
apps/erpnext/erpnext/stock/doctype/item/item.py,Item variant {0} exists with same attributes,Variant Položky {0} existuje s rovnakými vlastnosťami
DocType: Loan,Repay from Salary,Splatiť z platu
DocType: Exotel Settings,API Token,Rozhranie API
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Requesting payment against {0} {1} for amount {2},Požiadavka na platbu proti {0} {1} na sumu {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.,Povoľte obnovenie dohody o úrovni služieb z nastavení podpory.
apps/erpnext/erpnext/projects/doctype/task/task.py,{0} can not be greater than {1},{0} nemôže byť väčší ako {1}
DocType: Lead,Lost Quotation,stratil Citácia
DocType: Pricing Rule,Margin Rate or Amount,Marža sadzbou alebo pevnou sumou
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,'To Date' is required,"""Dátum 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,Položka predajnej objednávky
DocType: Salary Slip,Payment Days,Platební dny
DocType: Stock Settings,Convert Item Description to Clean HTML,Konvertovať popis položky na HTML
DocType: Patient,Dormant,spiace
DocType: Payroll Entry,Deduct Tax For Unclaimed Employee Benefits,Odpočítajte daň za nevyžiadané zamestnanecké výhody
DocType: Salary Slip,Total Interest Amount,Celková výška úroku
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with child nodes cannot be converted to ledger,Sklady s podriadené uzlami nemožno previesť do hlavnej účtovnej knihy
DocType: BOM,Manage cost of operations,Správa nákladů na provoz
DocType: Accounts Settings,Stale Days,Stale dni
DocType: Travel Itinerary,Arrival Datetime,Dátum príchodu
DocType: Tax Rule,Billing Zipcode,Fakturačný PSČ
DocType: Attendance,HR-ATT-.YYYY.-,HR-ATT-.YYYY.-
DocType: Crop,Row Spacing UOM,Rozloženie riadkov UOM
DocType: Assessment Result Detail,Assessment Result Detail,Posúdenie Detail Výsledok
DocType: Employee Education,Employee Education,Vzdelávanie zamestnancov
DocType: Service Day,Workday,pracovný deň
apps/erpnext/erpnext/setup/doctype/terms_and_conditions/terms_and_conditions.py,At least one of the Applicable Modules should be selected,Mal by sa vybrať aspoň jeden z použiteľných modulov
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate item group found in the item group table,Duplicitné skupinu položiek uvedené v tabuľke na položku v skupine
apps/erpnext/erpnext/config/quality_management.py,Tree of Quality Procedures.,Postupy pri strome stromu.
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","Nie je zamestnanec so štruktúrou platov: {0}. \ Prideľte {1} zamestnancovi, aby ste si mohli prezrieť ukážku platu"
apps/erpnext/erpnext/public/js/controllers/transaction.js,It is needed to fetch Item Details.,"Je potrebné, aby priniesla Detaily položky."
DocType: Fertilizer,Fertilizer Name,Názov 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 zľava
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on Actual,Ak akumulovaný mesačný rozpočet prekročil skutočný
DocType: Salary Component,Create Separate Payment Entry Against Benefit Claim,Vytvorte samostatné zadanie platby pred nárokom 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),"Prítomnosť horúčky (teplota&gt; 38,5 ° C alebo udržiavaná 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?,Zmazať trvalo?
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.,Folio č.
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","Keďže predpokladané množstvo surovín je väčšie ako požadované množstvo, nie je potrebné vytvárať požiadavky na materiál. Ak chcete podať materiálnu žiadosť, láskavo začiarknite políčko <b>Ignorovať existujúce projektované množstvo</b>"
DocType: Delivery Note,Billing Address Name,Názov fakturačnej adresy
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Department Stores,Obchodní domy
,Item Delivery Date,Dátum dodania položky
DocType: Selling Settings,Sales Update Frequency,Frekvencia aktualizácie predaja
DocType: Production Plan,Material Requested,Požadovaný materiál
DocType: Warehouse,PIN,PIN
DocType: Bin,Reserved Qty for sub contract,Vyhradené množstvo pre subkontrakt
DocType: Patient Service Unit,Patinet Service Unit,Servisná jednotka Patinet
DocType: Sales Invoice,Base Change Amount (Company Currency),Základňa Zmena Suma (Company mena)
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},Iba {0} na sklade pre položku {1}
DocType: Account,Chargeable,Spoplatniteľné
DocType: Company,Change Abbreviation,Zmeniť skratku
DocType: Contract,Fulfilment Details,Podrobnosti o plnení
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py,Pay {0} {1},Plaťte {0} {1}
DocType: Employee Onboarding,Activities,aktivity
DocType: Expense Claim Detail,Expense Date,Datum výdaje
DocType: Item,No of Months,Počet mesiacov
DocType: Item,Max Discount (%),Max zľava (%)
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,Credit Days cannot be a negative number,Kreditné dni nemôžu byť záporné číslo
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Upload a statement,Nahrajte vyhlásenie
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Report this item,Nahláste túto položku
DocType: Purchase Invoice Item,Service Stop Date,Dátum ukončenia servisu
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Last Order Amount,Suma poslednej objednávky
DocType: Cash Flow Mapper,e.g Adjustments for:,napr. Úpravy pre:
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} Zadržanie vzorky je založené na dávke. Skontrolujte dávkovú šaržu, ak chcete zachovať vzorku položky"
DocType: Task,Is Milestone,Je míľnikom
DocType: Certification Application,Yet to appear,Napriek tomu sa objaví
DocType: Delivery Stop,Email Sent To,E-mail odoslaný na
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Salary Structure not found for employee {0} and date {1},Štruktúra platu nebola nájdená pre zamestnanca {0} a dátum {1}
DocType: Job Card Item,Job Card Item,Položka Job Card
DocType: Accounts Settings,Allow Cost Center In Entry of Balance Sheet Account,Povoliť nákladové stredisko pri zápise účtov bilancie
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge with Existing Account,Zlúčiť so existujúcim účtom
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šetky položky už boli prevedené na túto pracovnú objednávku.
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Akékoľvek iné poznámky, pozoruhodné úsilie, ktoré by mali ísť v záznamoch."
DocType: Bank Account,Company Account,Firemný účet
DocType: Asset Maintenance,Manufacturing User,Používateľ výroby
DocType: Purchase Invoice,Raw Materials Supplied,Suroviny dodané
DocType: Subscription Plan,Payment Plan,Platobný plán
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},Mena cenníka {0} musí byť {1} alebo {2}
apps/erpnext/erpnext/config/accounts.py,Subscription Management,Správa predplatného
DocType: Appraisal,Appraisal Template,Posouzení Template
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Pin Code,Kódovanie 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čiarknite toto, ak chcete povoliť plánovanú dennú synchronizáciu prostredníctvom plánovača"
DocType: Item Group,Item Classification,Položka Klasifikace
apps/erpnext/erpnext/templates/pages/home.html,Publications,Publikácie
DocType: Driver,License Number,Číslo licencie
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,Druh položky na sklade
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Invoice Patient Registration,Faktúra Registrácia pacienta
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js,General Ledger,Hlavná Účtovná Kniha
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,To Fiscal Year,Do fiškálneho roka
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js,View Leads,Zobraziť Obchodné iniciatívy
DocType: Program Enrollment Tool,New Program,nový program
DocType: Item Attribute Value,Attribute Value,Hodnota atributu
DocType: POS Closing Voucher Details,Expected Amount,Očakávaná suma
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Multiple,Vytvorte viacero
,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,Zamestnanec {0} v platovej triede {1} nemá žiadne predvolené pravidlá pre dovolenku
DocType: Salary Detail,Salary Detail,Detail platu
DocType: Email Digest,New Purchase Invoice,Nová nákupná faktúra
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select {0} first,"Prosím, najprv vyberte {0}"
apps/erpnext/erpnext/public/js/hub/marketplace.js,Added {0} users,Pridali sme {0} používateľov
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Less Than Amount,Menej ako suma
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 prípade viacvrstvového programu budú zákazníci automaticky priradení príslušnému vrstvu podľa ich vynaložených prostriedkov
DocType: Appointment Type,Physician,lekár
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Batch {0} of Item {1} has expired.,Batch {0} z {1} bodu vypršala.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py,Consultations,konzultácie
apps/erpnext/erpnext/manufacturing/report/bom_variance_report/bom_variance_report.py,Finished Good,Ukončené dobro
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 sa objavuje viackrát na základe cenníka, dodávateľa / zákazníka, meny, položky, UOM, množstva a dátumov."
DocType: Sales Invoice,Commission,Provízia
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 byť väčšia ako plánované množstvo ({2}) v pracovnom poradí {3}
DocType: Certification Application,Name of Applicant,Meno žiadateľa
apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Čas list pre výrobu.
DocType: Quick Stock Balance,Quick Stock Balance,Rýchla bilancia zásob
apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,medzisúč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.,Nemožno zmeniť vlastnosti Variantu po transakcii s akciami. Budete musieť urobiť novú položku.
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ískajte položky pre pracovnú objednávku
DocType: Salary Detail,Default Amount,Výchozí částka
DocType: Lab Test Template,Descriptive,opisný
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 mesiac je zhrnutie
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.,`Zmraziť zásoby staršie ako` malo by byť menšie než %d dní.
DocType: Tax Rule,Purchase Tax Template,Spotrebná daň šablóny
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Earliest Age,Najstarší vek
DocType: Quality Goal,Revision,opakovanie
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Healthcare Services,Zdravotnícke služby
,Project wise Stock Tracking,Sledování zboží dle projektu
DocType: DATEV Settings,Regional,regionálne
apps/erpnext/erpnext/config/healthcare.py,Laboratory,laboratórium
DocType: UOM Category,UOM Category,UOM kategória
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á na určenie daňovej kategórie pri transakciách.
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Customer Group is Required in POS Profile,Zákaznícka skupina je povinná v POS profile
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,Nastavenia POS
apps/erpnext/erpnext/templates/pages/cart.html,Place Order,Objednať
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.js,Create Invoice,Vytvoriť faktúru
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...,Zvoľte značku ...
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""",Riadok č. Filtra: {0}: Názov poľa <b>{1}</b> musí byť typu „Link“ alebo „Table MultiSelect“
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Accumulated Depreciation as on,Oprávky aj na
DocType: Employee Tax Exemption Category,Employee Tax Exemption Category,Kategória oslobodenia od dane z príjmov zamestnancov
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Amount should not be less than zero.,Suma by nemala byť nižšia ako 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},Prevádzková doba musí byť väčšia ako 0 pre prevádzku {0}
DocType: Support Search Source,Post Route String,Pridať reťazec 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,Nepodarilo sa vytvoriť webové stránky
DocType: Soil Analysis,Mg/K,Mg / K
DocType: UOM Conversion Detail,UOM Conversion Detail,Detail konverzie MJ
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Admission and Enrollment,Prijatie a zápis
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Retention Stock Entry already created or Sample Quantity not provided,Už vytvorený záznam o zadržaní alebo množstvo neposkytnuté
DocType: Program,Program Abbreviation,program Skratka
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Voucher (Consolidated),Zoskupiť podľa poukážky (konsolidované)
DocType: HR Settings,Encrypt Salary Slips in Emails,Zašifrujte výplatné pásky v e-mailoch
DocType: Question,Multiple Correct Answer,Viacnásobná správna odpoveď
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,Rozvrh Výdavky
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Cheques and Deposits incorrectly cleared,Šeky a Vklady nesprávne vymazané
DocType: Homepage Section Card,Homepage Section Card,Karta sekcie domovskej stránky
,Amount To Be Billed,"Suma, ktorá sa má fakturovať"
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,Cenníková cena
apps/erpnext/erpnext/utilities/activation.py,Create customer quotes,Vytvoriť zákaznícke ponuky
apps/erpnext/erpnext/public/js/controllers/transaction.js,Service Stop Date cannot be after Service End Date,Dátum ukončenia servisu nemôže byť po dátume ukončenia 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,Priemerná doba zhotovená dodávateľom dodať
DocType: Travel Itinerary,Check-in Date,Dátum registrácie
DocType: Sample Collection,Collected By,Zhromaždené podľa
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js,Assessment Result,hodnotenie výsledkov
DocType: Hotel Room Package,Hotel Room Package,Balík hotelových izieb
DocType: Employee Transfer,Employee Transfer,Prevod zamestnancov
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},Bola pre vás vytvorená nová schôdzka s {0}
DocType: Project,Expected Start Date,Očekávané datum zahájení
DocType: Purchase Invoice,04-Correction in Invoice,04 - Oprava faktúry
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order already created for all items with BOM,Pracovná objednávka už vytvorená pre všetky položky s kusovníkom
DocType: Bank Account,Party Details,Party Podrobnosti
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant Details Report,Variant Details Report
DocType: Setup Progress Action,Setup Progress Action,Akcia pokroku pri inštalácii
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Price List,Nákupný cenní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šiť odber
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Please select Maintenance Status as Completed or remove Completion Date,Vyberte stav údržby ako dokončené alebo odstráňte dátum dokončenia
DocType: Supplier,Default Payment Terms Template,Šablóna predvolených platobných podmienok
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Transaction currency must be same as Payment Gateway currency,Mena transakcie musí byť rovnaká ako platobná brána menu
DocType: Payment Entry,Receive,Prijať
DocType: Employee Benefit Application Detail,Earning Component,Zisková zložka
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Items and UOMs,Spracúvanie položiek a UOM
apps/erpnext/erpnext/regional/italy/utils.py,Please set either the Tax ID or Fiscal Code on Company '%s',Prosím nastavte daňové identifikačné číslo alebo daňový kód spoločnosti &#39;% s&#39;
apps/erpnext/erpnext/templates/pages/rfq.html,Quotations: ,Ponuky:
DocType: Contract,Partially Fulfilled,Čiastočne splnené
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","Špeciálne znaky s výnimkou „-“, „#“, „.“, „/“, „{“ A „}“ nie sú v názvových sériách povolené."
DocType: Purchase Invoice Item,Is nil rated or exempted,Nie je hodnotené alebo vyňaté
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},Mena pre {0} musí byť {1}
DocType: Shift Type,Mark attendance based on 'Employee Checkin' for Employees assigned to this shift.,Označte účasť na základe kontroly zamestnancov pre zamestnancov priradených k tejto zmene.
DocType: Asset,Disposal Date,Likvidácia Dátum
DocType: Service Level,Response and Resoution Time,Čas odozvy a resoúcie
DocType: Employee Leave Approver,Employee Leave Approver,Schvalujúci priepustiek zamestnanca
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,Zadajte označenie
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ískajte vynikajúce dokumenty
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Items for Raw Material Request,Položky pre požiadavku na suroviny
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,CWIP Account,Účet CWIP
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Feedback,tréning Feedback
apps/erpnext/erpnext/config/accounts.py,Tax Withholding rates to be applied on transactions.,"Sadzby zrážky dane, ktoré sa majú uplatňovať na transakcie."
DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Kritériá hodnotiacej tabuľky dodávateľa
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,Suma na príjem
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Course is mandatory in row {0},Samozrejme je povinné v rade {0}
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,From date can not be greater than than To date,Od dátumu nemôže byť väčšie ako do dátumu
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,To date cannot be before from date,Dátum DO nemôže byť skôr ako dátum OD
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non GST Inward Supplies,Spotrebný materiál iný ako GST
DocType: Employee Group Table,Employee Group Table,Tabuľka skupiny zamestnancov
DocType: Packed Item,Prevdoc DocType,Prevdoc DOCTYPE
DocType: Cash Flow Mapper,Section Footer,Päta sekcie
apps/erpnext/erpnext/stock/doctype/item/item.js,Add / Edit Prices,Pridať / Upraviť ceny
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Employee Promotion cannot be submitted before Promotion Date ,Propagácia zamestnancov nemôže byť predložená pred dátumom propagácie
DocType: Batch,Parent Batch,Rodičovská dávka
DocType: Batch,Parent Batch,Rodičovská dávka
DocType: Cheque Print Template,Cheque Print Template,Šek šablóny tlače
DocType: Salary Component,Is Flexible Benefit,Je flexibilný prínos
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Chart of Cost Centers,Diagram nákladových stredísk
DocType: Subscription Settings,Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,Počet dní po uplynutí dátumu faktúry pred zrušením predplatného alebo označením predplatného ako nezaplateného
DocType: Clinical Procedure Template,Sample Collection,Zbierka vzoriek
,Requested Items To Be Ordered,Požadované položky je třeba objednat
DocType: Price List,Price List Name,Názov cenníka
DocType: Delivery Stop,Dispatch Information,Informácie o odoslaní
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill JSON can only be generated from submitted document,E-Way Bill JSON môže byť generovaný iba z predlož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!,Niečo sa 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,Mapovanie dát transakcií
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Sales Invoice {0} has already been submitted,Predajná faktúra {0} už bola odoslaná
DocType: Salary Component,Is Tax Applicable,Je možné uplatniť daň
DocType: Supplier Scorecard Scoring Criteria,Score,skóre
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} does not exist,Fiškálny 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 odporúčané
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Fetching...,Načítanie ...
DocType: Agriculture Analysis Criteria,Agriculture User,Poľnohospodársky užívateľ
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Valid till date cannot be before transaction date,Platné do dátumu nemôže byť pred dátumom transakcie
apps/erpnext/erpnext/stock/stock_ledger.py,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} jednotiek {1} potrebná {2} o {3} {4} na {5} pre dokončenie tejto transakcie.
DocType: Fee Schedule,Student Category,študent Kategórie
DocType: Announcement,Student,študent
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 skladovania k dispozícii nie je v sklade. Chcete zaznamenať prevod akcií
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,New {0} pricing rules are created,Vytvoria sa nové {0} pravidlá tvorby cien
DocType: Shipping Rule,Shipping Rule Type,Typ pravidla odoslania
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,"Company, Payment Account, From Date and To Date is mandatory","Spoločnosť, platobný účet, dátum a dátum je 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ženie spoloč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ávok uvedených v bode 3.1 písm. A) vyššie podrobnosti o medzinárodných dodávkach uskutočňovaných neregistrovaným osobám, osobám podliehajúcim dani v zložení a držiteľom UIN."
apps/erpnext/erpnext/regional/doctype/gst_hsn_code/gst_hsn_code.js,Item taxes updated,Dane z tovaru boli aktualizované
DocType: Education Settings,Enable LMS,Povoliť LMS
DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUPLIKÁT PRE DODÁVATEĽA
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Please save the report again to rebuild or update,Znova zostavte alebo aktualizujte prehľad
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot delete item {1} which has already been received,"Riadok # {0}: Nemožno odstrániť položku {1}, ktorá už bola prijatá"
DocType: Service Level Agreement,Response and Resolution Time,Čas odozvy a riešenia problémov
DocType: Asset,Custodian,strážca
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 mala byť hodnota medzi 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>Čas od času</b> nemôže byť neskôr ako <b>Čas od času</b> {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),Dovozné zásielky podliehajúce preneseniu daňovej povinnosti (iné ako vyššie uvedené položky 1 a 2)
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount(Company Currency),Suma objednávky (mena spoločnosti)
DocType: Chart of Accounts Importer,Import Chart of Accounts from a csv file,Importujte účtovnú schému zo súboru 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,Meno nákladového strediska
DocType: Student,B+,B +
DocType: HR Settings,Max working hours against Timesheet,Maximálna pracovná doba proti časového rozvrhu
DocType: Shift Type,Strictly based on Log Type in Employee Checkin,Prísne na základe typu denníka pri kontrole zamestnancov
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.,Dátum ukončenia úlohy {0} nemôže byť po dátume ukončenia 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,Prijaté a akceptované
,GST Itemised Sales Register,GST Podrobný predajný register
DocType: Staffing Plan,Staffing Plan Details,Podrobnosti personálneho 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é poistenie zamestnancov
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 robiť kreditný a debetný záznam na rovnaký účet naraz
DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Dávka dospelých sa pohybuje od 50 do 80 úderov za minútu.
DocType: Naming Series,Help HTML,Nápoveda HTML
DocType: Student Group Creation Tool,Student Group Creation Tool,Študent Group Tool Creation
DocType: Item,Variant Based On,Variant 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,Vernostný programový stupeň
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,Žiadny dodávateľ Part
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for hold: ,Dôvod pozastavenia:
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',"Nemôže odpočítať, ak kategória je pre &quot;ocenenie&quot; alebo &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,Prijaté Od
DocType: Lead,Converted,Prevedené
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 sa 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}","Podľa Nákupných nastavení, ak je potrebná nákupná požiadavka == &#39;ÁNO&#39;, potom pre vytvorenie nákupnej faktúry musí používateľ najskôr vytvoriť potvrdenie nákupu pre položku {0}"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Set Supplier for item {1},Riadok # {0}: Nastavte Dodávateľ pre položku {1}
DocType: Global Defaults,Default Distance Unit,Predvolená vzdialenosť jednotky
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: Hours value must be greater than zero.,Riadok {0}: doba hodnota musí byť väčšia ako nula.
apps/erpnext/erpnext/stock/doctype/item/item.py,Website Image {0} attached to Item {1} cannot be found,Webové stránky Image {0} pripája k bodu {1} nemožno nájsť
DocType: Asset,Assets,Aktíva
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álny dátum ukončenia faktúry
DocType: Payment Term,Due Date Based On,Dátum splatnosti založený na
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Please set default customer group and territory in Selling Settings,Nastavte predvolenú skupinu zákazníkov a územie v nastaveniach predaja
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, skontrolujte viac mien možnosť povoliť účty s inú menu"
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},Zamestnanec {0} je zapnutý Opustiť dňa {1}
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments selected for Journal Entry,Neboli vybraté žiadne splátky pre záznam denníka
DocType: Purchase Invoice,GST Category,Kategória GST
DocType: Payment Reconciliation,From Invoice Date,Z faktúry Dátum
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Budgets,Rozpočty
DocType: Invoice Discounting,Disbursed,vyplatená
DocType: Healthcare Settings,Laboratory Settings,Laboratórne nastavenia
DocType: Clinical Procedure,Service Unit,Servisná jednotka
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Successfully Set Supplier,Úspešne nastaviť dodávateľa
DocType: Leave Encashment,Leave Encashment,nechať inkasa
apps/erpnext/erpnext/public/js/setup_wizard.js,What does it do?,Čím sa zaoberá?
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py,Tasks have been created for managing the {0} disease (on row {1}),Boli vytvorené úlohy na správu ochorenia {0} (na riadku {1})
DocType: Crop,Byproducts,vedľajšie 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šetky Študent Prijímacie
,Average Commission Rate,Průměrná cena Komise
DocType: Share Balance,No of Shares,Počet akcií
DocType: Taxable Salary Slab,To Amount,Suma
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 byť ""áno"" pre neskladový tovar"
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Status,Vyberte položku 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,Popisný kľúč Popis
DocType: Pricing Rule,Pricing Rule Help,Ceny Pravidlo Help
DocType: School House,House Name,Meno dom
DocType: Fee Schedule,Total Amount per Student,Celková suma na študenta
DocType: Opportunity,Sales Stage,Predajná fáza
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Customer PO,Zákazník PO
DocType: Purchase Taxes and Charges,Account Head,Účet Head
DocType: Company,HRA Component,Komponent 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,Pridajte ostatných z vašej organizácie ako používateľov. Môžete tiež pridať a pozvať zákazníkov na portál ich pridaním zo zoznamu kontaktov
DocType: Stock Entry,Total Value Difference (Out - In),Celková hodnota Rozdíl (Out - In)
DocType: Employee Checkin,Location / Device ID,Miesto / ID zariadenia
DocType: Grant Application,Requested Amount,Požadovaná suma
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Exchange Rate is mandatory,Riadok {0}: Exchange Rate je povinné
DocType: Invoice Discounting,Bank Charges Account,Účet bankových poplatkov
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,Zistené choroby
DocType: Stock Entry,Default Source Warehouse,Výchozí zdroj Warehouse
DocType: Item,Customer Code,Code zákazníků
DocType: Bank,Data Import Configuration,Konfigurácia importu údajov
DocType: Asset Maintenance Task,Last Completion Date,Posledný dátum dokončenia
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í byť účtu Súvaha
DocType: Vital Signs,Coated,obalený
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Riadok {0}: Očakávaná hodnota po skončení životnosti musí byť nižšia ako čiastka hrubého nákupu
apps/erpnext/erpnext/regional/italy/utils.py,Please set {0} for address {1},Nastavte {0} pre adresu {1}
DocType: GoCardless Settings,GoCardless Settings,Nastavenia GoCardless
apps/erpnext/erpnext/controllers/stock_controller.py,Create Quality Inspection for Item {0},Vytvoriť kontrolu kvality pre 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.,Na zobrazenie tejto správy je potrebná trvalá inventarizácia spoločnosti {0}.
DocType: Certified Consultant,Certification Validity,Platnosť certifikátu
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Insurance Start date should be less than Insurance End date,Dátum poistenie štarte by mala byť menšia ako poistenie koncovým dátumom
DocType: Support Settings,Service Level Agreements,Dohody o úrovni služieb
DocType: Shopping Cart Settings,Display Settings,Nastavenia 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,Aktívna ponuka
DocType: Accounting Dimension Detail,Default Dimension,Predvolená dimenzia
DocType: Target Detail,Target Qty,Target Množství
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Against Loan: {0},Proti úveru: {0}
DocType: Shopping Cart Settings,Checkout Settings,Nastavenia checkout
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 platom zaslaný zamestnancovi bude chránený heslom, heslo sa vygeneruje na základe politiky hesiel."
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Closing Account {0} must be of type Liability / Equity,Záverečný účet {0} musí byť typu zodpovednosti / Equity
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Slip of employee {0} already created for time sheet {1},Výplatnej páske zamestnanca {0} už vytvorili pre časové list {1}
DocType: Vehicle Log,Odometer,Počítadlo najazdených kilometrov
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ázaná
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 žiadnu skladovú položku
DocType: Chapter,Chapter Head,Kapitola hlavu
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Search for a payment,Vyhľadajte platbu
DocType: Payment Term,Month(s) after the end of the invoice month,Mesiac (mesiace) po skončení mesiaca faktúry
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Salary Structure should have flexible benefit component(s) to dispense benefit amount,Štruktúra platu by mala mať flexibilné zložky prínosov na vyplácanie dávky
apps/erpnext/erpnext/config/projects.py,Project activity / task.,Projektová činnost / úkol.
DocType: Vital Signs,Very Coated,Veľmi potiahnuté
DocType: Tax Category,Source State,Zdrojový štát
DocType: Salary Component,Only Tax Impact (Cannot Claim But Part of Taxable Income),"Iba daňový vplyv (nemožno nárokovať, ale časť zdaniteľného príjmu)"
apps/erpnext/erpnext/www/book_appointment/index.html,Book Appointment,Kniha schôdzka
DocType: Vehicle Log,Refuelling Details,tankovacie Podrobnosti
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab result datetime cannot be before testing datetime,Výsledok dátumu výsledku laboratória nemôže byť pred dátumom testovania
DocType: Delivery Trip,Use Google Maps Direction API to optimize route,Na optimalizáciu trasy použite rozhranie API služby Mapy Google
DocType: POS Profile,Allow user to edit Discount,Povoliť používateľovi upraviť zľavu
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Get customers from,Získajte zákazníkov z
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per rules 42 & 43 of CGST Rules,Podľa pravidiel 42 a 43 pravidiel CGST
DocType: Purchase Invoice Item,Include Exploded Items,Zahrňte explodované 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 začiatku nemôže byť väčší alebo rovný času ukončenia \ pre {0}.
DocType: Shipping Rule,Restrict to Countries,Obmedziť na krajiny
DocType: Shift Type,Alternating entries as IN and OUT during the same shift,Striedanie záznamov ako IN a OUT počas tej istej zmeny
DocType: Shopify Settings,Shared secret,Zdieľané tajomstvo
DocType: Amazon MWS Settings,Synch Taxes and Charges,Synchronizácia daní a poplatkov
apps/erpnext/erpnext/accounts/general_ledger.py,Please create adjustment Journal Entry for amount {0} ,Vytvorte opravný zápis do denníka pre sumu {0}
DocType: Purchase Invoice,Write Off Amount (Company Currency),Odpísať Suma (Company meny)
DocType: Sales Invoice Timesheet,Billing Hours,billing Hodiny
DocType: Project,Total Sales Amount (via Sales Order),Celková výška predaja (prostredníctvom objednávky predaja)
apps/erpnext/erpnext/controllers/taxes_and_totals.py,Row {0}: Invalid Item Tax Template for item {1},Riadok {0}: Neplatná šablóna dane z položky pre položku {1}
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Default BOM for {0} not found,Predvolené BOM pre {0} nebol nájdený
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year Start Date should be one year earlier than Fiscal Year End Date,Dátum začatia fiškálneho roka by mal byť o jeden rok skôr ako dátum ukončenia fiškálneho roka
apps/erpnext/erpnext/stock/doctype/item/item.py,Row #{0}: Please set reorder quantity,Riadok # {0}: Prosím nastavte množstvo objednávacie
apps/erpnext/erpnext/public/js/pos/pos.html,Tap items to add them here,Poklepte na položky a pridajte ich sem
DocType: Course Enrollment,Program Enrollment,Registrácia do programu
apps/erpnext/erpnext/controllers/item_variant.py,Rename Not Allowed,Premenovať nie je povolené
DocType: Share Transfer,To Folio No,Do priečinka č
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á kategória pre hlavné daňové sadzby.
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 neaktívnym študentom
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} je neaktívnym študentom
DocType: Employee,Health Details,Zdravotní Podrobnosti
DocType: Coupon Code,Coupon Type,Typ kupónu
DocType: Leave Encashment,Encashable days,Zapamätateľné dni
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Vyžaduje sa vytvorenie referenčného dokumentu žiadosti o platbu
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Vyžaduje sa vytvorenie referenčného dokumentu žiadosti o platbu
DocType: Soil Texture,Sandy Clay,Sandy Clay
DocType: Grant Application,Assessment  Manager,Manažér pre hodnotenie
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Allocate Payment Amount,Vyčleniť sumu platby
DocType: Subscription Plan,Subscription Plan,Plán predplatné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 uloženia
apps/erpnext/erpnext/accounts/report/sales_register/sales_register.py,Custmer Group,Custmer Group
DocType: Email Digest,Receivables,Pohľadávky
DocType: Lead Source,Lead Source,Zdroj Iniciatívy
DocType: Customer,Additional information regarding the customer.,Ďalšie informácie týkajúce sa 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 priradená ku {2}, ale účet Party je {3}"
DocType: Bank Statement Settings Item,Bank Header,Záhlavie banky
apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js,View Lab Tests,Zobraziť laboratórne testy
DocType: Hub Users,Hub Users,Používatelia Hubu
DocType: Purchase Invoice,Y,Y
DocType: Maintenance Visit,Maintenance Date,Datum údržby
DocType: Purchase Invoice Item,Rejected Serial No,Zamítnuto Serial No
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 dátum začatia alebo ukončenia sa prekrýva s {0}. Aby sa zabránilo nastavte firmu
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Please mention the Lead Name in Lead {0},Označte vedúci názov vo vedúcej {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,Nastavenia automatickej dochádzky
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áť Dochádzku
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,BOM and Manufacturing Quantity are required,BOM a Výrobné množstvo sú 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 Sila
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Installing presets,Inštalácia predvolieb
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 {},Pre zákazníka nie je vybratá žiadna dodacia poznámka {}
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Rows Added in {0},Riadky pridané v {0}
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Employee {0} has no maximum benefit amount,Zamestnanec {0} nemá maximálnu výšku dávok
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select Items based on Delivery Date,Vyberte položku podľa dátumu doručenia
DocType: Grant Application,Has any past Grant Record,Má nejaký predchádzajúci grantový záznam
,Sales Analytics,Analýza predaja
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Available {0},K dispozícii {0}
,Prospects Engaged But Not Converted,"Perspektívy zapojené, ale nekonvertované"
,Prospects Engaged But Not Converted,"Perspektívy zapojené, ale nekonvertované"
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> odoslal položky. \ Odstráňte položku <b>{1}</b> z tabuľky, aby ste mohli pokračovať."
DocType: Manufacturing Settings,Manufacturing Settings,Nastavenia Výroby
DocType: Quality Feedback Template Parameter,Quality Feedback Template Parameter,Parameter šablóny spätnej väzby kvality
apps/erpnext/erpnext/config/settings.py,Setting up Email,Nastavenia pre e-mail
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Mobile No,Guardian1 Mobile Žiadne
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 zásob
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Daily Reminders,Denné pripomienky
apps/erpnext/erpnext/templates/pages/help.html,See all open tickets,Pozrite si všetky otvorené lístky
DocType: Brand,Brand Defaults,Predvolené hodnoty značky
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js,Healthcare Service Unit Tree,Strom jednotky zdravotníckych služieb
DocType: Pricing Rule,Product,výrobok
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,Ponechajte sumu zaplatenia za deň
DocType: Loyalty Program Collection,For how much spent = 1 Loyalty Point,Pre koľko strávil = 1 vernostný 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ázov účtu
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Dodává se nákladů na suroviny
DocType: Selling Settings,Settings for Selling Module,Nastavenie modulu Predaj
DocType: Hotel Room Reservation,Hotel Room Reservation,Rezervácia izieb v hoteli
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Customer Service,Služby zákazníkom
DocType: BOM,Thumbnail,Thumbnail
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,No contacts with email IDs found.,Neboli nájdené žiadne kontakty s e-mailovými ID.
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álna výška dávky zamestnanca {0} presahuje {1}
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total allocated leaves are more than days in the period,Celkové pridelené listy sú viac ako dní v období
DocType: Linked Soil Analysis,Linked Soil Analysis,Analýza prepojenej pôdy
DocType: Pricing Rule,Percentage,percento
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ýchodiskové prácu v sklade 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 pre prekrytie {0}, chcete pokračovať po preskočení prekryvných pozícií?"
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js,Grant Leaves,Grantové listy
DocType: Restaurant,Default Tax Template,Štandardná daňová šablóna
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,{0} Students have been enrolled,{0} Študenti boli zapísaní
DocType: Fees,Student Details,Podrobnosti študenta
DocType: Woocommerce Settings,"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".",Toto je predvolené UOM použité pre položky a predajné objednávky. Záložná UOM je „Nos“.
DocType: Purchase Invoice Item,Stock Qty,Množstvo zásob
DocType: Purchase Invoice Item,Stock Qty,Množstvo zásob
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Ctrl+Enter to submit,Ctrl + Enter na odoslanie
DocType: Contract,Requires Fulfilment,Vyžaduje splnenie
DocType: QuickBooks Migrator,Default Shipping Account,Predvolený dodací úč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.,"Prosím, nastavte Dodávateľa na položky, ktoré sa majú zohľadniť v Objednávke."
DocType: Loan,Repayment Period in Months,Doba splácania v mesiacoch
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Error: Not a valid id?,Chyba: Nie je 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}: &quot;výkaz ziskov a strát&quot; typ účtu {2} nie je povolený vstup do Otváracia Entry
DocType: Job Offer,Printing Details,Detaily tlače
DocType: Task,Closing Date,Uzávěrka Datum
DocType: Sales Order Item,Produced Quantity,Vyrobené Množstvo
DocType: Item Price,Quantity  that must be bought or sold per UOM,"Množstvo, ktoré je potrebné zakúpiť alebo predať podľa UOM"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Engineer,Inženýr
DocType: Promotional Scheme Price Discount,Max Amount,Maximálna suma
DocType: Journal Entry,Total Amount Currency,Celková suma Mena
DocType: Pricing Rule,Min Amt,Min. Amt
DocType: Item,Is Customer Provided Item,Je položka poskytnutá zákazníkom
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Search Sub Assemblies,Vyhľadávanie 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 identifikácia
DocType: Restaurant Menu,Restaurant Manager,Manažér reštaurácie
DocType: Call Log,Call Log,Výpis hovorov
DocType: Authorization Rule,Customerwise Discount,Sleva podle zákazníka
apps/erpnext/erpnext/config/projects.py,Timesheet for tasks.,Časového rozvrhu pre úlohy.
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 (mena spoločnosti)
apps/erpnext/erpnext/regional/india/utils.py,House rent paid days overlapping with {0},Nájomné za platené dni sa prekrýva s {0}
DocType: GSTR 3B Report,October,október
DocType: Bank Reconciliation,Get Payment Entries,Získať Platobné 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 servera
DocType: Item Reorder,Re-Order Level,Úroveň doobjednania
DocType: Additional Salary,Deduct Full Tax on Selected Payroll Date,Odpočítajte plnú daň na vybraný dátum výplaty
DocType: Shopify Tax Account,Shopify Tax/Shipping Title,Nakupujte názov dane / plavby
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 zamestnancov
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,Zhrnutie transakcií 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,Iné prí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,Ignorovať prekrytie času používateľa
DocType: Accounting Period,Accounting Period,Účtovného obdobia
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date updated,Svetlá Dátum aktualizované
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split Batch,Split Batch
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split Batch,Split Batch
DocType: Stock Settings,Batch Identification,Identifikácia šarže
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Successfully Reconciled,Úspešne zinventarizované
DocType: Request for Quotation Supplier,Download PDF,Stiahnuť 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ý zoznam vedúci zoznam kontaktov prepojených s akcionárom
DocType: Exchange Rate Revaluation Account,Current Exchange Rate,Aktuálny kurz
DocType: Item,"Sales, Purchase, Accounting Defaults","Predaj, nákup, predvolené účtovníctvo"
DocType: Accounting Dimension Detail,Accounting Dimension Detail,Detail účtovnej dimenzie
apps/erpnext/erpnext/config/non_profit.py,Donor Type information.,Informácie o dárcovom type.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Leave on {1},{0} v Neprítomnosť {1}
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available for use date is required,Je potrebný dátum použiteľného na použitie
DocType: Request for Quotation,Supplier Detail,Detail dodávateľa
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Error in formula or condition: {0},Chyba vo vzorci alebo stave: {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Invoiced Amount,Fakturovaná čiastka
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Criteria weights must add up to 100%,Kritériové váhy musia pripočítať až 100%
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js,Attendance,Účast
apps/erpnext/erpnext/public/js/pos/pos.html,Stock Items,Položky zásob
DocType: Sales Invoice,Update Billed Amount in Sales Order,Aktualizovať faktúrovanú čiastku v objednávke predaja
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Contact Seller,Kontaktovať predajcu
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.,"Ak chcete nahlásiť túto položku, prihláste sa ako používateľ Marketplace."
,Sales Partner Commission Summary,Zhrnutie provízie obchodné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,Pridať do sviatkov
DocType: Woocommerce Settings,Endpoint,Endpoint
DocType: Period Closing Voucher,Period Closing Voucher,Období Uzávěrka Voucher
DocType: Patient Encounter,Review Details,Prehľad podrobností
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shareholder does not belong to this company,Akcionár nepatrí k tejto spoločnosti
DocType: Dosage Form,Dosage Form,Dávkovací formulár
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,Please set up the Campaign Schedule in the Campaign {0},Nastavte kampaň v kampani {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čiť účasť ako <b></b>
DocType: BOM,Allow Alternative Item,Povoliť alternatívnu 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.,"Potvrdenie o kúpe nemá žiadnu položku, pre ktorú je povolená vzorka ponechania."
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Invoice Grand Total,Celková faktúra
DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Séria pre odpisy majetku (záznam v účte)
DocType: Membership,Member Since,Členom 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},Pre kartu práce sú potrebné denníky času {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Healthcare Service,Vyberte prosím službu zdravotnej starostlivosti
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 atribútu {0} musí byť v rozmedzí od {1} až {2} v krokoch po {3} pre item {4}
DocType: Pricing Rule,Product Discount Scheme,Schéma zľavy na výrobok
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,No issue has been raised by the caller.,Volajúci nenastolil žiadny problém.
DocType: Restaurant Reservation,Waitlisted,poradovníka
DocType: Employee Tax Exemption Declaration Category,Exemption Category,Kategória výnimky
apps/erpnext/erpnext/accounts/doctype/account/account.py,Currency can not be changed after making entries using some other currency,Mena nemôže byť zmenený po vykonaní položky pomocou inej mene
DocType: Shipping Rule,Fixed,fixné
DocType: Vehicle Service,Clutch Plate,kotúč spojky
DocType: Tally Migration,Round Off Account,Zaokrúhliť úč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áklade cenníka
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,E-Way Bill JSON môže byť generovaný iba z predajnej faktúry
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Maximum attempts for this quiz reached!,Dosiahli ste maximálny počet pokusov o tento test!
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Subscription,predplatné
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Pending,Tvorba poplatkov čaká
DocType: Project Template Task,Duration (Days),Trvanie (dni)
DocType: Appraisal Goal,Score Earned,Skóre Zasloužené
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Notice Period,Výpovedná Lehota
DocType: Asset Category,Asset Category Name,Asset názov kategórie
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,Meno Nová Sales Osoba
DocType: Packing Slip,Gross Weight UOM,Hrubá Hmotnosť MJ
DocType: Employee Transfer,Create New Employee Id,Vytvoriť nové číslo zamestnanca
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,Cestovanie z
DocType: Asset Maintenance Task,Preventive Maintenance,Preventívna údržba
DocType: Delivery Note Item,Against Sales Invoice,Proti prodejní faktuře
DocType: Purchase Invoice,07-Others,07-Iné
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please enter serial numbers for serialized item ,Zadajte sériové čísla pre sériovú položku
DocType: Bin,Reserved Qty for Production,Vyhradené Množstvo pre výrobu
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,"Ponechajte nezačiarknuté, ak nechcete zohľadňovať dávku pri zaradení do skupín."
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,"Ponechajte nezačiarknuté, ak nechcete zohľadňovať dávku pri zaradení do skupín."
DocType: Asset,Frequency of Depreciation (Months),Frekvencia odpisy (mesiace)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Credit Account,Úverový úč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,Testovacia 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}","Vydanie nie je možné vykonať na miesto. \ Zadajte zamestnanca, ktorý vydal majetok {0}"
DocType: Service Level Agreement,Entity,bytosť
DocType: Payment Reconciliation,Receivable / Payable Account,Účet pohľadávok/záväzkov
DocType: Delivery Note Item,Against Sales Order Item,Proti položce přijaté objednávky
DocType: Company,Company Logo,Logo spoločnosti
DocType: QuickBooks Migrator,Default Warehouse,Predvolený sklad
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Budget cannot be assigned against Group Account {0},Rozpočet nemôže byť priradená na skupinový účet {0}
DocType: Shopping Cart Settings,Show Price,Zobraziť cenu
DocType: Healthcare Settings,Patient Registration,Registrácia 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 Dátum
,Work Orders in Progress,Pracovné príkazy v procese
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žiteľnosti (v dňoch)
DocType: Appraisal,Total Score (Out of 5),Celkové skóre (Out of 5)
DocType: Student Attendance Tool,Batch,Šarža
DocType: Support Search Source,Query Route String,Dotaz reťazca trasy
DocType: Tally Migration,Day Book Data,Údaje o dennej knihe
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update rate as per last purchase,Miera aktualizácie podľa posledného nákupu
DocType: Donor,Donor Type,Typ darcu
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Auto repeat document updated,Dokument bol aktualizovaný automaticky
apps/erpnext/erpnext/stock/doctype/item/item.js,Balance,Zostatok
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please select the Company,Vyberte spoločnosť
DocType: Employee Checkin,Skip Auto Attendance,Preskočiť automatickú účasť
DocType: BOM,Job Card,Pracovná karta
DocType: Room,Seating Capacity,Počet miest na sedenie
DocType: Issue,ISS-,ISS-
DocType: Item,Is Non GST,Nie je GST
DocType: Lab Test Groups,Lab Test Groups,Laboratórne testovacie skupiny
apps/erpnext/erpnext/config/accounts.py,Profitability,Ziskovosť
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ý pre účet {0}
DocType: Project,Total Expense Claim (via Expense Claims),Total Expense Claim (via Expense nárokov)
DocType: GST Settings,GST Summary,Súhrn 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,Pred vytvorením dennej skupinovej pracovnej skupiny aktivujte predvolený prichádzajúci účet
DocType: Assessment Result,Total Score,Konečné skóre
DocType: Crop Cycle,ISO 8601 standard,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 poradí môžete uplatniť maximálne {0} body.
DocType: Expense Claim,HR-EXP-.YYYY.-,HR-EXP-.YYYY.-
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Secret,Zadajte zákaznícke tajomstvo služby API
DocType: Stock Entry,As per Stock UOM,Podľa skladovej MJ
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js,Not Expired,Neuplynula
DocType: Student Log,Achievement,úspech
DocType: Asset,Insurer,poisťovateľ
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,Boli vytvorené rozvrhy kurzov
DocType: Employee Onboarding,Employee Onboarding,Zamestnanec na palube
DocType: Journal Entry,Total Debit,Celkem Debit
DocType: Travel Request Costing,Sponsored Amount,Sponzorovaná čiastka
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Predvolený sklad hotových výrobkov
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,Predajca
DocType: Hotel Room Package,Amenities,Vybavenie
DocType: Accounts Settings,Automatically Fetch Payment Terms,Automaticky načítať platobné podmienky
DocType: QuickBooks Migrator,Undeposited Funds Account,Účet neukladaných finančných prostriedkov
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Nie je povolený viacnásobný predvolený spôsob platby
DocType: Sales Invoice,Loyalty Points Redemption,Vernostné body Vykúpenie
,Appointment Analytics,Aplikácia Analytics
DocType: Lead,Blog Subscriber,Blog Subscriber
DocType: Guardian,Alternate Number,Alternatívne Number
DocType: Assessment Plan Criteria,Maximum Score,maximálny počet bodov
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,Zúčtovanie peňažných tokov
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py, Group Roll No,Skupina Roll Nie
DocType: Quality Goal,Revision and Revised On,Revízia a revízia dňa
DocType: Batch,Manufacturing Date,Dátum výroby
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Failed,Vytvorenie poplatku zlyhalo
DocType: Opening Invoice Creation Tool,Create Missing Party,Vytvoriť chýbajúcu 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,"Nechajte prázdne, ak robíte študentské skupiny ročne"
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Nechajte prázdne, ak robíte študentské skupiny ročne"
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,Nepodarilo sa pridať 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.","Ak chcete povoliť príjem / doručenie, aktualizujte položku „Príjem a príjem zásielok“ v nastaveniach zásob alebo v položke."
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Aplikácie používajúce aktuálny kľúč nebudú mať prístup, určite?"
DocType: Subscription Settings,Prorate,kľúčovanie
DocType: Purchase Invoice,Total Advance,Total Advance
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Template Code,Zmena kódu šablóny
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ý Dátum ukončenia nesmie byť starší ako Počiatočný dátum doby platnosti. Opravte dáta a skúste to znova.
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot Count,Počet kvót
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot Count,Počet kvót
DocType: Bank Statement Transaction Entry,Bank Statement,Výpis z bankového účtu
DocType: Employee Benefit Claim,Max Amount Eligible,Maximálna výška oprávnenia
,BOM Stock Report,BOM Reklamné Report
DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Ak nie je priradený žiadny časový rozvrh, komunikácia bude uskutočnená touto skupinou"
DocType: Stock Reconciliation Item,Quantity Difference,Množstvo Rozdiel
DocType: Opportunity Item,Basic Rate,Základná sadzba
DocType: GL Entry,Credit Amount,Výška úveru
,Electronic Invoice Register,Elektronický register faktúr
DocType: Cheque Print Template,Signatory Position,signatár Position
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Set as Lost,Nastaviť ako Nezískané
DocType: Timesheet,Total Billable Hours,Celkovo zúčtované hodiny
DocType: Subscription,Number of days that the subscriber has to pay invoices generated by this subscription,"Počet dní, ktoré musí účastník zaplatiť faktúry generované týmto odberom"
apps/erpnext/erpnext/projects/doctype/project/project.py,Use a name that is different from previous project name,"Použite názov, ktorý sa líši od názvu predchádzajúceho projektu"
DocType: Employee Benefit Application Detail,Employee Benefit Application Detail,Podrobnosti o žiadosti o zamestnanecké benefity
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Payment Receipt Note,Doklad o zaplatení Note
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,This is based on transactions against this Customer. See timeline below for details,To je založené na transakciách proti tomuto zákazníkovi. Pozri časovú os nižšie podrobnosti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Create Material Request,Vytvoriť požiadavku 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}","Dátumy začiatku a ukončenia, ktoré nie sú v platnom období mzdy, sa nedajú vypočítať {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},Riadok {0}: Pridelená suma {1} musí byť menší ako alebo sa rovná sume zaplatení výstavného {2}
DocType: Program Enrollment Tool,New Academic Term,Nový akademický termín
,Course wise Assessment Report,Priebežná hodnotiaca správa
DocType: Customer Feedback Template,Customer Feedback Template,Spätná väzba od zákazníka
DocType: Purchase Invoice,Availed ITC State/UT Tax,Využil daň z ITC štá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,Prihláste sa ako iný používateľ na registráciu v službe Marketplace
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Naplánujte čas protokoly mimo Workstation pracovných hodín.
apps/erpnext/erpnext/public/js/pos/pos.html,Customers in Queue,Zákazníci vo fronte
DocType: Driver,Issuing Date,Dátum vydania
DocType: Procedure Prescription,Appointment Booked,Schôdza rezervovaná
DocType: Student,Nationality,národnosť
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure,konfigurácia
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Submit this Work Order for further processing.,Odošlite túto objednávku na ďalšie spracovanie.
,Items To Be Requested,Položky se budou vyžadovat
DocType: Company,Allow Account Creation Against Child Company,Povoliť vytvorenie účtu proti dcérskej spoločnosti
DocType: Company,Company Info,Informácie o spoločnosti
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select or add new customer,Vyberte alebo pridajte 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é stredisko je nutné rezervovať výdavkov 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žené na účasti základu tohto zamestnanca
DocType: Payment Request,Payment Request Type,Typ žiadosti o platbu
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Mark Attendance,Označenie účasti
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Debit Account,Debetný účet
DocType: Fiscal Year,Year Start Date,Dátom začiatku roka
DocType: Additional Salary,Employee Name,Meno zamestnanca
DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Položka objednávky reštaurácie
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,{0} bank transaction(s) created and {1} errors,Počet vytvorených bankových transakcií: {0} a {1} chýb
DocType: Purchase Invoice,Rounded Total (Company Currency),Zaoblený Total (Company Měna)
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} bol zmenený. 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.","V prípade neobmedzeného uplynutia platnosti Vernostných bodov, ponechajte dobu trvania expirácie prázdnu alebo 0."
DocType: Asset Maintenance Team,Maintenance Team Members,Členovia tímu údržby
DocType: Coupon Code,Validity and Usage,Platnosť a použitie
DocType: Loyalty Point Entry,Purchase Amount,suma 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}","Nie je možné dodať sériové číslo {0} položky {1}, pretože je rezervované \ na plnenie zákazky odberateľa {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,Dodávateľ Cien {0} vytvoril
apps/erpnext/erpnext/accounts/report/financial_statements.py,End Year cannot be before Start Year,Koniec roka nemôže byť pred uvedením do prevádzky roku
DocType: Employee Benefit Application,Employee Benefits,Zamestnanecké benefity
apps/erpnext/erpnext/projects/report/billing_summary.py,Employee ID,zamestnanecké ID
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Packed quantity must equal quantity for Item {0} in row {1},Balené množstvo se musí rovnať množstvu pre položku {0} v riadku {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ú pri {0}
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Select Difference Account,Vyberte rozdielny účet
DocType: Sales Partner Type,Sales Partner Type,Typ obchodného partnera
DocType: Purchase Order,Set Reserve Warehouse,Nastaviť rezervný sklad
DocType: Shopify Webhook Detail,Webhook ID,Webhook ID
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Invoice Created,Vytvorená faktúra
DocType: Asset,Out of Order,Mimo prevádzky
DocType: Purchase Receipt Item,Accepted Quantity,Schválené Množstvo
DocType: Projects Settings,Ignore Workstation Time Overlap,Ignorovať prekrytie pracovnej doby
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please set a default Holiday List for Employee {0} or Company {1},Prosím nastaviť predvolené Holiday List pre zamestnancov {0} alebo {1} Company
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html,Timing,načasovanie
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,Vyberte dávkové čísla
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To GSTIN,Na GSTIN
apps/erpnext/erpnext/config/accounts.py,Bills raised to Customers.,Faktúry zákazníkom
DocType: Healthcare Settings,Invoice Appointments Automatically,Automatické zadanie faktúr
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,Premenná založená na zdaniteľnom platu
DocType: Company,Basic Component,Základná zložka
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},"Riadok č {0}: Čiastka nemôže byť väčšia ako Čakajúci Suma proti Expense nároku {1}. Do doby, než množstvo je {2}"
DocType: Patient Service Unit,Medical Administrator,Zdravotnícky 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,Priradenie štruktúry platov pre zamestnanca už 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,Budúce platby
DocType: Amazon MWS Settings,Max Retry Limit,Maximálny limit opakovania
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',"Zamestnanec uvoľnený na {0} musí byť nastavený ako ""Opustil"""
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,Všetky komunikácie vrátane a nad nimi sa presunú do nového čísla
DocType: Salary Detail,Tax on additional salary,Daň z dodatočného platu
DocType: Item Alternative,Item Alternative,Položka Alternatíva
DocType: Healthcare Settings,Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,"Predpokladané výnosové účty, ktoré sa použijú, ak nie sú stanovené v zdravotníckom praktickom lekári na vyúčtovanie poplatkov za schôdzku."
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Total contribution percentage should be equal to 100,Celkové percento príspevku by sa malo rovnať 100
DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Vytvorte chýbajúceho zákazníka alebo dodávateľa.
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,Vzdelanie
DocType: Payroll Entry,Salary Slips Created,Vytvorené platobné pásky
DocType: Inpatient Record,Expected Discharge,Očakávané vybitie
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Del,del
DocType: Selling Settings,Campaign Naming By,Pomenovanie kampane podľa
DocType: Employee,Current Address Is,Aktuálna adresa je
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html,modified,modifikovaný
DocType: Travel Request,Identification Document Number,Identifikačné číslo dokladu
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Optional. Sets company's default currency, if not specified.","Voliteľné. Nastaví východiskovej mene spoločnosti, ak nie je uvedené."
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 ,"Zoznam chorôb zistených v teréne. Po výbere bude automaticky pridaný zoznam úloh, ktoré sa budú týkať tejto choroby"
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á sa o koreňovú službu zdravotnej starostlivosti a nemožno ju upraviť.
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, ktorá sa má prijať"
apps/erpnext/erpnext/public/js/event.js,Add Sales Partners,Pridať obchodných partnerov
apps/erpnext/erpnext/config/accounts.py,Accounting journal entries.,Zápisy v účetním deníku.
DocType: Travel Request,Travel Request,Žiadosť o cestu
DocType: Payment Reconciliation,System will fetch all the entries if limit value is zero.,"Ak je limitná hodnota nula, systém načíta všetky záznamy."
DocType: Delivery Note Item,Available Qty at From Warehouse,K dispozícii Množstvo na Od Warehouse
apps/erpnext/erpnext/hr/doctype/department_approver/department_approver.py,Please select Employee Record first.,"Prosím, vyberte zamestnanca záznam prvý."
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as it is a Holiday.,"Účasť sa nepredložila za {0}, pretože ide o dovolenku."
DocType: POS Profile,Account for Change Amount,Účet pre zmenu Suma
DocType: QuickBooks Migrator,Connecting to QuickBooks,Pripojenie k aplikácii QuickBooks
DocType: Exchange Rate Revaluation,Total Gain/Loss,Celkový zisk / strata
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Pick List,Vytvoriť zoznam
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Riadok {0}: Party / Account nezhoduje s {1} / {2} do {3} {4}
DocType: Employee Promotion,Employee Promotion,Podpora zamestnancov
DocType: Maintenance Team Member,Maintenance Team Member,Člen tímu údržby
DocType: Agriculture Analysis Criteria,Soil Analysis,Analýza pôdy
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Course Code: ,Kód kurzu:
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","Riadok # {0}: Reference Document Type musí byť jedným z objednávky, faktúry alebo Journal Entry"
DocType: Employee,Current Address,Aktuálna 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,Vykonajte objednávku práce pre položky podzostavy
DocType: Serial No,Purchase / Manufacture Details,Nákup / Výroba Podrobnosti
DocType: Assessment Group,Assessment Group,skupina Assessment
DocType: Stock Entry,Per Transferred,Za prevedené
apps/erpnext/erpnext/config/help.py,Batch Inventory,Batch Zásoby
DocType: Sales Invoice,GST Transporter ID,ID prepravcu GST
DocType: Procedure Prescription,Procedure Name,Názov procedúry
DocType: Employee,Contract End Date,Smlouva Datum ukončení
DocType: Amazon MWS Settings,Seller ID,ID predávajúceho
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,Výpis transakcie z bankového výpisu
DocType: Sales Invoice Item,Discount and Margin,Zľava a Margin
DocType: Lab Test,Prescription,predpis
DocType: Import Supplier Invoice,Upload XML Invoices,Odovzdajte faktúry XML
DocType: Company,Default Deferred Revenue Account,Predvolený účet odloženého výnosu
DocType: Project,Second Email,Druhý e-mail
DocType: Budget,Action if Annual Budget Exceeded on Actual,"Opatrenie, ak bol ročný rozpočet prekročený na skutoč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ázať šablónu
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),Začať dňa (dni)
DocType: Quality Action,Preventive,preventívna
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to Unregistered Persons,Dodávky dodávané neregistrovaným osobám
DocType: Company,Date of Incorporation,Dátum začlenenia
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Total Tax,Total Tax
DocType: Manufacturing Settings,Default Scrap Warehouse,Predvolený sklad šrotu
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Last Purchase Price,Posledná nákupná cena
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For Quantity (Manufactured Qty) is mandatory,Pre Množstvo (Vyrobené ks) je povinné
DocType: Stock Entry,Default Target Warehouse,Výchozí Target Warehouse
DocType: Purchase Invoice,Net Total (Company Currency),Net Total (Company Měna)
DocType: Sales Invoice,Air,ovzdušia
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 Dátum ukončenia nesmie byť starší ako dátum rok Štart. Opravte dáta a skúste to znova.
DocType: Purchase Order,Set Target Warehouse,Nastaviť cieľový sklad
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} is not in Optional Holiday List,{0} nie je v zozname voliteľný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álov dodaných proti tejto Predajnej objednávke
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}","Vynechanie priradenia štruktúry miezd pre nasledujúcich zamestnancov, pretože záznamy o priradení mzdovej štruktúry už proti nim existujú. {0}"
apps/erpnext/erpnext/config/manufacturing.py,Generate Material Requests (MRP) and Work Orders.,Generovanie žiadostí o materiál (MRP) a pracovných príkazov.
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Set default mode of payment,Nastavte predvolený spôsob platby
DocType: Stock Entry Detail,Against Stock Entry,Proti zásobám
DocType: Grant Application,Withdrawn,uzavretý
DocType: Support Search Source,Support Search Source,Zdroj vyhľadávania podpory
apps/erpnext/erpnext/accounts/report/account_balance/account_balance.js,Chargeble,Chargeble
DocType: Project,Gross Margin %,Hrubá Marža %
DocType: BOM,With Operations,S operacemi
DocType: Support Search Source,Post Route Key List,Pridať zoznam kľúčov
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 účtovníctva už boli vykonané v mene, {0} pre firmu {1}. Vyberte pohľadávky a záväzku účet s menou {0}."
DocType: Asset,Is Existing Asset,Je existujúcemu aktívu
DocType: Salary Component,Statistical Component,Štatistická zlož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 platenia dane
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ávne
DocType: Item,Has Expiry Date,Má dátum skončenia platnosti
apps/erpnext/erpnext/config/support.py,Issue Type.,Typ vydania.
DocType: POS Profile,POS Profile,POS Profile
DocType: Training Event,Event Name,Názov udalosti
DocType: Healthcare Practitioner,Phone (Office),Telefón (Office)
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,"Cannot Submit, Employees left to mark attendance","Nepodarilo sa odoslať, Zamestnanci odišli na označenie účasti"
DocType: Inpatient Record,Admission,vstupné
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Admissions for {0},Prijímacie konanie pre {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áma úspešná synchronizácia kontroly zamestnancov. Obnovte to, iba ak ste si istí, že všetky protokoly sú synchronizované zo všetkých miest. Ak si nie ste niečím istí, neupravujte to."
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,Žiadne hodnoty
DocType: Supplier Scorecard Scoring Variable,Variable Name,Názov premennej
apps/erpnext/erpnext/stock/get_item_details.py,"Item {0} is a template, please select one of its variants","Položka {0} je šablóna, prosím vyberte jednu z jeho variantov"
DocType: Purchase Invoice Item,Deferred Expense,Odložené náklady
apps/erpnext/erpnext/public/js/hub/pages/Messages.vue,Back to Messages,Späť na Sprá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 dátumu {0} nemôže byť pred dátumom spájania zamestnanca {1}
DocType: Purchase Invoice Item,Asset Category,asset Kategórie
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Net pay cannot be negative,Netto plat nemôže byť záporný
DocType: Purchase Order,Advance Paid,Vyplacené zálohy
DocType: Manufacturing Settings,Overproduction Percentage For Sales Order,Percento nadprodukcie pre objednávku predaja
DocType: Item Group,Item Tax,Daň Položky
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material to Supplier,Materiál Dodávateľovi
DocType: Soil Texture,Loamy Sand,Loamy Sand
,Lost Opportunity,Stratená príležitosť
DocType: Accounts Settings,Determine Address Tax Category From,Určite kategóriu dane z adresy
DocType: Production Plan,Material Request Planning,Plánovanie žiadostí o materiál
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Excise Invoice,Spotrebný Faktúra
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Treshold {0}% appears more than once,Prah {0}% sa objaví viac ako raz
DocType: Expense Claim,Employees Email Id,Email ID zamestnanca
DocType: Employee Attendance Tool,Marked Attendance,Výrazná Návštevnosť
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č prekročil daný čas.
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,Pozitívny
DocType: Program,Program Name,Názov programu
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Zvažte daň či poplatek za
DocType: Driver,Driving License Category,Kategória vodičského preukazu
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Actual Qty is mandatory,Skutočné množstvo 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 súčasnosti má postavenie {1} Scorecardu pre dodávateľov a nákupné objednávky tomuto dodávateľovi by mali byť vydané opatrne.
DocType: Asset Maintenance Team,Asset Maintenance Team,Tím na údržbu aktív
apps/erpnext/erpnext/setup/default_success_action.py,{0} has been submitted successfully,{0} bola úspešne odoslaná
DocType: Loan,Loan Type,pôžička Type
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Credit Card,Kreditní karta
DocType: Quality Goal,Quality Goal,Cieľ kvality
DocType: BOM,Item to be manufactured or repacked,Položka být vyráběn nebo znovu zabalena
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in condition: {0},Chyba syntaxe v stave: {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 dodávateľov v nastaveniach nákupu.
DocType: Sales Invoice Item,Drop Ship,Drop Loď
DocType: Driver,Suspended,suspendovaný
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 Dátum ukončenia
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Daně a poplatky odečteny (Company měna)
DocType: Item Group,General Settings,Všeobecné nastavenia
DocType: Article,Article,článok
apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Zadajte 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,Percentuálna zrážka
DocType: GL Entry,To Rename,Premenovať
DocType: Stock Entry,Repack,Přebalit
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select to add Serial Number.,"Vyberte, ak chcete pridať sériové číslo."
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the customer '%s',"Prosím, nastavte daňový kód pre zákazníka &#39;% s&#39;"
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select the Company first,Najskôr vyberte spoločnosť
DocType: Item Attribute,Numeric Values,Číselné hodnoty
apps/erpnext/erpnext/public/js/setup_wizard.js,Attach Logo,Pripojiť Logo
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Levels,Úrovne zásob
DocType: Customer,Commission Rate,Výška provízie
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Successfully created payment entries,Úspešne vytvorené položky platieb
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Created {0} scorecards for {1} between: ,Vytvorili {0} scorecards pre {1} medzi:
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.py,Not permitted. Please disable the Procedure Template,Nepovolené. Zakážte šablónu postupu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,"Payment Type must be one of Receive, Pay and Internal Transfer",Typ platby musí byť jedným z príjem Pay a interný prevod
DocType: Travel Itinerary,Preferred Area for Lodging,Preferovaná oblasť ubytovania
apps/erpnext/erpnext/config/agriculture.py,Analytics,analytika
DocType: Salary Detail,Additional Amount,Dodatočná suma
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html,Cart is Empty,Košík je prázdny
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} neobsahuje žiadne sériové číslo. Serializované položky \ môžu mať dodávku na základe poradového čísla
DocType: Vehicle,Model,Modelka
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čítať na základe 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,merné jednotky
DocType: Employee Tax Exemption Declaration,Rented in Metro City,Prenajaté v Metro City
DocType: Supplier,Default Tax Withholding Config,Predvolená kont
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,Kapitál Zásoby
DocType: Asset,Default Finance Book,Predvolená kniha financií
DocType: Shopping Cart Settings,Show Public Attachments,Zobraziť verejné prílohy
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Edit Publishing Details,Upraviť podrobnosti o publikovaní
DocType: Packing Slip,Package Weight Details,Detail hmotnosti zásielky
DocType: Leave Type,Is Compensatory,Je kompenzačný
DocType: Restaurant Reservation,Reservation Time,Čas rezervácie
DocType: Payment Gateway Account,Payment Gateway Account,Platobná brána účet
DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Po dokončení platby presmerovať užívateľa na vybrané stránky.
DocType: Company,Existing Company,existujúce Company
DocType: Healthcare Settings,Result Emailed,Výsledok bol odoslaný e-mailom
DocType: Item Tax Template Detail,Item Tax Template Detail,Detail šablóny dane z položky
apps/erpnext/erpnext/controllers/buying_controller.py,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Daňová kategória bola zmenená na &quot;Celkom&quot;, pretože všetky položky sú položky, ktoré nie sú na sklade"
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 dňu nemôže byť rovnaká alebo menšia ako od dátumu
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Nothing to change,Nič sa nemenia
apps/erpnext/erpnext/crm/doctype/lead/lead.py,A Lead requires either a person's name or an organization's name,Vedúci vyžaduje meno osoby alebo meno organizácie
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 niektorých riadkoch
DocType: Holiday List,Total Holidays,Celkové prázdniny
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Missing email template for dispatch. Please set one in Delivery Settings.,Chýba šablóna e-mailu na odoslanie. Prosím nastavte jednu z možností Delivery Settings.
DocType: Student Leave Application,Mark as Present,Označiť ako prítomný
DocType: Supplier Scorecard,Indicator Color,Farba indikátora
DocType: Purchase Order,To Receive and Bill,Prijímať a Bill
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Reqd by Date cannot be before Transaction Date,Riadok # {0}: Reqd by Date nemôže byť pred dátumom transakcie
DocType: Asset Maintenance,Select Serial No,Vyberte položku Sériové číslo
DocType: Pricing Rule,Is Cumulative,Je kumulatívne
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Designer,Návrhár
apps/erpnext/erpnext/config/accounts.py,Terms and Conditions Template,Podmínky Template
DocType: Delivery Trip,Delivery Details,Detaily dodania
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js,Please fill in all the details to generate Assessment Result.,"Vyplňte všetky podrobnosti, aby ste vygenerovali výsledok hodnotenia."
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,podmienky nápovedy
,Item-wise Purchase Register,Item-moudrý Nákup Register
DocType: Loyalty Point Entry,Expiry Date,Datum vypršení platnosti
DocType: Healthcare Settings,Employee name and designation in print,Meno a označenie zamestnanca v tlači
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,Zmluvné podmienky
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Continue Configuration,Pokračovať v konfigurácii
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Neukazovať žiadny symbol ako $ atď vedľa meny.
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Maximum benefit amount of component {0} exceeds {1},Maximálna výška dávky komponentu {0} presahuje {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py, (Half Day),(Pól dňa)
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Master Data,Spracovať kmeňové dáta
DocType: Payment Term,Credit Days,Úverové dni
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Please select Patient to get Lab Tests,"Ak chcete získať laboratórne testy, vyberte položku Pacient"
DocType: Exotel Settings,Exotel Settings,Nastavenia 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 ktorou je označená neprítomnosť. (Nulovanie na deaktiváciu)"
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Send a message,Poslať správu
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Get Items from BOM,Získat předměty z BOM
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Lead Time Days,Vek Obchodnej iniciatívy v dňoch
DocType: Cash Flow Mapping,Is Income Tax Expense,Daň z príjmov
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Your order is out for delivery!,Vaša objednávka je k dispozícii!
DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,"Skontrolujte, či študent býva v hosteli inštitútu."
DocType: Course,Hero Image,Obrázok hrdiny
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Sales Orders in the above table,"Prosím, zadajte Predajné objednávky v tabuľke vyššie"
,Stock Summary,Sumár zásob
apps/erpnext/erpnext/config/assets.py,Transfer an asset from one warehouse to another,Previesť aktíva z jedného skladu do druhého
DocType: Vehicle,Petrol,benzín
DocType: Employee Benefit Application,Remaining Benefits (Yearly),Zvyšné výhody (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čiatku začatia zmeny, keď sa nahlásenie považuje za oneskorené (v minútach)."
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Riadok {0}: Typ Party Party a je nutné pre pohľadávky / záväzky na účte {1}
DocType: Employee,Leave Policy,Opustiť pravidlá
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update Items,Aktualizovať 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 priepustky
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,View call log,Zobraziť denník hovorov
DocType: BOM Operation,Operating Cost(Company Currency),Prevádzkové náklady (Company mena)
DocType: Loan Application,Rate of Interest,Úroková sadzba
DocType: Expense Claim Detail,Sanctioned Amount,Sankcionovaná čiastka
DocType: Item,Shelf Life In Days,Životnosť počas dní
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 nasledujúcich {0} dňoch nie je možné nájsť časový interval operácie {1}.
DocType: Department,Expense Approvers,Sprostredkovatelia výdavkov
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,Sekcia odberu
apps/erpnext/erpnext/controllers/buying_controller.py,{0} Asset{2} Created for <b>{1}</b>,{0} Aktíva {2} Vytvorené pre <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éningový program
DocType: Account,Cash,V hotovosti
DocType: Sales Invoice,Unpaid and Discounted,Nezaplatené a diskontované
DocType: Employee,Short biography for website and other publications.,Krátký životopis na internetové stránky a dalších publikací.
