apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Pension Funds,Penzijné fondy
DocType: Supplier Quotation,Rounding Adjustment (Company Currency,Úprava zaokrúhľovania (mena spoločnosti
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Course is mandatory in row {0},Kurz je povinný v riadku {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Credit Account,Úverový účet
DocType: Employee Tax Exemption Proof Submission,Submission Date,Dátum predloženia
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Template Code,Zmena kódu šablóny
DocType: Expense Claim,Total Sanctioned Amount,Celková výška sankcie
apps/erpnext/erpnext/accounts/doctype/accounting_period/accounting_period.py,Accounting Period overlaps with {0},Účtovné obdobie sa prekrýva s {0}
DocType: Email Digest,New Expenses,Nové náklady
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Healthcare Practitioner not available on {0},Lekár nie je k dispozícii na {0}
DocType: Delivery Note,Transport Receipt No,Dopravný doklad č
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Administrative Officer,administratívny pracovník
DocType: Opportunity,Probability (%),Pravdepodobnosť (%)
DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,WooCommerce Products,Produkty WooCommerce
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Account Pay Only,Platiť iba za účet
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Cess,Cess
apps/erpnext/erpnext/config/settings.py,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Nastaviť predvolené hodnoty ako spoločnosť, mena, aktuálny fiškálny rok atď."
apps/erpnext/erpnext/config/projects.py,Time Tracking,Sledovanie času
DocType: Employee Education,Under Graduate,V časti Absolvent
DocType: Request for Quotation Item,Supplier Part No,Č
DocType: Journal Entry Account,Party Balance,Party Balance
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Source of Funds (Liabilities),Zdroj finančných prostriedkov (pasíva)
DocType: Payroll Period,Taxable Salary Slabs,Zdaniteľné platové tabuľky
DocType: Quality Action,Quality Feedback,Spätná väzba kvality
DocType: Support Settings,Support Settings,Nastavenia podpory
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Please enter Production Item first,Najprv zadajte Výrobnú položku
DocType: Quiz,Grading Basis,Triedenie Základ
DocType: Stock Entry Detail,Basic Amount,Základná čiastka
DocType: Journal Entry,Pay To / Recd From,Zaplatiť do / Recd Od
DocType: BOM,Scrap Material Cost,Náklady na šrot
DocType: Material Request Item,Received Quantity,Prijaté množstvo
,Sales Person-wise Transaction Summary,Zhrnutie transakcie s predajcami
DocType: Communication Medium,Voice,hlas
DocType: Work Order,Actual Operating Cost,Skutočné prevádzkové náklady
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html,Mode of Payments,Spôsob platby
DocType: Stock Entry,Send to Subcontractor,Odoslať subdodávateľovi
DocType: Purchase Invoice,Select Shipping Address,Vyberte Prepravnú adresu
DocType: Student,AB-,AB
apps/erpnext/erpnext/projects/doctype/project/project.py,Project Summary for {0},Zhrnutie projektu pre {0}
apps/erpnext/erpnext/regional/india/bank_remittance.py,"{0} is mandatory for generating remittance payments, set the field and try again","{0} je povinné pre generovanie platieb, nastavte pole a skúste to znova"
apps/erpnext/erpnext/public/js/hub/marketplace.js,Some emails are invalid,Niektoré e-maily sú neplatné
DocType: Asset,Calculate Depreciation,Vypočítať odpisy
DocType: Academic Term,Term Name,Termín Názov
DocType: Question,Question,otázka
DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Podkategória výnimiek
apps/erpnext/erpnext/www/all-products/item_row.html,More Details,Viac informácií
DocType: Salary Component,Earning,zarábať
DocType: Restaurant Order Entry,Click Enter To Add,Kliknite na položku Enter To Add
DocType: Communication Medium Timeslot,Employee Group,Zamestnanecká skupina
DocType: Quality Procedure,Processes,Procesy
DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Zadajte výmenný kurz na konverziu jednej meny na inú
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 4,Rozsah starnutia 4
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Warehouse required for stock Item {0},Sklad je potrebný na sklade Položka {0}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Could not solve criteria score function for {0}. Make sure the formula is valid.,"Nepodarilo sa vyriešiť funkciu skóre kritérií pre {0}. Uistite sa, že vzorec je platný."
DocType: Bank Reconciliation,Include Reconciled Entries,Zahrnúť zladené položky
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Povoliť sadzbu nulového ocenenia
apps/erpnext/erpnext/templates/includes/product_list.js,Nothing more to show.,Nič viac ukázať.
apps/erpnext/erpnext/controllers/buying_controller.py,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Kategória dane bola zmenená na &quot;Celkom&quot;, pretože všetky položky sú položky, ktoré nie sú skladom"
DocType: Salary Detail,Tax on flexible benefit,Daň z flexibilného požitku
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py,This is based on the Time Sheets created against this project,Toto je založené na časových výkazoch vytvorených proti tomuto projektu
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Rate,Nákupná sadzba
DocType: Water Analysis,Type of Sample,Typ vzorky
DocType: Budget,Budget Accounts,Rozpočtové účty
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} quantity {1} cannot be a fraction,Sériové číslo {0} množstvo {1} nemôže byť zlomok
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock In Hand,Skladom V Ruke
DocType: Workstation,Wages,mzda
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,No leave record found for employee {0} for {1},Pre zamestnanca {0} sa nenašli žiadne záznamy o dovolenke pre {1}
DocType: Invoice Discounting,Accounts Receivable Unpaid Account,Účtovanie pohľadávok Nesplatený účet
DocType: GST Account,SGST Account,Účet SGST
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Polovičný dátum by mal byť medzi prácou od dátumu a dátumom ukončenia práce
DocType: Employee Boarding Activity,Applicable in the case of Employee Onboarding,Uplatniteľné v prípade palubného zamestnanca
apps/erpnext/erpnext/controllers/buying_controller.py,Specified BOM {0} does not exist for Item {1},Zadaná kusovník {0} neexistuje pre položku {1}
apps/erpnext/erpnext/config/accounting.py,Company (not Customer or Supplier) master.,Kapitán spoločnosti (nie zákazník alebo dodávateľ).
DocType: Shopify Settings,Sales Invoice Series,Séria predajných faktúr
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Asset Movement record {0} created,Vytvoril sa záznam pohybu aktív {0}
DocType: Lab Prescription,Test Created,Vytvorený test
DocType: Communication Medium,Catch All,Catch All
DocType: Academic Term,Term Start Date,Termín Dátum začiatku
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Appointment {0} and Sales Invoice {1} cancelled,Schôdzka {0} a predajná faktúra {1} boli zrušené
DocType: Purchase Receipt,Vehicle Number,Číslo vozidla
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Your email address...,Vaša emailová adresa...
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js,Include Default Book Entries,Zahrnúť predvolené položky knihy
DocType: Activity Cost,Activity Type,Typ aktivity
DocType: Purchase Invoice,Get Advances Paid,Zaplatené zálohy
DocType: Company,Gain/Loss Account on Asset Disposal,Zisk / strata na likvidácii majetku
DocType: GL Entry,Voucher No,Poukážka č
DocType: Item,Reorder level based on Warehouse,Úroveň poradia na základe skladu
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel",Zastavený pracovný príkaz nie je možné zrušiť
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: Customer,Customer Primary Contact,Primárny kontakt zákazníka
DocType: Purchase Order Item Supplied,BOM Detail No,Detail kusovníka č
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Cash In Hand,Hotovosť v ruke
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py,The holiday on {0} is not between From Date and To Date,Dovolenka na hodnote {0} nie je medzi dátumom a dátumom
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction can not be converted to group.,Účet s existujúcou transakciou nemožno konvertovať na skupinu.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Timesheet {0} is already completed or cancelled,Časový rozvrh {0} je už dokončený alebo zrušený
DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.

Examples:

1. Validity of the offer.
1. Payment Terms (In Advance, On Credit, part advance etc).
1. What is extra (or payable by the Customer).
1. Safety / usage warning.
1. Warranty if any.
1. Returns Policy.
1. Terms of shipping, if applicable.
1. Ways of addressing disputes, indemnity, liability, etc.
1. Address and Contact of your Company.","Štandardné zmluvné podmienky, ktoré môžu byť pridané do predaja a nákupu. Príklady: 1. Platnosť ponuky. 1. Platobné podmienky (V Advance, On Credit, čiastočný záloh atď.). 1. Čo je navyše (alebo splatné zákazníkom). 1. Varovanie o bezpečnosti / používaní. 1. Záruka, ak existuje. 1. Vracia politiku. 1. Podmienky prepravy, ak sa uplatňujú. 1. Spôsoby riešenia sporov, odškodnenia, zodpovednosti atď. 1. Adresa a kontakt Vašej spoločnosti."
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Status Notification,Opustiť oznámenie o stave
DocType: Designation Skill,Designation Skill,Označenie Skill
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Množstvo požadované pre položku {0} v riadku {1}
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 Strany, vyberte najprv Typ strany"
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,No Salary Structure assigned for Employee {0} on given date {1},Žiadna štruktúra miezd pridelená zamestnancovi {0} k danému dátumu {1}
DocType: Prescription Duration,Number,číslo
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Samostatná skupina založená na kurze pre každú dávku
DocType: Healthcare Settings,Require Lab Test Approval,Vyžadovať schválenie laboratórneho testu
DocType: Bank Reconciliation,Update Clearance Date,Dátum aktualizácie
DocType: Chart of Accounts Importer,Import Chart of Accounts from a csv file,Importovať graf účtov zo súboru csv
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py,"Support for public app is deprecated. Please setup private app, for more details refer user manual","Podpora pre verejné aplikácie je zastaraná. Prosím, nastavte súkromnú aplikáciu, viac informácií nájdete v užívateľskej príručke"
DocType: Contract,Signed,podpísaný
DocType: Purchase Invoice,Terms and Conditions1,Zmluvné podmienky1
apps/erpnext/erpnext/hr/doctype/department_approver/department_approver.py,Please select Employee Record first.,Najskôr vyberte Zamestnanecký záznam.
apps/erpnext/erpnext/hr/doctype/hr_settings/hr_settings.py,Password policy for Salary Slips is not set,Politika hesiel pre výplaty platov nie je nastavená
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() failed for valid IBAN {},BankAccount.validate_iban () sa nepodarilo pre platný IBAN {}
DocType: Assessment Result Tool,Result HTML,Výsledok HTML
DocType: Agriculture Task,Ignore holidays,Ignorovať sviatky
DocType: Linked Soil Texture,Linked Soil Texture,Textúra prepojenej pôdy
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py,This is based on logs against this Vehicle. See timeline below for details,Toto je založené na guľatinách proti tomuto vozidlu. Podrobnosti nájdete v časovej osi nižšie
DocType: Payment Entry,ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-
DocType: Employee,Emergency Contact,Núdzový kontakt
DocType: QuickBooks Migrator,Authorization URL,Autorizačná adresa URL
DocType: Attendance,On Leave,Na odchode
DocType: Item,Show a slideshow at the top of the page,Zobraziť prezentáciu v hornej časti stránky
DocType: Cheque Print Template,Payer Settings,Nastavenia platiteľa
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Set Tax Rule for shopping cart,Nastaviť daňové pravidlo pre nákupný košík
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,In Production,Vo výrobe
DocType: Payment Entry,Payment References,Referencie platby
DocType: Fee Validity,Valid Till,Platný do
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0}: From {0} of type {1},{0}: Od {0} typu {1}
DocType: Request for Quotation Item,Project Name,Názov projektu
DocType: Purchase Invoice Item,Stock Qty,Sklad
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Položka pre dieťa by nemala byť balíkom produktov. Odstráňte položku „{0}“ a uložte ju
DocType: Support Search Source,Response Result Key Path,Cesta kľúča výsledku odpovede
DocType: Travel Request,Fully Sponsored,Plne Sponzorované
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py,Not permitted. Please disable the Service Unit Type,Nepovolené. Vypnite typ servisnej jednotky
DocType: POS Profile,Offline POS Settings,Nastavenia offline POS
DocType: Supplier Scorecard Period,Calculations,výpočty
DocType: Production Plan,Material Requested,Požadovaný materiál
DocType: Payment Reconciliation Payment,Reference Row,Referenčný riadok
DocType: Leave Policy Detail,Annual Allocation,Ročné pridelenie
DocType: Buying Settings,Subcontract,subdodávka
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Valuation type charges can not marked as Inclusive,Poplatky typu oceňovania nie je možné označiť ako inkluzívne
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} does not belong to company: {2},Účet {0}: Rodičovský účet {1} nepatrí spoločnosti: {2}
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Nepodarilo sa prihlásiť
apps/erpnext/erpnext/config/buying.py,Items and Pricing,Položky a ceny
DocType: Payment Terms Template,Payment Terms Template,Šablóna platobných podmienok
DocType: Employee,Previous Work Experience,Predchádzajúce pracovné skúsenosti
DocType: Assessment Plan,Program,Program
DocType: Antibiotic,Healthcare,Zdravotná starostlivosť
DocType: Complaint,Complaint,sťažnosť
DocType: Shipping Rule,Restrict to Countries,Obmedziť na krajiny
DocType: Hub Tracked Item,Item Manager,Správca položiek
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/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Budgets,rozpočty
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Opening Invoice Item,Položka otvorenia faktúry
DocType: Work Order,Plan material for sub-assemblies,Plán materiálu pre podzostavy
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Hardware,technické vybavenie
DocType: Budget,Action if Annual Budget Exceeded on MR,"Činnosť, ak ročný rozpočet presiahol MR"
DocType: Sales Invoice Advance,Advance Amount,Výška preddavku
DocType: Accounting Dimension,Dimension Name,Názov dimenzie
DocType: Delivery Note Item,Against Sales Invoice Item,Proti položke predajnej faktúry
DocType: Expense Claim,HR-EXP-.YYYY.-,HR-EXP-.YYYY.-
DocType: BOM Explosion Item,Include Item In Manufacturing,Zahrnúť položku do výroby
DocType: Item Reorder,Check in (group),Registrácia (skupina)
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Nezobrazovať žiadny symbol ako $ atď vedľa mien.
DocType: Additional Salary,Salary Component Type,Typ mzdového komponentu
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shareholder does not belong to this company,Akcionár nepatrí do tejto spoločnosti
DocType: Payment Term,Day(s) after the end of the invoice month,Deň (dni) po skončení fakturačného mesiaca
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Vehicle Type,Typ vozidla
DocType: Antibiotic,Healthcare Administrator,Správca zdravotníctva
DocType: Tax Withholding Rate,Single Transaction Threshold,Jediný prah transakcie
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Broadcasting,vysielania
DocType: Support Search Source,Post Title Key,Kľúč názvu príspevku
DocType: Customer,Customer Primary Address,Primárna adresa zákazníka
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select batches for batched item ,Vyberte dávky pre dávkovú položku
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Are you sure you want to make credit note?,Naozaj chcete vykonať dobropis?
DocType: Pricing Rule,Min Qty,Min
DocType: Payment Entry,Payment Deductions or Loss,Zrážky platieb alebo straty
DocType: Purchase Taxes and Charges,On Item Quantity,Na položke Množstvo
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/accounts/doctype/subscription/subscription.py,Both Trial Period Start Date and Trial Period End Date must be set,Musí sa nastaviť dátum začiatku skúšobného obdobia aj dátum ukončenia skúšobného obdobia
apps/erpnext/erpnext/templates/pages/projects.html,No time sheets,Žiadne časové výkazy
DocType: Bank Statement Settings,Statement Header Mapping,Mapovanie hlavičky výpisu
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Half Day,Mark Half Day
DocType: Stock Entry,Material Transfer for Manufacture,Prenos materiálu na výrobu
DocType: Supplier,Block Supplier,Blokovať dodávateľa
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter Woocommerce Server URL,Zadajte adresu URL servera Woocommerce
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Place,Z miesta
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,No contacts with email IDs found.,Nenašli sa žiadne kontakty s identifikátormi e-mailov.
DocType: Clinical Procedure,Consumption Invoiced,Spotreba fakturovaná
DocType: Bin,Requested Quantity,Požadované množstvo
DocType: Student,Exit,Východ
DocType: Delivery Stop,Dispatch Information,Informácie o odoslaní
DocType: BOM Scrap Item,Basic Amount (Company Currency),Základná čiastka (mena spoločnosti)
DocType: Selling Settings,Selling Settings,Predajné nastavenia
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/hr/doctype/salary_slip/salary_slip.py,Please set the Date Of Joining for employee {0},"Prosím, nastavte Dátum vstupu pre zamestnanca {0}"
apps/erpnext/erpnext/public/js/hub/components/profile_dialog.js,About your company,O vašej spoločnosti
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} does not exist,Fiškálny rok {0} neexistuje
DocType: Sales Invoice,Unpaid and Discounted,Neplatené a Zľavnené
DocType: Attendance,Leave Application,Opustiť aplikáciu
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Maintenance Log,Protokol údržby
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid Posting Time,Neplatný čas účtovania
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Discount,zľava
DocType: Sales Invoice,Redeem Loyalty Points,Uplatniť vernostné body
DocType: Shopping Cart Settings,Quotation Series,Séria ponuky
DocType: Guardian,Occupation,povolania
DocType: Item,Opening Stock,Otvorenie skladu
DocType: Supplier Scorecard,Supplier Score,Skóre dodávateľa
DocType: POS Profile,Only show Items from these Item Groups,Zobraziť iba položky z týchto skupín položiek
DocType: Sales Invoice,Overdue and Discounted,Omeškané a Zľavnené
DocType: Job Card Time Log,Time In Mins,Čas v minách
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Item {0} does not exist in the system or has expired,Položka {0} neexistuje v systéme alebo uplynula platnosť
DocType: Pricing Rule,Price Discount Scheme,Cenová zľava Schéma
DocType: Vital Signs,Hyper,hyper
apps/erpnext/erpnext/public/js/setup_wizard.js,What does it do?,Čo to robí?
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Summary Saved,Uložené súhrnné hovory
,Sales Invoice Trends,Trendy predajnej faktúry
DocType: Bank Reconciliation,Payment Entries,Platobné položky
DocType: Employee Education,Class / Percentage,Trieda / percento
,Electronic Invoice Register,Elektronický register faktúr
DocType: Shift Type,The number of occurrence after which the consequence is executed.,"Počet výskytov, po ktorých je dôsledok vykonaný."
DocType: Sales Invoice,Is Return (Credit Note),Je návrat (kreditná poznámka)
DocType: Price List,Price Not UOM Dependent,Cena nie je závislá od UOM
DocType: Lab Test Sample,Lab Test Sample,Vzorka laboratórneho testu
DocType: Shopify Settings,status html,status html
DocType: Fiscal Year,"For e.g. 2012, 2012-13","Napríklad 2012, 2012-13"
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,disabled user,postihnutého používateľa
DocType: Amazon MWS Settings,ES,ES
DocType: Warehouse,Warehouse Type,Typ skladu
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Quick Journal Entry,Rýchly zápis do denníka
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Spotrebovaná čiastka
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Already completed,Dokončené
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Pending Amount,Čakajúca suma
DocType: Supplier,Warn RFQs,Upozorniť na RFQ
DocType: Lab Prescription,Lab Prescription,Lekársky predpis
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Riadok odpisu {0}: Ďalší dátum odpisu nemôže byť pred dátumom použiteľnosti
DocType: Certification Application,USD,Americký dolár
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,"Asset {0} cannot be scrapped, as it is already {1}","Asset {0} nie je možné vyradiť, pretože je už {1}"
DocType: Delivery Trip,Departure Time,Čas odchodu
DocType: Donor,Donor Type,Typ darcu
DocType: Company,Monthly Sales Target,Mesačný predajný cieľ
DocType: Loyalty Point Entry Redemption,Redemption Date,Dátum spätného odkúpenia
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Approving User cannot be same as user the rule is Applicable To,Schválenie Užívateľ nemôže byť rovnaký ako používateľ
DocType: Fee Schedule Student Group,Fee Schedule Student Group,Študentská skupina Poplatok
apps/erpnext/erpnext/projects/report/billing_summary.py, From Date can not be greater than To Date,Od Dátum nemôže byť väčší ako Dátum
apps/erpnext/erpnext/public/js/queries.js,Please specify a {0},Zadajte číslo {0}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To GSTIN,Na GSTIN
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Dátum ukončenia lehoty nemôže byť skorší ako dátum začiatku dátumu. Opravte dátumy a skúste to znova.
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,No Employee Found,Nenašiel sa žiadny zamestnanec
DocType: Employee Tax Exemption Declaration Category,Exemption Category,Kategória výnimky
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Disbursement Entry,Vytvorenie vstupu platby
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Purpose must be one of {0},Účelom musí byť {0}
DocType: Content Activity,Last Activity ,Posledná aktivita
DocType: Crop Cycle,A link to all the Locations in which the Crop is growing,"Odkaz na všetky miesta, v ktorých rastie"
apps/erpnext/erpnext/education/doctype/course_activity/course_activity.py,Course Enrollment {0} does not exists,Zápis kurzu {0} neexistuje
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}
,Qty to Transfer,Množstvo na prenos
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please identify/create Account (Group) for type - {0},Identifikujte / vytvorte účet (skupina) pre typ - {0}
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 časti Nastavenia predaja
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 žiadny variant položky
DocType: Contract,Contract Details,Podrobnosti zmluvy
DocType: Customer,"Select, to make the customer searchable with these fields","Vyberte, ak chcete, aby zákazník prehľadával tieto polia"
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Actual,Skutočné
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Code,Zmeniť kód
DocType: Crop,Planting Area,Plocha výsadby
DocType: Leave Control Panel,Employee Grade (optional),Zamestnanecký stupeň (voliteľné)
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Cost Center For Item with Item Code ',Nákladové stredisko pre položku s kódom položky
DocType: Stock Settings,Default Stock UOM,Predvolené skladom UOM
DocType: Workstation,Rent Cost,Náklady na prenájom
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Result,Výsledok tréningu
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order not created,Pracovný príkaz nebol vytvorený
apps/erpnext/erpnext/utilities/user_progress.py,Meter,meter
DocType: Course,Hero Image,Obrázok hrdinu
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,No Items to pack,Žiadne položky na balenie
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Delivery warehouse required for stock item {0},Pre skladovú položku {0} je potrebný sklad dodávky.
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 dodaných surovinách
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Target Location is required for the asset {0},Cieľová poloha je vyžadovaná pre aktívum {0}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,SGST Amount,SGST Suma
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Zostatok na účte už v kredite, nie je povolené nastaviť &#39;Zostatok musí byť&#39; ako &#39;Debet&#39;"
DocType: GSTR 3B Report,GSTR 3B Report,Správa GSTR 3B
DocType: BOM Item,Rate & Amount,Sadzba a čiastka
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To is required,Vyžaduje sa debet
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Item Name,Názov položky
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of New Purchase,Náklady na nový nákup
DocType: Customer,Additional information regarding the customer.,Ďalšie informácie o zákazníkovi.
DocType: Quiz Result,Wrong,zle
apps/erpnext/erpnext/config/help.py,Batch Inventory,Dávková inventúra
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Unable to find Salary Component {0},Nepodarilo sa nájsť komponent mzdy {0}
DocType: HR Settings,"The salary slip emailed to the employee will be password protected, the password will be generated based on the password policy.","Platový lístok zaslaný zamestnancovi bude chránený heslom, heslo bude vygenerované na základe politiky hesiel."
DocType: Payment Entry,Received Amount,Prijatá čiastka
DocType: Item,Is Sales Item,Je predajná položka
apps/erpnext/erpnext/accounts/doctype/payment_order/regional/india.js,Generate Text File,Generovanie textového súboru
DocType: Item,Variants,varianty
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Poplatky budú rozdelené proporcionálne na základe položky qty alebo sumy, podľa vášho výberu"
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Pending activities for today,V súčasnosti prebiehajúce aktivity
DocType: Quality Procedure Process,Quality Procedure Process,Proces kvality
DocType: Fee Schedule Program,Student Batch,Študentská dávka
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Valuation Rate required for Item in row {0},Miera ocenenia požadovaná pre položku v riadku {0}
DocType: BOM Operation,Base Hour Rate(Company Currency),Základná hodinová sadzba (mena spoločnosti)
apps/erpnext/erpnext/education/doctype/question/question.py,No correct answer is set for {0},Pre {0} nie je nastavená správna odpoveď
DocType: Job Offer,Printing Details,Podrobnosti o tlači
DocType: Asset Repair,Manufacturing Manager,Manažér výroby
DocType: BOM,Job Card,Karta zamestnania
DocType: Subscription Settings,Prorate,kľúčovanie
DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","ID užívateľa systému (login). Ak je nastavené, stane sa predvoleným pre všetky formuláre HR."
apps/erpnext/erpnext/public/js/pos/pos.html,All Item Groups,Všetky skupiny položiek
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Status,Vyberte položku Stav
DocType: Subscription Plan,Fixed rate,Pevne stanovena sadzba
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Airline,letecká linka
DocType: Quotation,Term Details,Termín Podrobnosti
DocType: Vehicle,Acquisition Date,Dátum nadobudnutia
DocType: SMS Center,Send To,Poslať
apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py,Average Rate,Priemerná hodnota
DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Nastavte počet v transakciách na základe sériového vstupu
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Advance account currency should be same as company currency {0},Mena preddavkového účtu by mala byť rovnaká ako mena spoločnosti {0}
apps/erpnext/erpnext/portal/doctype/homepage/homepage.js,Customize Homepage Sections,Prispôsobte sekcie domovskej stránky
apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Prosím nastavte inštruktor pomenovania systému vo vzdelávaní&gt; Nastavenia vzdelávania
DocType: GSTR 3B Report,October,október
DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Skryť daňové identifikačné číslo zákazníka z predajných transakcií
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! A GSTIN must have 15 characters.,Neplatný GSTIN! GSTIN musí mať 15 znakov.
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Pricing Rule {0} is updated,Pravidlo určovania cien {0} sa aktualizuje
DocType: Contract Fulfilment Checklist,Contract Fulfilment Checklist,Kontrolný zoznam plnenia zmluvy
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py,All Products,Všetky produkty
apps/erpnext/erpnext/www/all-products/index.html,Product Search,Vyhľadávanie produktov
DocType: Salary Slip,Net Pay,Čistý plat
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,{0} bank transaction(s) created and {1} errors,{0} vytvorených bankových transakcií a {1} chýb
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py,Total Invoiced Amt,Celkový fakturovaný Amt
DocType: Clinical Procedure,Consumables Invoice Separately,Faktúra spotrebného materiálu samostatne
DocType: Shift Type,Working Hours Threshold for Absent,Prahová hodnota pracovnej doby pre neprítomnosť
DocType: Appraisal,HR-APR-.YY.-.MM.,HR-APR-.YY.-.MM.
apps/erpnext/erpnext/support/doctype/issue/issue.py,Service Level Agreement has been changed to {0}.,Zmluva o úrovni služieb bola zmenená na {0}.
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Budget cannot be assigned against Group Account {0},Rozpočet nie je možné priradiť ku kontu skupiny {0}
DocType: Purchase Receipt Item,Rate and Amount,Sadzba a výška
DocType: Patient Appointment,Check availability,Skontrolovať dostupnosť
apps/erpnext/erpnext/public/js/controllers/transaction.js,Cannot find Item with this barcode,Položka s týmto čiarovým kódom sa nedá nájsť
DocType: Hotel Settings,Default Invoice Naming Series,Predvolená séria názvov faktúr
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žstiev položky <b>{2}</b> , bude na položku použitá schéma <b>{3}</b> ."
DocType: Student Siblings,Student Siblings,Študenti súrodenci
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Journal Entry {0} does not have account {1} or already matched against other voucher,Položka žurnálu {0} nemá účet {1} alebo už nie je priradená k inému poukazu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Právne výdavky
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html,Checkout,Odhlásiť sa
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Membership Details,Podrobnosti o členstve
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Customer Address,Nastavte adresu zákazníka
apps/erpnext/erpnext/utilities/user_progress.py,List your products or services that you buy or sell.,"Uveďte zoznam svojich produktov alebo služieb, ktoré kupujete alebo predávate."
DocType: Account,Income,príjem
DocType: Account,Rate at which this tax is applied,"Sadzba, za ktorú sa táto daň uplatňuje"
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Payment Receipt Note,Poznámka o prijatí platby
DocType: Asset Finance Book,In Percentage,V percentách
apps/erpnext/erpnext/config/buying.py,Quotations received from Suppliers.,Citácie od dodávateľov.
DocType: Journal Entry Account,Reference Due Date,Dátum splatnosti referencie
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Lead Time Days,Dni dodacích lehôt
DocType: Quality Goal,Revision and Revised On,Revízia a revízia dňa
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Purchase Order {1},{0} proti objednávke {1}
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py,Fee Records Created - {0},Vytvorené záznamy o poplatkoch - {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Note: {0},Poznámka: {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} has already been received,Sériové číslo {0} už bolo prijaté
DocType: HR Settings,Leave Settings,Ponechajte nastavenia
DocType: Delivery Note,Issue Credit Note,Poznámka k emisii
,Batch Item Expiry Status,Stav vypršania položky dávky
apps/erpnext/erpnext/config/stock.py,Stock Transactions,Transakcie na burze
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html,Event Location,Miesto konania
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Motion Picture & Video,Film a video
DocType: Crop,Row Spacing,Riadkovanie
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 správnu schému účtov."
DocType: Cheque Print Template,Starting location from left edge,Počiatočná poloha od ľavého okraja
DocType: HR Settings,HR Settings,HR nastavenia
DocType: Healthcare Practitioner,Appointments,schôdzky
apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Bola vytvorená položka {0}
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Planned Qty for Item {0} at row {1},Zadajte plánovaný počet pre položku {0} v riadku {1}
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch,Vyberte položku Batch
DocType: BOM,Item Description,popis položky
DocType: Account,Account Name,Názov účtu
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Key,Zadajte používateľský kľúč rozhrania API
DocType: Products Settings,Products per Page,Produkty na stránku
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Duplicate {0} found in the table,Duplikát {0} sa nachádza v tabuľke
DocType: Global Defaults,Default Distance Unit,Predvolená jednotka vzdialenosti
DocType: Clinical Procedure,Consume Stock,Spotrebujte zásoby
DocType: Appraisal Template Goal,Key Performance Area,Kľúčová oblasť výkonu
apps/erpnext/erpnext/selling/report/pending_so_items_for_purchase_request/pending_so_items_for_purchase_request.py,S.O. No.,SO No.
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,{0} not found for item {1},{0} pre položku {1} sa nenašlo
DocType: Sales Invoice,Set Source Warehouse,Nastaviť zdrojový sklad
DocType: Healthcare Settings,Out Patient Settings,Out Patient Settings (Nastavenia pacienta)
DocType: Asset,Insurance End Date,Dátum ukončenia poistenia
DocType: Bank Account,Branch Code,Kód pobočky
apps/erpnext/erpnext/public/js/conf.js,User Forum,Užívateľské fórum
DocType: Landed Cost Item,Landed Cost Item,Položka nákladových nákladov
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ť tí istí
DocType: Project,Copied From,Kopírované z
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Available,k dispozícii
DocType: Sales Person,Sales Person Targets,Ciele predajnej osoby
DocType: BOM Operation,BOM Operation,Prevádzka kusovníka
DocType: Student,O-,O-
DocType: Repayment Schedule,Interest Amount,Úroková čiastka
DocType: Water Analysis,Origin,pôvod
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Add a new address,Pridajte novú adresu
DocType: POS Profile,Write Off Account,Odpísať účet
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal/Price Quote,Návrh / cenová ponuka
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Associate,spolupracovník
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Please input all required Result Value(s),Zadajte všetky požadované hodnoty výsledkov
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Dodaná položka objednávky
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Item {0} is not a serialized Item,Položka {0} nie je serializovaná položka
DocType: GoCardless Mandate,GoCardless Customer,Zákazník GoCardless
DocType: Leave Encashment,Leave Balance,Zanechajte zostatok
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance Schedule {0} exists against {1},Plán údržby {0} existuje proti {1}
DocType: Assessment Plan,Supervisor Name,Meno supervízora
DocType: Selling Settings,Campaign Naming By,Pomenovanie kampane
DocType: Student Group Creation Tool Course,Course Code,Kód kurzu
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Aerospace,Aerospace
DocType: Landed Cost Voucher,Distribute Charges Based On,Distribuovať poplatky založené na
DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Kritériá skórovania hodnotiacej tabuľky dodávateľov
DocType: Account,Stock,sklad
DocType: Landed Cost Item,Receipt Document Type,Typ dokladu
DocType: Territory,Classification of Customers by region,Klasifikácia zákazníkov podľa regiónov
DocType: Hotel Room Amenity,Billable,zúčtovateľné
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Government,vláda
apps/erpnext/erpnext/utilities/activation.py,"Create Employee records to manage leaves, expense claims and payroll","Vytvorte záznamy zamestnancov, ktoré budú spravovať listy, nároky na výdavky a mzdy"
apps/erpnext/erpnext/config/help.py,Point-of-Sale,Miesto predaja
apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Pre položku {0} v riadku {1} nie je možné prepísať viac ako {2}. Ak chcete povoliť nadmerné účtovanie, nastavte ho v časti Nastavenia skladu"
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner.py,User {0} is already assigned to Healthcare Practitioner {1},Používateľ {0} je už priradený k programu Healthcare Practitioner {1}
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Buying,Štandardný nákup
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Apprentice,učeň
apps/erpnext/erpnext/utilities/activation.py,Add Timesheets,Pridať časové rozvrhy
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Number of new Account, it will be included in the account name as a prefix","Číslo nového účtu, bude zahrnuté do názvu účtu ako predpona"
apps/erpnext/erpnext/controllers/buying_controller.py,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dodávateľský sklad je povinný pre subdodávateľov
apps/erpnext/erpnext/hr/doctype/employee/employee.js,Please enter Preferred Contact Email,Zadajte preferovaný kontaktný e-mail
DocType: Vital Signs,Normal,normálne
DocType: Customer,Customer POS Id,Id zákazníka POS
DocType: Purchase Invoice Item,Weight Per Unit,Hmotnosť na jednotku
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,Child nodes can be only created under 'Group' type nodes,Podradené uzly môžu byť vytvorené iba v rámci uzlov typu „Skupina“
DocType: Share Transfer,(including),(počítajúc do toho)
,Requested,požadované
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is not a stock Item,Položka {0} nie je skladom Položka
DocType: Journal Entry,Multi Currency,Viac mien
DocType: Payment Entry,Write Off Difference Amount,Odpísanie rozdielu
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is disabled,Položka {0} je zakázaná
DocType: Asset Maintenance Task,Last Completion Date,Dátum posledného dokončenia
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py,Fulfillment,splnenie
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 zaradená ako práca na pozadí. V prípade, že nastane nejaký problém pri spracovaní na pozadí, systém pridá komentár k chybe na tomto Zosúladení zásob a vráti sa do štádia Konceptu"
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Total Order Considered,Uvažovaná celková objednávka
DocType: Delivery Trip,Optimize Route,Optimalizovať trasu
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.,Percentuálny podiel zliav možno uplatniť buď na základe Cenníka alebo na všetky Cenníky.
DocType: Training Event,Trainer Email,E-mail trénera
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Get from Patient Encounter,Dostaňte sa od stretnutia pacienta
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Software Developer,Vývojár softvéru
DocType: Clinical Procedure Template,Sample Collection,Odber vzoriek
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',Podeľte sa o svoju spätnú väzbu so školením kliknutím na položku „Spätná väzba v oblasti odbornej prípravy“ a potom na položku „Nové“.
DocType: QuickBooks Migrator,Connecting to QuickBooks,Pripojenie k QuickBooks
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Enrolling student,Zapísanie študenta
DocType: Employee Advance,Claimed,vyhlasoval
apps/erpnext/erpnext/config/hr.py,Leaves,listy
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Rozdelenie platov založené na zárobku a odpočítaní.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Structure Missing,Chýba mzdová štruktúra
DocType: Setup Progress Action,Action Field,Akčné pole
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ť vygenerovaný iba z predajnej faktúry
,Quotation Trends,Trendy ponuky
apps/erpnext/erpnext/config/integrations.py,Connect Amazon with ERPNext,Pripojiť Amazon s ERPNext
DocType: Service Level Agreement,Response and Resolution Time,Odozva a čas rozlíšenia
DocType: Loyalty Program,Collection Tier,Kolekcia Tier
DocType: Guardian,Guardian Of ,Strážca
DocType: Payment Request,Payment Gateway Details,Podrobnosti o platobnej bráne
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 na označenie {1}
DocType: Item,Website Warehouse,Galéria webových stránok
DocType: Sales Invoice Item,Rate With Margin,Miera s maržou
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 Vyhlásenia o oslobodení od dane
apps/erpnext/erpnext/public/js/event.js,Add Leads,Pridať vedie
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reserve Warehouse,Rezervný sklad
DocType: Payment Term,Payment Term Name,Názov termínu platby
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,No Permission,Bez povolenia
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Company...,Vyberte spoločnosť ...
DocType: Stock Settings,Use Naming Series,Použite Naming Series
DocType: Salary Component,Formula,vzorec
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on Actual,"Činnosť, ak bol kumulovaný mesačný rozpočet prekročený o skutočný"
DocType: Leave Type,Allow Encashment,Povoliť inkaso
apps/erpnext/erpnext/config/projects.py,Project activity / task.,Činnosť projektu / úloha.
DocType: Bank Statement Transaction Invoice Item,Bank Statement Transaction Invoice Item,Položka fakturácie výpisu z účtu
DocType: Work Order,Total Operating Cost,Celkové prevádzkové náklady
DocType: Employee Onboarding,Employee Onboarding Template,Zamestnanecká palubná šablóna
DocType: Pricing Rule,Same Item,Rovnaká položka
apps/erpnext/erpnext/regional/india/bank_remittance.py,"Amount for a single transaction exceeds maximum allowed amount, create a separate payment order by splitting the transactions","Suma za jednu transakciu presahuje maximálnu povolenú sumu, vytvorením samostatného platobného príkazu rozdelením transakcií"
DocType: Payroll Entry,Salary Slips Created,Vytvorené platové lístky
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,Lab Test(s) ,Laboratórne testy
DocType: Bank Account,Party Details,Podrobnosti o strane
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
apps/erpnext/erpnext/support/doctype/issue/issue.js,All communications including and above this shall be moved into the new Issue,Všetky oznámenia vrátane a nad touto správou sa presunú do nového vydania
DocType: Stock Entry,Material Consumption for Manufacture,Spotreba materiálu na výrobu
DocType: Item Website Specification,Table for Item that will be shown in Web Site,"Tabuľka pre položku, ktorá sa zobrazí na webovej lokalite"
DocType: Restaurant Menu,Restaurant Menu,Reštaurácia Menu
DocType: Asset Movement,Purpose,účel
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,Salary Structure Assignment for Employee already exists,Priradenie mzdovej štruktúry zamestnancov už existuje
DocType: Clinical Procedure,Service Unit,Servisná jednotka
DocType: Travel Request,Identification Document Number,Číslo identifikačného dokladu
DocType: Stock Entry,Additional Costs,Dodatočné náklady
DocType: Employee Education,Employee Education,Vzdelávanie zamestnancov
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.js,Number of positions cannot be less then current count of employees,Počet pozícií nemôže byť menší ako súčasný počet zamestnancov
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Customer Groups,Všetky skupiny zákazníkov
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Price List,Nákupný cenník
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Finished Good Item Code,Hotový kód dobrej položky
apps/erpnext/erpnext/controllers/accounts_controller.py,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,"Pre dátum {0} existuje viacero fiškálnych rokov. Prosím, nastavte spoločnosť v rozpočtovom roku"
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available for use date is required,Vyžaduje sa dátum použiteľnosti
DocType: Employee Training,Training Date,Dátum školenia
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Čítanie nahraného súboru
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material Request,Žiadosť o materiál
DocType: Payment Entry,Total Allocated Amount (Company Currency),Celková pridelená suma (mena spoločnosti)
DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Položka objednávky reštaurácie
DocType: Delivery Stop,Distance,vzdialenosť
DocType: Amazon MWS Settings,Get financial breakup of Taxes and charges data by Amazon ,Získajte finančné rozdelenie daní a poplatkov údaje Amazon
DocType: Vehicle Service,Mileage,najazdených kilometrov
apps/erpnext/erpnext/controllers/status_updater.py,"For an item {0}, quantity must be positive number",Pre položku {0} musí byť množstvo kladné číslo
apps/erpnext/erpnext/public/js/pos/pos.html,Item Cart,Položka Košík
apps/erpnext/erpnext/accounts/utils.py,Payment Entries {0} are un-linked,Platobné položky {0} nie sú prepojené
DocType: Email Digest,Open Notifications,Otvorte upozornenia
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Successfully created payment entries,Úspešne sa vytvorili položky platby
DocType: Soil Analysis,Mg/K,Mg / K
DocType: Item,Has Serial No,Má sériové číslo
DocType: Asset Maintenance,Manufacturing User,Výrobný užívateľ
apps/erpnext/erpnext/accounts/doctype/account/account.js,Ledger,Hlavná kniha
DocType: Journal Entry Account,Loan,pôžička
DocType: Vehicle,Fuel UOM,Palivo UOM
DocType: Issue,Support,podpora
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid Company for Inter Company Transaction.,Neplatná spoločnosť pre medzipodnikovú transakciu.
DocType: Company,Fixed Asset Depreciation Settings,Nastavenia odpisov fixných aktív
DocType: Employee,Department and Grade,Oddelenie a trieda
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Cheques Required,Vyžaduje sa kontrola
DocType: Lead,Do Not Contact,Nepotýkajte sa
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Expense,Nové náklady
DocType: Sales Invoice,Update Billed Amount in Sales Order,Aktualizovať fakturovanú čiastku v zákazke odberateľa
DocType: Travel Itinerary,Meal Preference,Preferencia jedla
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:","Aj keď existuje viacero pravidiel určovania cien s najvyššou prioritou, použijú sa tieto interné priority:"
DocType: Item,Over Delivery/Receipt Allowance (%),Príspevok na dodanie / prevzatie (%)
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
apps/erpnext/erpnext/config/accounting.py,List of all share transactions,Zoznam všetkých transakcií s akciami
DocType: Item Default,Sales Defaults,Predvolené hodnoty predaja
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Overlap in scoring between {0} and {1},Prekrytie medzi hodnotami {0} a {1}
DocType: Course Assessment Criteria,Weightage,weightage
DocType: Bank Statement Transaction Entry,Create New Payment/Journal Entry,Vytvoriť novú platbu / záznam do denníka
DocType: Attendance,HR-ATT-.YYYY.-,HR-ATT-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Ak sa na základe vyššie uvedených podmienok zistia dve alebo viac pravidiel tvorby cien, použije sa priorita. Priorita je číslo od 0 do 20, zatiaľ čo predvolená hodnota je nula (prázdna). Vyššie číslo znamená, že bude mať prednosť v prípade, ak sú s rovnakými podmienkami viaceré pravidlá určovania cien."
apps/erpnext/erpnext/controllers/selling_controller.py,Row {0}: Qty is mandatory,Riadok {0}: Počet je povinný
DocType: Sales Invoice,Against Income Account,Proti účtu príjmov
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Riadok # {0}: Nákupnú faktúru nemožno vykonať voči existujúcemu majetku {1}
apps/erpnext/erpnext/config/buying.py,Rules for applying different promotional schemes.,Pravidlá uplatňovania rôznych propagačných schém.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,UOM coversion factor required for UOM: {0} in Item: {1},Pre UOM je potrebný faktor konverzie UOM: {0} v položke: {1}
apps/erpnext/erpnext/buying/utils.py,Please enter quantity for Item {0},Zadajte množstvo pre položku {0}
DocType: Workstation,Electricity Cost,Náklady na elektrickú energiu
DocType: Vehicle Service,Vehicle Service,Servis vozidiel
apps/erpnext/erpnext/config/help.py,Making Stock Entries,Vytváranie skladových záznamov
DocType: Bank Guarantee,Fixed Deposit Number,Fixné vkladové číslo
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ť prevzatie / doručenie, aktualizujte „Over Receipt / Delivery Allowance“ v položke Stock Settings alebo Item."
DocType: Vital Signs,Very Coated,Veľmi potiahnuté
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 odpojí tento účet od akejkoľvek externej služby integrujúcej ERPNext s vašimi bankovými účtami. Nedá sa vrátiť späť. Si si istý?
DocType: Delivery Trip,Initial Email Notification Sent,Pôvodné e-mailové upozornenie odoslané
DocType: Production Plan,For Warehouse,Pre sklad
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,"{0}: Employee email not found, hence email not sent","{0}: E-mail zamestnanca nebol nájdený, preto e-mail nebol odoslaný"
DocType: Currency Exchange,From Currency,Z meny
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Return / Debit Note,Poznámka o vrátení / debete
DocType: Homepage Section,"Order in which sections should appear. 0 is first, 1 is second and so on.","Poradie, v ktorom sa majú zobrazovať sekcie. 0 je prvá, 1 je druhá a tak ďalej."
apps/erpnext/erpnext/utilities/activation.py,Create Sales Orders to help you plan your work and deliver on-time,"Vytvorte zákazky odberateľa, ktoré vám pomôžu naplánovať si prácu a dodať včas"
apps/erpnext/erpnext/templates/includes/cart.js,Something went wrong!,Niečo sa pokazilo!
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Healthcare Service,Vyberte službu zdravotnej starostlivosti
DocType: Leave Application,Apply / Approve Leaves,Použiť / schváliť listy
DocType: Leave Block List,Applies to Company,Vzťahuje sa na spoločnosť
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Row {0}: Bill of Materials not found for the Item {1},Riadok {0}: kusovník nebol nájdený pre položku {1}
DocType: Loan,Account Info,Informácie o účte
DocType: Item Attribute Value,Abbreviation,Skratka
DocType: Email Digest,Purchase Orders to Bill,Objednávky na účet Bill
DocType: Purchase Invoice,Total Net Weight,Celková čistá hmotnosť
DocType: Authorization Rule,Approving Role (above authorized value),Schválenie úlohy (nad povolenú hodnotu)
DocType: Employee Advance,HR-EAD-.YYYY.-,HR-EAD-.YYYY.-
DocType: Job Applicant,Resume Attachment,Obnovenie prílohy
DocType: Agriculture Analysis Criteria,Agriculture Manager,Manažér pre poľnohospodárstvo
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batch Entries,Dávkové zápisy
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,Zapnite možnosť Platné na objednávku a platí pre rezerváciu skutočných nákladov
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 likvidácie majetku
DocType: Loan,Total Payment,Celková platba
DocType: Asset,Total Number of Depreciations,Celkový počet odpisov
DocType: Asset,Fully Depreciated,Plne odpísané
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant Settings,Nastavenia variantu položky
DocType: Supplier Group,Supplier Group Name,Názov skupiny dodávateľov
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,Sales Price List,Predajný cenník
DocType: Email Digest,How frequently?,Ako často?
DocType: Purchase Invoice,Supplier Warehouse,Dodávateľský sklad
DocType: Salary Component,Only Tax Impact (Cannot Claim But Part of Taxable Income),"Iba daňový dopad (nedá sa reklamovať, ale je súčasťou zdaniteľného príjmu)"
DocType: Item Default,Purchase Defaults,Predvolené nákupy
DocType: Contract,Contract Template,Zmluva šablóny
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/hr/doctype/leave_application/leave_application_dashboard.html,Pending Leaves,Čakajúce listy
DocType: Student Applicant,Applied,aplikovaný
DocType: Clinical Procedure,Consumption Details,Podrobnosti o spotrebe
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.html,Loading Payment System,Načítanie platobného systému
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.py,Repayment Amount must be greater than ,Výška splátok musí byť väčšia ako
DocType: Assessment Plan,Maximum Assessment Score,Maximálne skóre hodnotenia
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Status Notification in HR Settings.,Prosím nastavte predvolenú šablónu pre Leave Status Notification v nastavení HR.
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Report Card,Karta študentskej správy
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Nature Of Supplies,Príroda dodávok
DocType: Shopify Settings,Last Sync Datetime,Dátum poslednej synchronizácie
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Code {0} already exist,Kód {0} už existuje
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Based On Payment Terms,Na základe platobných podmienok
DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Táto hodnota sa aktualizuje v predvolenom cenníku predaja.
DocType: Special Test Template,Special Test Template,Špeciálna testovacia šablóna
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Vytvorte varianty
DocType: Item Default,Default Expense Account,Predvolený účet výdavkov
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py,Please setup Students under Student Groups,Prosím nastavte Študenti v Študentských skupinách
apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Zdaniteľná suma
DocType: Lead,Lead Owner,Vedúci vlastník
DocType: Share Transfer,Transfer,prevod
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Search Item (Ctrl + i),Položka vyhľadávania (Ctrl + i)
DocType: Call Log,Call Log,Denník hovorov
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,{0} Result submittted,{0} Výsledok bol odoslaný
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äčší ako k dnešnému dňu
DocType: Supplier,Supplier of Goods or Services.,Dodávateľ tovaru alebo služieb.
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: Nevytvárajte účty pre zákazníkov a dodávateľov
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Student Group or Course Schedule is mandatory,Študentská skupina alebo rozvrh kurzu je povinný
DocType: Tax Rule,Sales Tax Template,Šablóna dane z predaja
DocType: BOM,Routing,smerovanie
DocType: Payment Reconciliation,Payment Reconciliation,Zúčtovanie platieb
apps/erpnext/erpnext/config/accounting.py,Match non-linked Invoices and Payments.,Zodpovedajúce neprepojené faktúry a platby.
apps/erpnext/erpnext/utilities/user_progress.py,Opening Balances,Otváracie zostatky
DocType: Supplier,PAN,PAN
DocType: Work Order,Operation Cost,Prevádzkové náklady
DocType: Bank Guarantee,Name of Beneficiary,Meno príjemcu
apps/erpnext/erpnext/public/js/templates/address_list.html,New Address,Nová adresa
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,"Subsidiary companies have already planned for {1} vacancies at a budget of {2}. \
				Staffing Plan for {0} should allocate more vacancies and budget for {3} than planned for its subsidiary companies","Dcérske spoločnosti už naplánovali {1} voľné pracovné miesta s rozpočtom {2}. Personálny plán pre {0} by mal vyčleniť viac voľných pracovných miest a rozpočet pre {3}, než je plánované pre jeho dcérske spoločnosti"
DocType: Stock Entry,From BOM,Z kusovníka
DocType: Program Enrollment Tool,Student Applicant,Žiadateľ o štúdium
DocType: Leave Application,Leave Balance Before Application,Zostať pred použitím
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Expiry date is mandatory for selected item,Dátum exspirácie je povinný pre vybranú položku
DocType: Stock Entry,Default Target Warehouse,Predvolený cieľový sklad
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Show Salary Slip,Zobraziť platový sklz
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py,Percentage Allocation should be equal to 100%,Percento alokácie by sa malo rovnať 100%
DocType: Purchase Invoice Item,UOM Conversion Factor,Faktor konverzie UOM
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Stock cannot be updated against Purchase Receipt {0},Zásobu nie je možné aktualizovať oproti Potvrdeniu o nákupe {0}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Item Row {0}: {1} {2} does not exist in above '{1}' table,Položka Riadok {0}: {1} {2} neexistuje v tabuľke {1}
DocType: Asset Maintenance Task,2 Yearly,2 Ročne
DocType: Guardian Student,Guardian Student,Študent Guardian
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please add a Temporary Opening account in Chart of Accounts,Do účtovej osnovy pridajte účet Dočasné otvorenie
DocType: Account,Include in gross,Zahrnúť v hrubom
apps/erpnext/erpnext/config/hr.py,Loans,pôžičky
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Patient History,História pacienta
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Serial Numbers,Vyberte Sériové čísla
DocType: Tally Migration,UOMs,UOMs
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}: strana / účet sa nezhoduje s {1} / {2} v {3} {4}
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid reference {0} {1},Neplatný odkaz {0} {1}
DocType: Quality Action,Corrective/Preventive,Nápravné / preventívne
DocType: Work Order Operation,Work In Progress,Práca v pokroku
DocType: Bank Reconciliation,Account Currency,Mena účtu
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,credit_note_amt,credit_note_amt
DocType: Setup Progress Action,Action Name,Názov akcie
DocType: Employee,Health Insurance,Zdravotné poistenie
DocType: Student Group,Max Strength,Maximálna sila
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate customer group found in the cutomer group table,Duplicitná skupina zákazníkov sa nachádza v tabuľke skupiny cutomer
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Dovolenka nemôže byť uplatnená / zrušená pred {0}, pretože zostatok dovolenky už bol prenesený v budúcom zázname o pridelení dovolenky {1}"
DocType: Promotional Scheme Price Discount,Min Amount,Min
DocType: Sales Invoice Item,Rate With Margin (Company Currency),Miera s maržou (mena spoločnosti)
DocType: Lead,Follow Up,Nasleduj
DocType: Tax Rule,Shipping Country,Prepravná krajina
DocType: Delivery Note,Track this Delivery Note against any Project,Sledujte tento dodací list voči akémukoľvek projektu
apps/erpnext/erpnext/regional/india/utils.py,Vehicle Type is required if Mode of Transport is Road,"Typ vozidla sa vyžaduje v prípade, ak je Druh dopravy Cestná"
DocType: Company,Default Payroll Payable Account,Východiskový mzdový účet
DocType: Drug Prescription,Update Schedule,Plán aktualizácie
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Updating estimated arrival times.,Aktualizácia odhadovaných časov príchodu.
DocType: Asset Category,Finance Book Detail,Detail finančnej knihy
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Serial No {0} does not belong to Delivery Note {1},Sériové číslo {0} nepatrí do poznámky o doručení {1}
apps/erpnext/erpnext/regional/italy/utils.py,Please set Tax ID for the customer '%s',Nastavte ID DPH pre zákazníka „% s“
DocType: Sales Partner,Logo,logo
DocType: Leave Type,Include holidays within leaves as leaves,Zahrňte dovolenku do listov ako listy
DocType: Shift Assignment,Shift Request,Požiadavka posunu
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py,"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Nedá sa označiť Vybitý záznam v nemocničnom zázname, neexistujú faktúry fakturované {0}"
DocType: QuickBooks Migrator,Scope,Rozsah
DocType: Purchase Invoice Item,Service Stop Date,Dátum zastavenia služby
apps/erpnext/erpnext/setup/doctype/company/test_company.py,No Account matched these filters: {},Tieto filtre nezodpovedali žiadnemu účtu: {}
DocType: Article,Publish Date,Dátum publikovania
DocType: Student,O+,O +
DocType: BOM,Work Order,Zákazka
DocType: Bank Statement Transaction Settings Item,Transaction,transakcie
DocType: Workstation,per hour,za hodinu
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,This action will stop future billing. Are you sure you want to cancel this subscription?,Táto akcia zastaví budúcu fakturáciu. Naozaj chcete zrušiť predplatné?
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,State/UT Tax,Daň štátu / UT
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py,Scorecards,scorecards
,Projected Quantity as Source,Predpokladané množstvo ako zdroj
DocType: Supplier Group,Parent Supplier Group,Skupina dodávateľov materskej spoločnosti
apps/erpnext/erpnext/controllers/accounts_controller.py,Rows with duplicate due dates in other rows were found: {0},Boli nájdené riadky s duplicitnými dátumami splatnosti v iných riadkoch: {0}
DocType: Fees,EDU-FEE-.YYYY.-,EDU-FEE-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Chart Of Accounts Template,Šablóna účtov
DocType: Lead,Lead,Lead
DocType: Appraisal Template Goal,KRA,KRA
apps/erpnext/erpnext/utilities/user_progress.py,Setup Institution,Nastavenie inštitúcie
DocType: Invoice Discounting,Loan Period (Days),Obdobie úveru (dni)
,Salary Register,Platový register
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 viacúrovňového programu budú zákazníci automaticky priradení k príslušnej úrovni podľa ich vynaložených nákladov
DocType: Bank Reconciliation Detail,Posting Date,Dátum odoslania
DocType: Upload Attendance,Attendance From Date,Účasť od dátumu
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: GST Settings,GST Summary,Zhrnutie GST
DocType: Education Settings,Make Academic Term Mandatory,Urobiť povinné akademické obdobie
DocType: Vehicle,Odometer Value (Last),Hodnota počítadla kilometrov (posledná)
apps/erpnext/erpnext/config/assets.py,Transfer an asset from one warehouse to another,Preneste majetok z jedného skladu do druhého
DocType: Room,Seating Capacity,Počet miest na sedenie
DocType: Employee Benefit Application Detail,Employee Benefit Application Detail,Detail aplikácie Zamestnanecká výhoda
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 o {1} medzi {2} a {3}:
DocType: Asset Category Account,Capital Work In Progress Account,Účet kapitálovej práce v postupe
DocType: Employee Benefit Claim,Benefit Type and Amount,Typ dávky a výška
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Please set default payable account for the company {0},Nastavte predvolený splatný účet pre spoločnosť {0}
DocType: Daily Work Summary Group,Holiday List,Zoznam dovoleniek
DocType: Job Card,Total Time in Mins,Celkový čas v minách
DocType: Shipping Rule,Shipping Amount,Množstvo zásielky
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Absent,Spolu chýba
DocType: Fee Validity,Reference Inv,Odkaz Inv
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Row {0}: {1} is required to create the Opening {2} Invoices,Riadok {0}: {1} je potrebný na vytvorenie faktúr Otvorenie {2}
DocType: Bank Account,Is Company Account,Je firemný účet
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Do you want to notify all the customers by email?,Chcete informovať všetkých zákazníkov e-mailom?
DocType: Opening Invoice Creation Tool,Sales,odbyt
DocType: Vital Signs,Tongue,jazyk
DocType: Journal Entry,Excise Entry,Vstup do spotrebnej dane
apps/erpnext/erpnext/www/all-products/index.html,Clear filters,Vymazať filtre
DocType: Delivery Trip,In Transit,V preprave
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/doctype/gl_entry/gl_entry.py,Balance for Account {0} must always be {1},Zostatok na účte {0} musí byť vždy {1}
apps/erpnext/erpnext/public/js/controllers/transaction.js,Invalid Blanket Order for the selected Customer and Item,Neplatná objednávka pre zvoleného zákazníka a položku
DocType: Production Plan Item,"If enabled, system will create the work order for the exploded items against which BOM is available.","Ak je táto možnosť povolená, systém vytvorí objednávku pre rozložené položky, proti ktorým je kusovník k dispozícii."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Product Bundle,Produktový balík
DocType: Exchange Rate Revaluation Account,New Exchange Rate,Nový výmenný kurz
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open To Do,Otvoriť
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Receiver List is empty. Please create Receiver List,Zoznam príjemcov je prázdny. Vytvorte zoznam príjemcov
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Current Liabilities,Bežné záväzky
apps/erpnext/erpnext/templates/pages/demo.html,ERPNext Demo,ERPNext Demo
DocType: Patient,Other Risk Factors,Iné rizikové faktory
DocType: Item Attribute,To Range,Rozsah
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} applicable after {1} working days,{0} použiteľné po {1} pracovných dňoch
DocType: Task,Task Description,Popis úlohy
DocType: Bank Account,SWIFT Number,Číslo SWIFT
DocType: Accounts Settings,Show Payment Schedule in Print,Zobraziť plán platieb v Print
DocType: Purchase Invoice,Apply Tax Withholding Amount,Žiadosť o zrážkovú daň
DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Dodávateľ Scorecard Stály
DocType: Quality Inspection Reading,Quality Inspection Reading,Čítanie kontroly kvality
DocType: Healthcare Settings,Valid number of days,Platný počet dní
DocType: Production Plan Item,material_request_item,material_request_item
DocType: Installation Note,MAT-INS-.YYYY.-,MAT-INS-.YYYY.-
DocType: Healthcare Settings,Custom Signature in Print,Vlastný podpis v tlači
DocType: Patient Encounter,Procedures,postupy
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Issues,Otvorené problémy
DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Séria pre odpisy majetku (zápis do denníka)
DocType: Healthcare Service Unit,Occupancy Status,Stav obsadenosti
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Privilege Leave,Dovolenka Privilege
DocType: Subscription,Current Invoice End Date,Aktuálny dátum ukončenia faktúry
DocType: Sample Collection,Collected Time,Zozbieraný čas
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please select BOM for Item in Row {0},Vyberte položku BOM pre položku v riadku {0}
DocType: Department,Expense Approver,Schvaľovateľ výdavkov
DocType: Bank Statement Transaction Entry,New Transactions,Nové transakcie
apps/erpnext/erpnext/hr/report/loan_repayment/loan_repayment.py,Payable Amount,Splatná suma
DocType: SMS Center,All Supplier Contact,Všetci dodávatelia Kontakt
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Quotation {0} not of type {1},Citácia {0} nie typu {1}
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,Leave Type {0} is not encashable,Typ ponechania {0} nie je možné uložiť
DocType: Contract,Fulfilment Status,Stav plnenia
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Unsubscribe from this Email Digest,Odhlásiť sa z tohto Digestu
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.py,{0} {1} created,{0} {1} vytvorené
DocType: Water Analysis,Person Responsible,Zodpovedná osoba
DocType: Asset,Asset Category,Kategória aktív
DocType: Cash Flow Mapping Accounts,Cash Flow Mapping Accounts,Účty mapovania peňažných tokov
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Select Serial No,Vyberte Sériové číslo
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Predajný výnos
apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py,No record found,Nebol nájdený žiadny záznam
DocType: Department,Expense Approvers,Schvalovatelia výdavkov
DocType: Purchase Invoice,Group same items,Skupina rovnaké položky
DocType: Company,Parent Company,Materská spoločnosť
DocType: Daily Work Summary Group,Reminder,pripomienka
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Bank Overdraft Account,Kontokorentný účet
DocType: Journal Entry,Difference (Dr - Cr),Rozdiel (Dr - Cr)
apps/erpnext/erpnext/stock/doctype/item/item.py,"An Item Group exists with same name, please change the item name or rename the item group","Skupina položiek existuje s rovnakým názvom, zmeňte názov položky alebo premenujte skupinu položiek"
DocType: Student,B+,B +
apps/erpnext/erpnext/controllers/buying_controller.py,Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Nasledujúca položka {0} nie je označená ako {1} položka. Môžete ich povoliť ako položku {1} z jej hlavného riadku položky
DocType: Healthcare Service Unit,Allow Overlap,Povoliť prekrytie
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 pre atribút {0} musí byť v rozsahu {1} až {2} v prírastkoch {3} pre položku {4}
DocType: Timesheet,Billing Details,fakturačné údaje
DocType: Quality Procedure Table,Quality Procedure Table,Tabuľka kvality
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} created,Vytvorené sériové číslo {0}
DocType: Warehouse,Warehouse Detail,Detail skladu
DocType: Sales Order,To Deliver and Bill,Dodať a Bill
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Pridané k detailom
apps/erpnext/erpnext/public/js/hub/marketplace.js,Add Users to Marketplace,Pridajte používateľov na trh
DocType: Healthcare Settings,Remind Before,Pripomeňte predtým
DocType: Healthcare Settings,Manage Customer,Spravovať zákazníka
DocType: Loyalty Program Collection,Tier Name,Názov triedy
DocType: Manufacturing Settings,Manufacturing Settings,Výrobné nastavenia
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,Taken,zaujatý
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select Start Date and End Date for Item {0},Vyberte položku Dátum začiatku a Dátum ukončenia položky {0}
DocType: Education Settings,Education Settings,Nastavenia vzdelávania
DocType: Student Admission,Admission End Date,Dátum ukončenia prijatia
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> , bude na položku použitá schéma <b>{3}</b> ."
DocType: Bank Account,Mask,maskovať
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Please specify Company to proceed,"Zadajte spoločnosť, aby pokračovala"
DocType: Asset Maintenance Team,Asset Maintenance Team,Tím údržby majetku
DocType: Production Plan Material Request,Material Request Date,Dátum požiadavky na materiál
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Responsibilities,zodpovednosť
DocType: Project,Total Costing Amount (via Timesheets),Celková čiastka kalkulácie (prostredníctvom výkazov)
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Make New Contact,Vytvoriť nový kontakt
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Importovanie položiek a UOM
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Leaves per Year,Listy za rok
DocType: Student,Date of Leaving,Dátum odchodu
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,Export E-Invoices,Export e-faktúr
DocType: Healthcare Settings,Laboratory SMS Alerts,Laboratórne SMS upozornenia
DocType: Program,Is Published,Je publikované
DocType: Clinical Procedure,Healthcare Practitioner,Lekársky lekár
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/stock_reconciliation/stock_reconciliation.py,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Batched Item {0} nie je možné aktualizovať pomocou odsúhlasenia zásob, namiesto toho použite položku Entry Stock"
DocType: Employee External Work History,Total Experience,Celkové skúsenosti
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material to Supplier,Materiál pre dodávateľa
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 povinný voči účtu pohľadávok {2}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Healthcare Services,Služby zdravotnej starostlivosti
DocType: Grading Scale Interval,Grade Code,Kód triedy
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Schôdzky a stretnutia pacientov
,TDS Computation Summary,Zhrnutie výpočtu TDS
DocType: Shipping Rule,Shipping Rule Label,Štítok s prepravným pravidlom
DocType: Buying Settings,Supplier Naming By,Dodávateľ Pomenovanie By
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Admissions for {0},Prijatie pre {0}
DocType: Loan,Loan Details,Podrobnosti úveru
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} on Half day on {1},Zamestnanec {0} o pol dňa dňa {1}
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_sub_category/employee_tax_exemption_sub_category.py,Max Exemption Amount cannot be greater than maximum exemption amount {0} of Tax Exemption Category {1},Maximálna čiastka oslobodenia od dane nemôže byť vyššia ako maximálna výška výnimky {0} kategórie oslobodenia od dane {1}
apps/erpnext/erpnext/hr/utils.py,Please set leave policy for employee {0} in Employee / Grade record,Nastavte politiku opustenia zamestnanca {0} v zázname Zamestnanec / Trieda
DocType: Bank Reconciliation Detail,Cheque Number,Kontrolné číslo
,Prospects Engaged But Not Converted,"Vyhliadky zapojené, ale nie konvertované"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Liabilities,Záväzky z akcií
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py,-Above,-Above
DocType: Item Website Specification,Item Website Specification,Špecifikácia web stránky
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}) nie je možné spotrebovať tak, ako je určená na plnenie objednávky odberateľa {2}."
DocType: Vehicle,Electric,elektrický
apps/erpnext/erpnext/config/hr.py,Fleet Management,Správa vozového parku
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 zobrazí viackrát na základe Cenníka, Dodávateľa / Zákazníka, Meny, Položky, UOM, Množstvo a Dátumy."
DocType: Stock Ledger Entry,Stock Ledger Entry,Položka knihy
DocType: HR Settings,Email Salary Slip to Employee,Email Plat Slip na zamestnanca
DocType: Stock Entry,Delivery Note No,Dodací list č
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Timeslots,Pridať Timesloty
DocType: Packing Slip Item,Packing Slip Item,Balenie Slip Item
DocType: Payroll Period,Standard Tax Exemption Amount,Štandardná čiastka oslobodenia od dane
apps/erpnext/erpnext/config/help.py,Serialized Inventory,Serializovaná inventúra
DocType: Contract,Requires Fulfilment,Vyžaduje splnenie
DocType: Quality Inspection,MAT-QA-.YYYY.-,MAT-QA-.YYYY.-
DocType: Bank Statement Transaction Entry,Receivable Account,Účet pohľadávok
DocType: Website Attribute,Website Attribute,Atribút webovej stránky
apps/erpnext/erpnext/public/js/templates/address_list.html,No address added yet.,Zatiaľ nebola pridaná žiadna adresa.
DocType: Sales Order,Partly Billed,Čiastočne fakturované
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,Customer isn't enrolled in any Loyalty Program,Zákazník nie je zapísaný v žiadnom vernostnom programe
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Jobs,jobs
DocType: Expense Claim,Approval Status,Stav schválenia
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Opening Qty,Otvorenie Množstvo
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}","Preskočenie štruktúry miezd Priradenie nasledovných zamestnancov, keďže záznamy o mzdovej štruktúre priradenia už existujú proti nim. {0}"
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Dátum uzávierky nemôže byť neskorší ako dátum ukončenia akademického roka, na ktorý je termín spojený (akademický rok {}). Opravte dátumy a skúste to znova."
DocType: Purchase Order,% Billed,Fakturované
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Variance,Celková odchýlka
apps/erpnext/erpnext/support/doctype/issue/issue.js,Split Issue,Problém s rozdelením
DocType: Item Default,Default Supplier,Predvolený dodávateľ
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Base,základňa
apps/erpnext/erpnext/config/accounting.py,Share Management,Správa podielov
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Sales Order {0} is not valid,Zákazka odberateľa {0} nie je platná
DocType: Leave Control Panel,Branch (optional),Pobočka (voliteľné)
DocType: Bank Reconciliation Detail,Clearance Date,Dátum vyrovnania
DocType: Supplier Scorecard Period,Criteria,kritériá
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,"Zvýšiť požiadavku na materiál, keď zásoba dosiahne úroveň opätovnej objednávky"
,Campaign Efficiency,Účinnosť kampane
apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Vytvoriť časový rozvrh
DocType: Employee,Internal Work History,História vnútornej práce
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Select Target Warehouse,Vyberte cieľový sklad
DocType: Subscription Settings,Grace Period,Obdobie milosti
DocType: Patient,Married,ženatý
DocType: Work Order Item,Available Qty at Source Warehouse,Dostupný počet v zdrojovom sklade
DocType: Shipping Rule Country,Shipping Rule Country,Prepravná krajina
DocType: Delivery Stop,Email Sent To,Odoslať e-mailom
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Material Consumption,Spotreba materiálu
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Nothing to change,Nič sa nezmení
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,No Lab Test created,Nebol vytvorený žiadny laboratórny test
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maximálne vzorky - {0} už boli ponechané pre dávku {1} a položku {2} v dávke {3}.
apps/erpnext/erpnext/setup/doctype/company/company.py,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Nemožno zmeniť predvolenú menu spoločnosti, pretože existujú existujúce transakcie. Ak chcete zmeniť predvolenú menu, transakcie sa musia zrušiť."
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Maintenance Expenses,Náklady na údržbu kancelárií
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é pridelené listy sú viac dní ako maximálna alokácia {0} dovolenky pre zamestnanca {1} v danom období
DocType: Stock Entry,Update Rate and Availability,Rýchlosť aktualizácie a dostupnosť
DocType: Item Variant Attribute,Item Variant Attribute,Atribút Variant položky
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Dostupné množstvo šarží v sklade
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Zľava (%) z Cenníka s maržou
DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,"Skontrolujte, či Asset vyžaduje preventívnu údržbu alebo kalibráciu"
DocType: Lab Test,Technician Name,Meno technika
DocType: Lab Test Groups,Normal Range,Normálny rozsah
DocType: Item,Total Projected Qty,Celkový projektovaný počet
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Boms,kusovníky
DocType: Work Order,Actual Start Date,Skutočný dátum začiatku
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í na všetky dni (dni) medzi dňami žiadosti o náhradné voľno
apps/erpnext/erpnext/config/accounting.py,Tree of financial accounts.,Strom finančných účtov.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Indirect Income,Nepriame príjmy
DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,Rezervácia Rezervácia
DocType: Course Scheduling Tool,Course Start Date,Dátum začiatku kurzu
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Sell,predávať
DocType: Support Search Source,Post Route String,Post Trasa String
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Electrical,elektrický
DocType: Journal Entry,Total Debit,Celkový debet
DocType: Guardian,Guardian,poručník
DocType: Share Transfer,Transfer Type,Typ prenosu
apps/erpnext/erpnext/config/crm.py,Database of potential customers.,Databáza potenciálnych zákazníkov.
DocType: Skill,Skill Name,Názov zručnosti
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js,Print Report Card,Vytlačiť kartu správy
DocType: Soil Texture,Ternary Plot,Ternárny graf
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Support Tickets,Podporné vstupenky
DocType: Asset Category Account,Fixed Asset Account,Účet investičného majetku
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Latest,najnovšie
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Odoslať Plat Slip
DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Pulzová frekvencia dospelých je medzi 50 a 80 údermi za minútu.
DocType: Program Enrollment Course,Program Enrollment Course,Kurz zápisu do programu
,IRS 1099,IRS 1099
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set the series to be used.,"Nastavte rad, ktorý sa má použiť."
DocType: Delivery Trip,Distance UOM,Vzdialenosť UOM
DocType: Accounting Dimension,Mandatory For Balance Sheet,Povinné pre súvahu
DocType: Payment Entry,Total Allocated Amount,Celková alokovaná suma
DocType: Sales Invoice,Get Advances Received,Získané pokroky
DocType: Shift Type,Last Sync of Checkin,Posledná synchronizácia služby Checkin
DocType: Student,B-,B-
DocType: Purchase Invoice Item,Item Tax Amount Included in Value,Položka Suma dane zahrnuté v hodnote
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á, môže byť zrušená / neexistuje. Zadajte platnú faktúru"
DocType: Subscription Plan,Subscription Plan,Plán predplatného
DocType: Student,Blood Group,Krvná skupina
apps/erpnext/erpnext/config/healthcare.py,Masters,masters
DocType: Crop,Crop Spacing UOM,Medzera orezania UOM
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,View call log,Zobrazenie denníka hovorov
DocType: Shift Type,The time after the shift start time when check-in is considered as late (in minutes).,"Čas po začatí zmeny posunu, keď je check-in považovaný za neskorý (v minútach)."
apps/erpnext/erpnext/templates/pages/home.html,Explore,preskúmať
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,No outstanding invoices found,Nenašli sa žiadne nevyrovnané faktúry
DocType: Promotional Scheme,Product Discount Slabs,Produkt Zľavové dosky
DocType: Hotel Room Package,Amenities,Vybavenie
DocType: Lab Test Groups,Add Test,Pridať test
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Cannot return more than {1} for Item {2},Riadok # {0}: Nie je možné vrátiť viac ako {1} pre položku {2}
DocType: Student Leave Application,Student Leave Application,Študent opustiť žiadosť
DocType: Maintenance Schedule Item,Maintenance Schedule Item,Položka Plán údržby
DocType: Bank Account,Integration Details,Podrobnosti o integrácii
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS profil je potrebný na zadanie POS vstupu
DocType: Education Settings,Enable LMS,Povoliť LMS
DocType: POS Closing Voucher,Sales Invoices Summary,Súhrn predajných faktúr
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Benefit,výhoda
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Balance Sheet account,Úverový účet musí byť účet súvahy
DocType: Call Log,Duration,trvanie
DocType: Lab Test Template,Descriptive,opisný
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select Price List,Vyberte prosím Cenník
DocType: Payment Reconciliation,From Invoice Date,Od dátumu faktúry
DocType: Education Settings,Validate Batch for Students in Student Group,Overiť dávku pre študentov v študentskej skupine
DocType: Leave Policy,Leave Allocations,Opustiť pridelenia
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js,Score cannot be greater than Maximum Score,Skóre nemôže byť väčšie ako maximálne skóre
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,BOM is not specified for subcontracting item {0} at row {1},Rozpiska nie je zadaná pre položku subdodávky {0} v riadku {1}
DocType: Item,Automatically Create New Batch,Automaticky vytvoriť novú dávku
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() accepted invalid IBAN {},BankAccount.validate_iban () prijal neplatný IBAN {}
DocType: Restaurant Menu,Price List (Auto created),Cenník (automatické vytvorenie)
DocType: Customer,Credit Limit and Payment Terms,Úverový limit a platobné podmienky
apps/erpnext/erpnext/stock/doctype/item/item.js,Show Variants,Zobraziť varianty
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Prosím nastavte „Zisk / strata na likvidácii majetku“ v spoločnosti {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Slip of employee {0} already created for time sheet {1},Platový sklz zamestnanca {0} už bol vytvorený pre časový výkaz {1}
apps/erpnext/erpnext/config/projects.py,Timesheet for tasks.,Časový rozvrh úloh.
DocType: Purchase Invoice,Rounded Total (Company Currency),Zaokrúhlené celkom (mena spoločnosti)
apps/erpnext/erpnext/config/website.py,Settings for website product listing,Nastavenia pre zoznam produktov webových stránok
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Successfully Set Supplier,Úspešne nastaviť dodávateľa
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čiatku zmluvy nemôže byť väčší alebo rovný dátumu ukončenia.
,Item Prices,Položka Ceny
DocType: Products Settings,Product Page,Stránka produktu
DocType: Amazon MWS Settings,Market Place ID,ID miesta na trhu
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Production Order has been {0},Výrobná zákazka bola {0}
DocType: Employee Benefit Application,Employee Benefit Application,Aplikácia Zamestnanecká výhoda
DocType: BOM Item,Item operation,Prevádzka položky
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Received,Čiastočne prijaté
DocType: Landed Cost Voucher,MAT-LCV-.YYYY.-,MAT-LCV-.YYYY.-
DocType: Employee Advance,Due Advance Amount,Výška preddavku
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,Celkový počet pridelených listov {0} nemôže byť nižší ako počet schválených listov {1} za dané obdobie
DocType: Email Digest,New Purchase Orders,Nové objednávky
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Item: {0} does not exist in the system,Položka: {0} v systéme neexistuje
DocType: Loan Application,Loan Info,Informácie o úvere
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Skúste naplánovať operácie na X dní vopred.
DocType: Serial No,Is Cancelled,Zrušené
DocType: Request for Quotation,For individual supplier,Pre jednotlivých dodávateľov
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Min Qty can not be greater than Max Qty,Min Qty nemôže byť väčší ako Max Qty
DocType: Soil Texture,Loamy Sand,Hlinitý piesok
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Riadok {0}: Platba proti predajnej / nákupnej objednávke by mala byť vždy označená ako záloha
DocType: Item,"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.","Príklad: ABCD. #####. Ak je séria nastavená a číslo dávky nie je uvedené v transakciách, potom sa na základe tejto série vytvorí automatické číslo dávky. Ak chcete pre túto položku vždy výslovne uviesť číslo šarže, nechajte toto pole prázdne. Poznámka: toto nastavenie má prednosť pred predponou Naming Series v položke Stock Settings."
apps/erpnext/erpnext/config/healthcare.py,Consultation,Konzultácia
DocType: Item,Item Defaults,Predvolené položky
DocType: Sales Invoice,Total Commission,Komisia spolu
DocType: Hotel Room,Hotel Room,Hotelová izba
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,{0} hours,{0} hodín
apps/erpnext/erpnext/controllers/buying_controller.py,Serial no is mandatory for the item {0},Pre položku {0} je povinné sériové číslo
DocType: Company,Standard Template,Štandardná šablóna
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í sú nekonzistentné
DocType: Project,Start and End Dates,Dátumy začiatku a konca
DocType: Supplier Scorecard,Notify Employee,Upozorniť zamestnanca
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Software,softvér
DocType: Program,Allow Self Enroll,Povoliť vlastnú registráciu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Expenses,Náklady na zásoby
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference No is mandatory if you entered Reference Date,"Referenčné číslo je povinné, ak ste zadali referenčný dátum"
DocType: Training Event,Workshop,Dielňa
DocType: Stock Settings,Auto insert Price List rate if missing,"Automaticky vložiť sadzbu cenníka, ak chýba"
DocType: Course Content,Course Content,Obsah kurzu
DocType: Purchase Order Item,Material Request Item,Položka požiadavky materiálu
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Účel údržby
DocType: Designation,Skills,zručností
DocType: Asset,Out of Order,Mimo prevádzky
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Available {0},K dispozícii {0}
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js,Select Customer,Vyberte položku Zákazník
DocType: Projects Settings,Ignore Workstation Time Overlap,Ignorovať časové prekrytie pracovnej stanice
DocType: Shareholder,Hidden list maintaining the list of contacts linked to Shareholder,Skrytý zoznam zachovávajúci zoznam kontaktov prepojených s akcionárom
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","Odstráňte zamestnanca <a href=""#Form/Employee/{0}"">{0},</a> ak chcete tento dokument zrušiť"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Same item has been entered multiple times,Rovnaká položka bola zadaná viackrát
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} is under maintenance contract upto {1},Sériové číslo {0} je na základe zmluvy o údržbe až {1}
DocType: Bin,FCFS Rate,Miera FCFS
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Negative Quantity is not allowed,Negatívne množstvo nie je povolené
DocType: Quotation Item,Planning,plánovanie
DocType: Marketplace Settings,Marketplace URL (to hide and update label),Adresa URL Marketplace (na skrytie a aktualizáciu menovky)
DocType: Item Group,Parent Item Group,Skupina rodičovských položiek
DocType: Bank,Data Import Configuration,Konfigurácia importu dát
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Avg. Buying Price List Rate,Avg. Nákup Cenník sadzba
,Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC]
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,Row #{0}: Timings conflicts with row {1},Riadok # {0}: Časovanie je v rozpore s riadkom {1}
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customers,Opakovať zákazníkov
DocType: Fee Schedule,Fee Schedule,Harmonogram poplatkov
DocType: Quality Inspection Reading,Reading 10,Čítanie 10
apps/erpnext/erpnext/config/help.py,Setting up Employees,Nastavenie zamestnancov
DocType: Selling Settings,Settings for Selling Module,Nastavenia pre modul predaja
DocType: Payment Reconciliation,Reconcile,zmieriť
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 rozdielu musí byť účtom typu aktív / pasív, pretože tento záznam o vstupe je vstupnou položkou"
apps/erpnext/erpnext/accounts/report/financial_statements.py,End Year cannot be before Start Year,Koncový rok nemôže byť pred začiatkom roka
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: Task,Parent Task,Rodičovská úloha
DocType: Attendance,Attendance Request,Žiadosť o účasť
DocType: Item,Moving Average,Pohyblivý priemer
DocType: Employee Attendance Tool,Unmarked Attendance,Neoznačená účasť
DocType: Homepage Section,Number of Columns,Počet stĺpcov
DocType: Issue Priority,Issue Priority,Priorita vydania
DocType: Holiday List,Add Weekly Holidays,Pridať týždenné prázdniny
DocType: Shopify Log,Shopify Log,Shopify Log
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Salary Slip,Vytvorte platový sklz
DocType: Customs Tariff Number,Customs Tariff Number,Číslo colného sadzobníka
DocType: Job Offer Term,Value / Description,Hodnota / Popis
DocType: Warranty Claim,Issue Date,Dátum vydania
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,"Vyberte dávku pre položku {0}. Nemožno nájsť jednu dávku, ktorá spĺňa túto požiadavku"
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py,Cannot create Retention Bonus for left Employees,Nie je možné vytvoriť bonus na ponechanie pre ľavých zamestnancov
DocType: Employee Checkin,Location / Device ID,ID lokality / zariadenia
DocType: Purchase Order,To Receive,Obdržať
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ť znova načítať, kým nebudete mať sieť."
DocType: Course Activity,Enrollment,Zápis
DocType: Lab Test Template,Lab Test Template,Laboratórna testovacia šablóna
,Employee Birthday,Narodeniny zamestnancov
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Max: {0},Max: {0}
apps/erpnext/erpnext/regional/italy/utils.py,E-Invoicing Information Missing,Chýbajú informácie o elektronickej fakturácii
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No material request created,Nebola vytvorená žiadna požiadavka na materiál
DocType: Loan,Total Amount Paid,Celková suma zaplatená
DocType: Bank Account,Is the Default Account,Je predvolený účet
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,All these items have already been invoiced,Všetky tieto položky už boli fakturované
DocType: Training Event,Trainer Name,Meno trénera
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Project Manager,Projektový manažér
DocType: Travel Itinerary,Non Diary,Non Diary
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shares don't exist with the {0},Akcie s {0} neexistujú
DocType: Lab Test,Test Group,Testovacia skupina
DocType: Subscription,Number of days that the subscriber has to pay invoices generated by this subscription,"Počet dní, počas ktorých musí účastník zaplatiť faktúry vygenerované týmto predplatným"
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,Please set Unrealized Exchange Gain/Loss Account in Company {0},Nastavte účet nerealizovaných výmen / strát v spoločnosti {0}
DocType: Payroll Entry,Select Payment Account to make Bank Entry,"Vyberte položku Platobný účet, aby ste zadali bankový účet"
apps/erpnext/erpnext/hub_node/api.py,No items to publish,Žiadne položky na publikovanie
DocType: Supplier Scorecard,Scoring Setup,Nastavenie bodovania
DocType: Salary Slip,Total Interest Amount,Celková úroková suma
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},Dátum začiatku fiškálneho roka a dátum ukončenia fiškálneho roka sú už stanovené vo fiškálnom roku {0}
apps/erpnext/erpnext/projects/report/billing_summary.py,Billable Hours,Fakturovateľné hodiny
apps/erpnext/erpnext/config/accounting.py,Accounting Masters,Účtovníctvo majstrov
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge with Existing Account,Zlúčenie s existujúcim účtom
DocType: Lead,Lost Quotation,Stratená ponuka
DocType: Email Digest,Note: Email will not be sent to disabled users,Poznámka: E-mail nebude odoslaný postihnutým používateľom
apps/erpnext/erpnext/config/settings.py,"Create and manage daily, weekly and monthly email digests.","Vytvárať a spravovať denné, týždenné a mesačné prehľady e-mailov."
DocType: Academic Term,Academic Year,Akademický rok
DocType: Sales Stage,Stage Name,Pseudonym
DocType: SMS Center,All Employee (Active),Všetci zamestnanci (aktívni)
DocType: Accounting Dimension,Accounting Dimension,Účtovná dimenzia
DocType: Project,Customer Details,Detaily zákazníka
DocType: Buying Settings,Default Supplier Group,Predvolená skupina dodávateľov
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please cancel Purchase Receipt {0} first,Najskôr najprv zrušte nákupný doklad {0}
DocType: Bank Transaction Mapping,Field in Bank Transaction,Pole v transakcii banky
apps/erpnext/erpnext/controllers/accounts_controller.py,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Poplatok typu &#39;Skutočné&#39; v riadku {0} nie je možné zahrnúť do sadzby položky
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Business Development Manager,Business Development Manager
DocType: Agriculture Task,Urgent,naliehavý
DocType: Shipping Rule Condition,From Value,Od hodnoty
DocType: Asset Maintenance Task,Next Due Date,Ďalší dátum splatnosti
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Buy,kúpiť
apps/erpnext/erpnext/projects/doctype/task/task.py,Progress % for a task cannot be more than 100.,Pokrok% pre úlohu nemôže byť väčší ako 100.
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Number of root accounts cannot be less than 4,Počet koreňových účtov nemôže byť menší ako 4
DocType: Item,Website Item Groups,Skupiny položiek webovej stránky
DocType: Certified Consultant,Certified Consultant,Certifikovaný konzultant
DocType: Driving License Category,Class,Trieda
DocType: Asset,Sold,predávané
apps/erpnext/erpnext/accounts/party.py,There can only be 1 Account per Company in {0} {1},V službe {0} {1} môže byť iba 1 účet na spoločnosť
DocType: GL Entry,Against,proti
DocType: Company,Default Deferred Expense Account,Predvolený účet odložených výdavkov
DocType: Stock Settings,Auto Material Request,Automatická požiadavka na materiál
DocType: Marketplace Settings,Sync in Progress,Prebieha synchronizácia
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,"Nezistil sa žiadny výplatný list, ktorý by sa predložil pre vyššie uvedené kritériá ALEBO už predložený výplatný list"
apps/erpnext/erpnext/config/settings.py,Create rules to restrict transactions based on values.,Vytvorte pravidlá na obmedzenie transakcií na základe hodnôt.
DocType: Products Settings,Enable Field Filters,Povoliť filtre polí
DocType: Loan,Loan Amount,Výška pôžičky
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Miscellaneous Expenses,Rôzne výdavky
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the public administration '%s',"Prosím, nastavte fiškálny kód pre verejnú správu „% s“"
apps/erpnext/erpnext/config/retail.py,Setup mode of POS (Online / Offline),Režim nastavenia POS (Online / Offline)
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Používateľ {0} nemá predvolený profil POS. Pre tohto používateľa začiarknite políčko Predvolené v riadku {1}.
DocType: Department,Leave Block List,Ponechajte zoznam blokov
apps/erpnext/erpnext/healthcare/page/patient_history/patient_history.html,Select Patient,Vyberte položku Pacient
DocType: Attendance,Leave Type,Typ ponechania
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Creating student groups,Vytváranie skupín študentov
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Plants and Machineries,Rastliny a stroje
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Not Marked,Nie je označené
DocType: Bank Statement Transaction Invoice Item,Purchase Invoice,Nákupná faktúra
DocType: GL Entry,Is Opening,Otvára sa
DocType: Accounts Settings,Accounts Settings,Nastavenia účtov
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Actual Qty: Quantity available in the warehouse.,Skutočné množstvo: Množstvo dostupné v sklade.
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expires On,Vyprší
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Accounting Entry for Asset,Účtovná položka pre majetok
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Plán kurzu
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cost Center with existing transactions can not be converted to ledger,Nákladové stredisko s existujúcimi transakciami nie je možné previesť na účtovnú knihu
,Bank Clearance Summary,Zhrnutie bankového zúčtovania
DocType: SMS Center,SMS Center,SMS centrum
DocType: Pricing Rule,Threshold for Suggestion,Prahová hodnota pre návrh
DocType: Stock Entry,Sales Invoice No,Predajná faktúra č
DocType: Project Update,Project Update,Aktualizácia projektu
DocType: Student Sibling,Student ID,Študentská karta
,Pending SO Items For Purchase Request,Čakajúce položky SO na objednávku
DocType: Task,Timeline,časová os
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ú spoločnosť
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfigurovať {0}
DocType: Employee,Contact Details,Kontaktné údaje
apps/erpnext/erpnext/utilities/user_progress.py,Classrooms/ Laboratories etc where lectures can be scheduled.,Učebne / Laboratóriá atď.
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Cannot cancel because submitted Stock Entry {0} exists,"Nie je možné zrušiť, pretože odoslaná položka položky {0} existuje"
DocType: Exchange Rate Revaluation Account,Balance In Account Currency,Zostatok v mene účtu
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Close the POS,Zatvorte POS
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"For {0}, only credit accounts can be linked against another debit entry",Pre položku {0} sa môžu prepojiť iba iné úverové účty s iným debetným záznamom
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Pharmaceutical,farmaceutické
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.py,Please set account heads in GST Settings for Compnay {0},Nastavte hlavy účtu v nastaveniach GST pre Compnay {0}
DocType: Program Enrollment,Boarding Student,Stravovanie Študent
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js,Total Contribution Amount: {0},Celková výška príspevku: {0}
DocType: Item Alternative,Two-way,obojsmerný
DocType: Appraisal,Appraisal,ocenenie
DocType: Plaid Settings,Plaid Settings,Nastavenia Plaid
apps/erpnext/erpnext/controllers/trends.py,Fiscal Year: {0} does not exists,Fiškálny rok: {0} neexistuje
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Create Employee,Vytvoriť zamestnanca
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Structures have been assigned successfully,Štruktúry boli úspešne priradené
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Expenses,Priame náklady
DocType: Support Search Source,Result Route Field,Pole Výsledok trasy
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,There is not enough leave balance for Leave Type {0},Nedostatočný zostatok na dovolenku pre typ dovolenky {0}
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}) nebol nájdený pre položku: {2}
DocType: Material Request Plan Item,Actual Qty,Skutočné množstvo
DocType: Purchase Invoice,Supplier Invoice Date,Dátum dodávateľskej faktúry
DocType: Depreciation Schedule,Finance Book Id,Id finančnej knihy
DocType: Exchange Rate Revaluation Account,Current Exchange Rate,Aktuálny výmenný kurz
DocType: Account,Equity,spravodlivosť
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}: Typ referenčného dokumentu musí byť jeden z zákazky odberateľa, faktúry predaja alebo položky denníka"
apps/erpnext/erpnext/utilities/user_progress.py,Explore Sales Cycle,Preskúmajte cyklus predaja
DocType: Shopify Log,Request Data,Údaje o požiadavke
DocType: Quality Procedure,Quality Procedure,Postup kvality
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Email sent to supplier {0},E-mail zaslaný dodávateľovi {0}
,Course wise Assessment Report,Správa o hodnotení múdrosti
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Automotive,automobilový priemysel
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},Riadok {0}: Pridelená suma {1} musí byť nižšia alebo rovná fakturovanej zostatkovej čiastke {2}
DocType: Student Report Generation Tool,Total Parents Teacher Meeting,Stretnutie učiteľov rodičov
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 suroviny {1}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Posting timestamp must be after {0},Časová značka zaúčtovania musí byť po {0}
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Please mention the Lead Name in Lead {0},"Uveďte, prosím, úvodné meno v úvode {0}"
DocType: Employee,You can enter any date manually,Môžete zadať ľubovoľný dátum manuálne
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Položka Zosúladenie zásob
DocType: Shift Type,Early Exit Consequence,Dôsledok predčasného ukončenia
DocType: Item Group,General Settings,Všeobecné nastavenia
apps/erpnext/erpnext/accounts/party.py,Due Date cannot be before Posting / Supplier Invoice Date,Dátum splatnosti nemôže byť pred dátumom účtovania / fakturácie dodávateľa
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.
apps/erpnext/erpnext/config/healthcare.py,Record Patient Vitals,Zaznamenajte vitality pacienta
DocType: Shopping Cart Settings,Show Configure Button,Zobraziť tlačidlo Konfigurovať
DocType: Industry Type,Industry Type,Typ priemyslu
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,Nie je možné vybrať typ poplatku ako „On Previous Row Amount“ alebo „On Previous Row Total“ pre prvý riadok
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shares already exist,Akcie už existujú
DocType: Work Order Item,Available Qty at WIP Warehouse,K dispozícii v sklade WIP Warehouse
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Resolve error and upload again.,Vyriešte chybu a znova odovzdajte.
DocType: Travel Request,Copy of Invitation/Announcement,Kópia pozvania / oznámenia
DocType: Healthcare Service Unit,Healthcare Service Unit,Služba zdravotnej starostlivosti
apps/erpnext/erpnext/controllers/trends.py,Total(Qty),Celkom (ks)
DocType: Employee,Health Insurance No,Zdravotné poistenie č
DocType: Supplier Scorecard Scoring Standing,Max Grade,Max Grade
DocType: Department Approver,Approver,schvaľovateľa
,Sales Order Trends,Trendy zákazky odberateľa
DocType: Asset Repair,Repair Cost,Náklady na opravu
apps/erpnext/erpnext/accounts/general_ledger.py,Please mention Round Off Account in Company,"Uveďte, prosím, Round Off Account v spoločnosti"
DocType: Payroll Entry,Select Payroll Period,Vyberte Mzdové obdobie
DocType: Price List,Price List Name,Názov cenníka
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,You can only submit Leave Encashment for a valid encashment amount,Odmena za odoslanie môžete zaplatiť len za platnú sumu
DocType: Pricing Rule,"Higher the number, higher the priority","Vyššie číslo, vyššia priorita"
DocType: Designation,Required Skills,Požadované zručnosti
DocType: Marketplace Settings,Disable Marketplace,Zakázať Trh
DocType: Budget,Action if Annual Budget Exceeded on Actual,Činnosť v prípade prekročenia skutočného ročného rozpočtu
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as {1} on leave.,Účasť nebola predložená na {0} ako {1} na dovolenke.
DocType: Pricing Rule,Promotional Scheme Id,Id propagačnej schémy č
DocType: Driver,License Details,Detaily licencie
DocType: Cash Flow Mapper,e.g Adjustments for:,napr. úpravy pre:
DocType: Selling Settings,Default Quotation Validity Days,Predvolené dni platnosti ponuky
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,"Bank Account, From Date and To Date are Mandatory","Bankový účet, dátum a dátum sú povinné"
DocType: Travel Request Costing,Expense Type,Typ nákladov
DocType: Account,Auditor,kontrolór
apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html,Payment Confirmation,Potvrdenie platby
,Available Stock for Packing Items,Dostupný sklad pre položky balenia
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please remove this Invoice {0} from C-Form {1},Odstráňte túto faktúru {0} z formulára C {1}
DocType: Shift Type,Every Valid Check-in and Check-out,Každá platná registrácia a odhlásenie
DocType: Support Search Source,Query Route String,Reťazec dotazu trasy
DocType: Customer Feedback Template,Customer Feedback Template,Šablóna spätnej väzby od zákazníkov
apps/erpnext/erpnext/config/selling.py,Quotes to Leads or Customers.,Citáty pre vedúcich alebo zákazníkov.
DocType: Driver,Transporter,prepravca
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Slip of employee {0} already created for this period,Platový sklz zamestnanca {0} je už vytvorený pre toto obdobie
apps/erpnext/erpnext/controllers/selling_controller.py,To {0} | {1} {2},Do {0} | {1} {2}
DocType: Leave Block List Date,Block Date,Dátum bloku
DocType: Sales Team,Contact No.,Kontaktné číslo
DocType: Manufacturing Settings,Overproduction Percentage For Work Order,Percento nadprodukcie pre pracovný príkaz
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Enroll,zapísať
DocType: Quotation Lost Reason,Quotation Lost Reason,Citát Lost Reason
,Employee Billing Summary,Prehľad fakturácie zamestnanca
apps/erpnext/erpnext/config/settings.py,Country wise default Address Templates,Predvolené šablóny adresy krajiny
DocType: Cost Center,Parent Cost Center,Centrum rodičovských nákladov
DocType: Pricing Rule,Apply Rule On Item Group,Použiť skupinu pravidiel na položku
apps/erpnext/erpnext/utilities/user_progress.py,Example: Basic Mathematics,Príklad: Základná matematika
DocType: Expense Claim,Total Amount Reimbursed,Celková refundovaná suma
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Validity period of this quotation has ended.,Platnosť tejto ponuky sa skončila.
,Item-wise Sales History,História predaja podľa položiek
DocType: Employee,Personal Email,Osobný e-mail
DocType: Bank Reconciliation Detail,Cheque Date,Dátum kontroly
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: Lead,Next Contact Date,Nasledujúci dátum kontaktu
DocType: Membership,Membership,členstva
DocType: Buying Settings,Default Buying Price List,Predvolený nákupný cenník
DocType: Asset,Depreciation Method,Metóda odpisovania
DocType: Travel Request,Travel Request,Žiadosť o cestovanie
apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} vytvorené varianty.
DocType: Healthcare Settings,Avoid Confirmation,Vyhnite sa potvrdeniu
DocType: Serial No,Under AMC,Pod AMC
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}","Sklad je vyžadovaný v riadku č. {0}, nastavte predvolený sklad pre položku {1} pre spoločnosť {2}"
DocType: Authorization Control,Authorization Control,Kontrola autorizácie
,Daily Work Summary Replies,Odpovede na dennú prácu
apps/erpnext/erpnext/projects/doctype/project/project.py,You have been invited to collaborate on the project: {0},Boli ste pozvaní na spoluprácu na projekte: {0}
DocType: Issue,Response By Variance,Odpoveď podľa variácie
DocType: Item,Sales Details,Podrobnosti o predaji
apps/erpnext/erpnext/config/settings.py,Letter Heads for print templates.,Letter Heads pre tlačové šablóny.
DocType: Salary Detail,Tax on additional salary,Daň z dodatočného platu
apps/erpnext/erpnext/public/js/setup_wizard.js,Attach Logo,Pripojiť logo
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,For row {0}: Enter Planned Qty,Pre riadok {0}: Zadajte plánované množstvo
DocType: Asset Settings,Calculate Prorated Depreciation Schedule Based on Fiscal Year,Výpočet Prorated Odpisový plán Na základe fiškálneho roka
apps/erpnext/erpnext/config/crm.py,Logs for maintaining sms delivery status,Záznamy pre zachovanie stavu doručenia sms
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Current Job Openings,Aktuálne pracovné miesta
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Pravidlo určovania cien sa najprv vyberie na základe políčka „Použiť na“, ktorým môže byť položka Položka, Skupina položiek alebo Značka."
DocType: Purchase Receipt,Add / Edit Taxes and Charges,Pridať / upraviť dane a poplatky
DocType: Item,Supply Raw Materials for Purchase,Dodávka surovín na nákup
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal Writing,Písanie návrhu
DocType: Landed Cost Item,Purchase Receipt Item,Položka príjemky
DocType: Production Plan,Get Sales Orders,Získať zákazky odberateľa
DocType: Pricing Rule,Selling,predajné
DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Zabránenie objednávkam
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Print and Stationery,Tlač a písacie potreby
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Buying,Prepravné pravidlo platí len pre nákup
apps/erpnext/erpnext/templates/includes/product_list.js,No products found.,Nenašli sa žiadne produkty.
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,Riadok {0}: Prosím nastavte na Daňové oslobodenie Dôvod v dane z obratu a poplatkov
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Group: ,Posudzovacia skupina:
DocType: Tally Migration,Parties,strany
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Show exploded view,Zobraziť rozložené zobrazenie
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,No Delivery Note selected for Customer {},Pre zákazníka {} nie je vybratá žiadna poznámka o doručení
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,End on,Ukončiť
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 s vyššou hodnotou ako Grand Total.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Designer,návrhár
DocType: QuickBooks Migrator,Default Warehouse,Predvolený sklad
DocType: Company,Default Cash Account,Predvolený účet v hotovosti
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please enter Reference date,Zadajte referenčný dátum
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Item {0} must be a stock Item,Položka {0} musí byť položka položky
DocType: POS Profile,Print Format for Online,Formát tlače pre online
,Employee Leave Balance,Zostatok zamestnancov
DocType: Projects Settings,Ignore User Time Overlap,Ignorovať prekrytie času používateľa
DocType: Stock Entry,As per Stock UOM,Podľa zásob UOM
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cost Center with existing transactions can not be converted to group,Nákladové stredisko s existujúcimi transakciami nemožno konvertovať na skupinu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,cannot be greater than 100,nemôže byť väčšia ako 100
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Please Delivery Note first,Najprv dodací list
DocType: Leave Type,Leave Type Name,Nechajte názov typu
DocType: Homepage Featured Product,Homepage Featured Product,Domovská stránka Odporúčaný produkt
DocType: Assessment Plan,Examiner Name,Meno skúšajúceho
,Hotel Room Occupancy,Obsadenosť hotelovej izby
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Telecommunications,telekomunikácie
DocType: Certification Application,Certification Application,Žiadosť o certifikáciu
apps/erpnext/erpnext/stock/doctype/item/item.py,Website Image should be a public file or website URL,Obrázok webovej stránky by mal byť verejný súbor alebo adresa URL webovej stránky
apps/erpnext/erpnext/utilities/user_progress.py,Your Suppliers,Vaši dodávatelia
DocType: Appraisal Goal,Weightage (%),Váha (%)
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inter-State Supplies,Medzištátne dodávky
DocType: Fees,Send Payment Request,Odoslať žiadosť o platbu
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} is not added in the table,{0} nie je pridané do tabuľky
apps/erpnext/erpnext/controllers/stock_controller.py,Quality Inspection required for Item {0} to submit,Kontrola kvality vyžadovaná na predloženie položky {0}
apps/erpnext/erpnext/utilities/activation.py,Create Student,Vytvoriť študenta
apps/erpnext/erpnext/config/projects.py,Gantt chart of all tasks.,Ganttov diagram všetkých úloh.
DocType: Department,Leave Approvers,Nechajte schvaľovateľov
DocType: BOM,Materials Required (Exploded),Požadované materiály (rozložené)
DocType: Loan,Repay Over Number of Periods,Splácať počet období
DocType: Account,Receivable,pohľadávka
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py,Price List must be applicable for Buying or Selling,Cenník musí byť platný pre nákup alebo predaj
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Resend Payment Email,Znova odoslať platobný e-mail
apps/erpnext/erpnext/regional/italy/utils.py,Please set {0} for address {1},Nastavte adresu {0} pre adresu {1}
DocType: Stock Entry,Default Source Warehouse,Predvolený zdrojový sklad
DocType: Timesheet Detail,Bill,zmenka
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplikátne číslo pre študenta {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Batch {0} of Item {1} has expired.,Dávka {0} položky {1} vypršala.
DocType: Lab Test,Approved Date,Schválený dátum
DocType: Item Group,Item Tax,Položka Daň
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Cannot transfer Employee with status Left,Nemožno preniesť zamestnanca so stavom vľavo
DocType: BOM,Total Cost,Celkové náklady
DocType: Request for Quotation Supplier,Quote Status,Stav ponuky
DocType: Employee Education,Qualification,kvalifikácia
DocType: Complaint,Complaints,sťažnosti
DocType: Item,Is Purchase Item,Je položka nákupu
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Purchase Receipt,Potvrdenie o kúpe
DocType: Subscription,Trial Period Start Date,Dátum začatia skúšobného obdobia
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Credit Balance,Stav účtu
DocType: Employee Benefit Application,Payroll Period,Mzdové obdobie
apps/erpnext/erpnext/config/buying.py,Supplier database.,Databáza dodávateľov.
DocType: Tax Rule,Tax Type,Typ dane
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Move Item,Presunúť položku
DocType: Job Opening,Description of a Job Opening,Popis otvorenia úlohy
apps/erpnext/erpnext/utilities/activation.py,Create Users,Vytvoriť používateľov
DocType: Global Defaults,Current Fiscal Year,Aktuálny fiškálny rok
DocType: Item,Hub Warehouse,Skladový sklad
DocType: Purchase Invoice,Tax Breakup,Daňové porušenie
DocType: Job Card,Material Transferred,Prevedený materiál
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Nie ste oprávnení pridávať alebo aktualizovať položky pred {0}
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date of Birth cannot be greater than today.,Dátum narodenia nemôže byť väčší ako dnes.
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Number of serial nos and quantity must be the same,Počet sériových čísiel a množstiev musí byť rovnaký
DocType: Company,Exception Budget Approver Role,Výnimka pre schvaľovateľa rozpočtu
DocType: Fee Schedule,In Process,V procese
DocType: Daily Work Summary Group,Send Emails At,Odoslať e-maily na adrese
apps/erpnext/erpnext/public/js/hub/hub_call.js,Marketplace Error,Chyba na trhu
DocType: Salary Slip,Working Days,Pracovné dni
DocType: Bank Guarantee,Margin Money,Margin Money
DocType: Chapter,Chapter,kapitola
DocType: Purchase Receipt Item Supplied,Current Stock,Aktuálny stav
DocType: Employee,History In Company,História spoločnosti
DocType: Purchase Invoice Item,Manufacturer,Výrobca
apps/erpnext/erpnext/healthcare/setup.py,Moderate Sensitivity,Mierna citlivosť
DocType: Compensatory Leave Request,Leave Allocation,Opustiť pridelenie
apps/erpnext/erpnext/projects/doctype/task/task.js,Timesheet,pracovný výkaz
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation already used for another company,Skratka už použitá pre inú spoločnosť
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Please select Patient to get Lab Tests,"Vyberte možnosť Pacient, aby ste získali laboratórne testy"
DocType: Purchase Order,Advance Paid,Platba vopred
DocType: Supplier Scorecard,Load All Criteria,Načítať všetky kritériá
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
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Creditors,veritelia
DocType: Warranty Claim,Raised By,Navýšené
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 sú povinné pre bankovú transakciu
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 celkového vynaloženého množstva môže existovať viacnásobný faktor. Konverzný faktor pre vykúpenie bude vždy rovnaký pre všetky úrovne.
DocType: Purchase Invoice Item,Batch No,Dávka č
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Executive Search,Výkonné vyhľadávanie
DocType: Company,Stock Adjustment Account,Účet úpravy zásob
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Gross Profit %,Hrubý zisk %
DocType: Lead,Request Type,Typ požiadavky
DocType: Patient Appointment,Reminded,pripomenul
DocType: Accounts Settings,Billing Address,Fakturačná adresa
DocType: Student Leave Application,Mark as Present,Označiť ako súčasný
DocType: Landed Cost Voucher,Landed Cost Voucher,Doklad o nákladoch na pristátie
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Total working hours should not be greater than max working hours {0},Celkový pracovný čas by nemal byť väčší ako maximálny pracovný čas {0}
DocType: Communication Medium Timeslot,Communication Medium Timeslot,Komunikačné médium Timeslot
apps/erpnext/erpnext/config/selling.py,Customer Addresses And Contacts,Adresy zákazníkov a kontakty
DocType: Project,Task Progress,Úloha Úloha
DocType: Journal Entry,Opening Entry,Otvorenie vstupu
DocType: Bank Guarantee,Charges Incurred,Vzniknuté poplatky
DocType: Shift Type,Working Hours Calculation Based On,Výpočet pracovných hodín na základe
DocType: Work Order,Material Transferred for Manufacturing,Materiál prevedený na výrobu
DocType: Products Settings,Hide Variants,Skryť varianty
DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Zakázať plánovanie kapacity a sledovanie času
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Vypočíta sa v transakcii.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} is required for 'Balance Sheet' account {1}.,Pre účet „Súvaha“ {1} sa vyžaduje {0}.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} not allowed to transact with {1}. Please change the Company.,"{0} nie je povolené s {1} obchodovať. Prosím, zmeňte spoločnosť."
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 nákupný príjem povinný == &#39;ÁNO&#39;, potom na vytvorenie nákupnej faktúry je potrebné, aby používateľ najprv vytvoril nákupný doklad pre položku {0}"
DocType: Delivery Trip,Delivery Details,detaily doručenia
DocType: Inpatient Record,Discharge Scheduled,Plánovaný výboj
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,"Reference: {0}, Item Code: {1} and Customer: {2}","Odkaz: {0}, Kód položky: {1} a zákazník: {2}"
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Caution,pozor
DocType: Project User,View attachments,Zobrazenie príloh
DocType: Manufacturing Settings,Allow Production on Holidays,Povoliť výrobu na sviatky
apps/erpnext/erpnext/config/accounting.py,Update Bank Transaction Dates,Aktualizovať dátumy bankovej transakcie
DocType: Quality Inspection Reading,Reading 4,Čítanie 4
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Item {0} has no Serial No. Only serilialized items \
						can have delivery based on Serial No",Položka {0} nemá žiadne sériové číslo Len sériové položky môžu mať doručenie na základe sériového čísla
DocType: Program Course,Program Course,Programový kurz
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefónne výdavky
DocType: Patient,Widow,vdova
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Number of Interaction,Počet interakcií
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}","Pravidlá viacerých cien existujú s rovnakými kritériami, vyriešte prosím konflikt priradením priority. Cenové pravidlá: {0}"
apps/erpnext/erpnext/config/accounting.py,Cost Center and Budgeting,Nákladové stredisko a rozpočtovanie
,Ordered Items To Be Delivered,Objednané položky budú dodané
DocType: Homepage Section Card,Homepage Section Card,Karta Domáca sekcia
DocType: Account,Depreciation,znehodnotenie
DocType: Guardian,Interests,záujmy
DocType: Purchase Receipt Item Supplied,Consumed Qty,Spotreba Množstvo
DocType: Education Settings,Education Manager,Manažér vzdelávania
DocType: Employee Checkin,Shift Actual Start,Shift Skutočné spustenie
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Plánovanie časových záznamov mimo pracovných hodín pracovnej stanice.
apps/erpnext/erpnext/public/js/utils.js,Loyalty Points: {0},Vernostné body: {0}
DocType: Healthcare Settings,Registration Message,Registrácia Správa
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"
apps/erpnext/erpnext/accounts/page/pos/pos.js,Serial no item cannot be a fraction,Sériová žiadna položka nemôže byť zlomok
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Sklad nie je možné zmazať, pretože pre tento sklad existuje záznam knihy akcií."
apps/erpnext/erpnext/templates/pages/cart.html,See past quotations,Pozri predchádzajúce citácie
apps/erpnext/erpnext/www/all-products/index.html,Prev,Predchádzajúce
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Unit of Measure,Merná jednotka
DocType: Lab Test,Test Template,Testovacia šablóna
DocType: Fertilizer,Fertilizer Contents,Obsah hnojiva
DocType: Quality Meeting Minutes,Minute,minúta
apps/erpnext/erpnext/controllers/accounts_controller.py,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Riadok # {0}: Nie je možné odoslať položku {1}, je už {2}"
DocType: Task,Actual Time (in Hours),Aktuálny čas (v hodinách)
DocType: Period Closing Voucher,Closing Account Head,Uzávierka účtov
DocType: Purchase Invoice,Shipping Rule,Pravidlo odoslania
DocType: Shipping Rule,Net Weight,Cista hmotnost
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: POS Closing Voucher Invoices,Quantity of Items,Množstvo položiek
DocType: Warehouse,PIN,PIN
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab testing datetime cannot be before collection datetime,Laboratórne testovanie datetime nemôže byť pred zberom datetime
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Invoice already created for all billing hours,Faktúra už bola vytvorená pre všetky fakturačné hodiny
DocType: Sales Partner,Contact Desc,Kontaktný formulár
DocType: Purchase Invoice,Pricing Rules,Cenové pravidlá
apps/erpnext/erpnext/stock/doctype/item/item.py,"As there are existing transactions against item {0}, you can not change the value of {1}","Keďže existujú transakcie proti položke {0}, nemôžete zmeniť hodnotu {1}"
DocType: Hub Tracked Item,Image List,Zoznam obrázkov
DocType: Item Variant Settings,Allow Rename Attribute Value,Povoliť hodnotu premenovania atribútu
apps/erpnext/erpnext/templates/generators/bom.html,Time(in mins),Čas (v minútach)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Basic,základné
DocType: Loan,Interest Income Account,Účet úrokových výnosov
DocType: Shipping Rule Condition,A condition for a Shipping Rule,Podmienka pre pravidlo o preprave
DocType: Payroll Period Date,Payroll Period Date,Dátum mzdového obdobia
DocType: Employee,Employment Type,typ zamestnania
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Select POS Profile,Vyberte POS profil
DocType: Support Settings,Get Latest Query,Získajte najnovší dopyt
DocType: Employee Incentive,Employee Incentive,Motivácia zamestnancov
DocType: Service Level,Priorities,priority
apps/erpnext/erpnext/config/website.py,Add cards or custom sections on homepage,Pridajte na domovskú stránku karty alebo vlastné sekcie
DocType: Homepage,Hero Section Based On,Hero Sekcia Na
DocType: Project,Total Purchase Cost (via Purchase Invoice),Celková obstarávacia cena (prostredníctvom nákupnej faktúry)
DocType: Staffing Plan Detail,Total Estimated Cost,Celkové odhadované náklady
DocType: Item,"Sales, Purchase, Accounting Defaults","Štandardy predaja, nákupu, účtovníctva"
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Requesting payment against {0} {1} for amount {2},Žiadosť o platbu vo výške {0} {1} za sumu {2}
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Please set the Item Code first,Najprv nastavte kód položky
DocType: Payment Term,Due Date Based On,Dátum splatnosti založený na
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Payment,Nová platba
DocType: Quality Inspection,Incoming,prichádzajúce
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Ordered,Čiastočne objednané
DocType: Delivery Note,Customer's Purchase Order No,Objednávka zákazníka č
apps/erpnext/erpnext/public/js/utils.js,Select Alternate Item,Vyberte možnosť Alternatívna položka
DocType: Employee,Applicable Holiday List,Platný zoznam dovoleniek
DocType: Hub Tracked Item,Hub Tracked Item,Položka sledovania rozbočovača
DocType: Vehicle Log,Service Details,Podrobnosti služby
DocType: Program,Is Featured,Je vybavený
DocType: HR Settings,Don't send Employee Birthday Reminders,Neposielajte upomienky zamestnancov
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Udržať rovnakú sadzbu počas celého predajného cyklu
DocType: Program Enrollment,Transportation,preprava
DocType: Patient Appointment,Date TIme,Dátum Čas
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Vyberte množstvo na riadku
DocType: Employee Benefit Application Detail,Earning Component,Zisk komponent
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Please select Company first,Najskôr vyberte spoločnosť
DocType: Item,Publish Item to hub.erpnext.com,Publikovať položku na adresu hub.erpnext.com
apps/erpnext/erpnext/projects/doctype/project/project.py,Join,pripojiť
DocType: BOM,Set rate of sub-assembly item based on BOM,Nastavte rýchlosť položky podzostavy na základe kusovníka
DocType: Vehicle,Wheels,kolesá
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žky ** do inej ** Položka **. To je užitočné, ak balíčkujete určité položky ** do balíka a udržujete zásoby balených ** položiek ** a nie súhrnný ** Položka **. Balík ** Položka ** bude mať položku &quot;Je položka položky&quot; ako &quot;Nie&quot; a položka &quot;Je položka predaja&quot; ako &quot;Áno&quot;. Napríklad: Ak predávate notebooky a batohy samostatne a majú špeciálnu cenu, ak si zákazník kúpi oboje, potom notebook + batoh bude nový produktový balík. Poznámka: kusovník = kusovník"
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},Ďalší záznam o rozpočte &#39;{0}&#39; už existuje proti {1} &#39;{2}&#39; a účtu &#39;{3}&#39; pre fiškálny rok {4}
DocType: Asset,Purchase Receipt Amount,Výška objednávky
DocType: Issue,Ongoing,pokračujúce
DocType: Service Level Agreement,Agreement Details,Podrobnosti o dohode
DocType: Purchase Invoice,Posting Time,Čas účtovania
DocType: Loyalty Program,Loyalty Program Name,Názov vernostného programu
DocType: Patient,Dormant,spiace
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,{0}: From {1},{0}: Od {1}
DocType: Chart of Accounts Importer,Attach custom Chart of Accounts file,Pripojiť vlastný súbor grafu účtov
apps/erpnext/erpnext/config/help.py,Item Variants,Varianty položky
DocType: Maintenance Visit,Fully Completed,Úplne dokončené
apps/erpnext/erpnext/controllers/item_variant.py,Rename Not Allowed,Premenovať nie je povolené
DocType: Bank Statement Transaction Invoice Item,Transaction Date,dátum transakcie
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,No data for this period,Pre toto obdobie nie sú žiadne údaje
DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,"Keď je tento režim vybraný, predvolený účet bude automaticky aktualizovaný v POS faktúre."
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation cannot have more than 5 characters,Skratka spoločnosti nemôže mať viac ako 5 znakov
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting_list.js,Canceled,zrušený
apps/erpnext/erpnext/utilities/user_progress.py,Customers and Suppliers,Zákazníci a dodávatelia
,To Produce,Na výrobu
DocType: Location,Is Container,Je kontajner
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Research & Development,Výskum a vývoj
DocType: QuickBooks Migrator,Application Settings,Nastavenia aplikácie
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Production Order cannot be raised against a Item Template,Výrobnú zákazku nemožno vzniesť proti šablóne položky
DocType: Work Order,Manufacture against Material Request,Výroba proti žiadosti o materiál
DocType: Blanket Order Item,Ordered Quantity,Objednané množstvo
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Riadok # {0}: Zamietnutý sklad je povinný proti odmietnutej položke {1}
,Received Items To Be Billed,Prijaté položky na fakturáciu
DocType: Attendance,Working Hours,Pracovný čas
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py,Payment Mode,Režim platby
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Purchase Order Items not received on time,Položky objednávky neboli doručené včas
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Duration in Days,Trvanie v dňoch
DocType: Customer,Sales Team Details,Podrobnosti o predajnom tíme
DocType: BOM Update Tool,Replace,vymeniť
DocType: Training Event,Event Name,Názov udalosti
DocType: SMS Center,Receiver List,Zoznam prijímačov
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Cr,Cr
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 udalosť?
DocType: Invoice Discounting,Accounts Receivable Credit Account,Účtovný účet pohľadávok
DocType: Naming Series,Prefix,prefix
DocType: Work Order Operation,Actual Operation Time,Skutočný čas prevádzky
DocType: Purchase Invoice Item,Net Rate,Čistá sadzba
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Čistá zmena v hotovosti
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.py,Set warehouse for Procedure {0} ,Nastaviť sklad pre procedúru {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Block Invoice,Bloková faktúra
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} does not exist,Účet {0}: Rodičovský účet {1} neexistuje
DocType: HR Settings,Encrypt Salary Slips in Emails,Šifrovať platové lístky v e-mailoch
DocType: Supplier Scorecard Scoring Criteria,Score,skóre
DocType: Delivery Note,Driver Name,Názov ovládača
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select Incharge Person's name,"Prosím, vyberte meno osoby, ktorá je príjemcom"
DocType: Employee Training,Training,výcvik
apps/erpnext/erpnext/config/stock.py,Stock Reports,Skladové správy
apps/erpnext/erpnext/stock/doctype/item/item.py,Conversion factor for default Unit of Measure must be 1 in row {0},Prepočítavací faktor pre predvolenú jednotku merania musí byť 1 v riadku {0}
DocType: Course Scheduling Tool,Course Scheduling Tool,Nástroj na plánovanie kurzu
,Finished Goods,Hotové výrobky
DocType: Sales Invoice Item,Customer Warehouse (Optional),Sklad zákazníka (voliteľné)
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Master Data,Synchronizovať kmeňové dáta
DocType: Lead,Address & Contact,Adresa a kontakt
DocType: Bank Reconciliation,To Date,Randiť
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Error in some rows,Chyba v niektorých riadkoch
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/config/accounting.py,Tax Rule for transactions.,Daňové pravidlo pre transakcie.
DocType: Stock Settings,Show Barcode Field,Zobraziť pole čiarového kódu
DocType: Packing Slip Item,DN Detail,DN Detail
DocType: Vital Signs,Fluid,tekutina
DocType: GST Settings,B2C Limit,Limit B2C
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Electronic Equipments,Elektronické vybavenie
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Cannot find active Leave Period,Nie je možné nájsť aktívne obdobie odchodu
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Create Maintenance Visit,Vytvorte návštevu údržby
DocType: Healthcare Service Unit Type,Change In Item,Zmena v položke
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,{0} Students have been enrolled,{0} Študenti boli zapísaní
DocType: Vehicle Service,Inspection,inšpekcia
DocType: Location,Area,rozloha
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Summary for this week and pending activities,Zhrnutie pre tento týždeň a prebiehajúce aktivity
DocType: Asset Maintenance Task,Maintenance Task,Úloha údržby
DocType: Subscription,Current Invoice Start Date,Aktuálny dátum začiatku faktúry
DocType: Purchase Invoice Item,Item,položka
DocType: Program Enrollment Tool,Get Students From,Získajte študentov od
DocType: Amazon MWS Settings,Always synch your products from Amazon MWS before synching the Orders details,Pred synchronizáciou detailov objednávky vždy synchronizujte svoje produkty od spoločnosti Amazon MWS
DocType: Leave Block List,Leave Block List Name,Nechajte názov zoznamu blokov
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,"Could not update stock, invoice contains drop shipping item.","Nepodarilo sa aktualizovať zásoby, faktúra obsahuje položku odoslania."
DocType: Asset Maintenance Log,Completion Date,Dátum vyplnenia
DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,"Sadzba, ktorou sa mena dodávateľa prepočíta na základnú menu spoločnosti"
DocType: Leave Control Panel,Leave Control Panel,Nechajte Ovládací panel
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Celková platná sadzba v položke Položky príjmu pri nákupe musí byť rovnaká ako celková daň a poplatok
DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,V aplikácii Words budú viditeľné po uložení dodacieho listu.
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Suppliies made to Composition Taxable Persons,Dodávky pre osoby podliehajúce dani
DocType: Bin,Reserved Qty for Production,Vyhradené množstvo pre výrobu
DocType: Asset,Quality Manager,Manažér kvality
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py,"Configure Item Fields like UOM, Item Group, Description and No of Hours.","Konfigurujte polia položky ako UOM, Skupina položiek, Popis a Počet hodín."
apps/erpnext/erpnext/hr/doctype/department/department_tree.js,New Department,Nové oddelenie
DocType: Employee,Job Applicant,Úchádzač o zamestnanie
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Create Invoices,Vytvorte faktúry
DocType: Purchase Invoice Item,Purchase Order Item,Položka objednávky
apps/erpnext/erpnext/config/settings.py,Data Import and Export,Import a export údajov
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Please contact to the user who have Sales Master Manager {0} role,"Obráťte sa na používateľa, ktorý má úlohu Sales Master Manager {0}"
apps/erpnext/erpnext/projects/doctype/project_type/project_type.py,You cannot delete Project Type 'External',Typ projektu „Externé“ nie je možné odstrániť
DocType: Account,Temporary,dočasný
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Column Labels : ,Menovky stĺpcov:
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Employee A/C Number,Číslo zamestnanca A / C
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date should be before Closing Date,Dátum otvorenia by mal byť pred dátumom uzávierky
DocType: Packed Item,Parent Detail docname,Rodičovský Detail docname
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Detail bankového vyrovnania
DocType: Tax Withholding Rate,Cumulative Transaction Threshold,Kumulatívna prahová hodnota transakcie
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 pole intervalu napr. Ak Interval je &#39;Days&#39; a Billing Interval Count je 3, faktúry budú generované každé 3 dni"
apps/erpnext/erpnext/projects/doctype/task/task.py,'Actual Start Date' can not be greater than 'Actual End Date',„Skutočný dátum začiatku“ nemôže byť väčší ako „skutočný dátum ukončenia“
DocType: Payment Entry Reference,Payment Entry Reference,Referenčné číslo platby
DocType: Salary Component Account,Salary Component Account,Účet miezd
DocType: Supplier,Default Payable Accounts,Predvolené účty
DocType: Purchase Invoice,In Words,V slovách
DocType: Journal Entry Account,Purchase Order,Objednávka
apps/erpnext/erpnext/education/utils.py,You are not enrolled in program {0},Nie ste zaregistrovaný v programe {0}
DocType: Journal Entry,Entry Type,Typ vstupu
apps/erpnext/erpnext/config/healthcare.py,Laboratory,laboratórium
DocType: Purchase Order,To Bill,Platiť
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Utility Expenses,Náklady na verejné služby
DocType: Manufacturing Settings,Time Between Operations (in mins),Čas medzi operáciami (v minútach)
DocType: GSTR 3B Report,May,Smieť
apps/erpnext/erpnext/accounts/utils.py,"Payment Gateway Account not created, please create one manually.","Účet platobnej brány nebol vytvorený, vytvorte ho manuálne."
DocType: Opening Invoice Creation Tool,Purchase,nákup
DocType: Program Enrollment,School House,Školský dom
apps/erpnext/erpnext/public/js/setup_wizard.js,Please select at least one domain.,Vyberte aspoň jednu doménu.
apps/erpnext/erpnext/projects/doctype/project/project.py,Daily Project Summary for {0},Zhrnutie denného projektu pre {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py,All Territories,Všetky územia
DocType: Asset Repair,Failure Date,Dátum zlyhania
DocType: Training Event,Attendees,Účastníci
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Total Outstanding,Celkový stav
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Amount of TDS Deducted,Výška odpočítaného TDS
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Cash or Bank Account is mandatory for making payment entry,Platobný alebo bankový účet je povinný pri zadávaní platby
DocType: Company,Registration Details,Podrobnosti registrácie
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Calculated Bank Statement balance,Vypočítaný zostatok bankového výpisu
DocType: Bank Transaction,Bank Transaction,Transakcia banky
apps/erpnext/erpnext/hub_node/api.py,Only users with {0} role can register on Marketplace,Na Marketplace sa môžu zaregistrovať iba užívatelia s {0} rolou
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 prosím účet v skladovom zázname alebo nastavte predvolený účet v spoločnosti {1}."
DocType: Inpatient Record,Admission,Vstupné
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
DocType: SMS Center,Create Receiver List,Vytvorte zoznam príjemcov
DocType: Leave Type,Max Leaves Allowed,Povolené maximálne listy
DocType: Salary Detail,Component,komponentov
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Leave and Attendance,Dovolenka a účasť
DocType: Sales Invoice Timesheet,Billing Amount,Výška fakturácie
DocType: BOM Website Item,BOM Website Item,Položka webovej stránky kusovníka
DocType: Purchase Invoice,Rounded Total,Zaokrúhlené celkom
DocType: Production Plan,Production Plan,Výrobný plán
DocType: Asset Maintenance Log,Actions performed,Vykonané akcie
DocType: Purchase Invoice,Set Accepted Warehouse,Nastavte Accepted Warehouse
apps/erpnext/erpnext/config/buying.py,Rules for applying pricing and discount.,Pravidlá pre uplatnenie ceny a zľavy.
DocType: Supplier,Statutory info and other general information about your Supplier,Zákonné informácie a ďalšie všeobecné informácie o Vašom dodávateľovi
DocType: Item Default,Default Selling Cost Center,Centrum východiskových predajných nákladov
DocType: Sales Partner,Address & Contacts,Adresa a kontakty
DocType: Subscriber,Subscriber,predplatiteľ
apps/erpnext/erpnext/utilities/bot.py,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / Item / {0}) je skladom
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Please select Posting Date first,Najprv vyberte Dátum účtovania
DocType: Supplier,Mention if non-standard payable account,"Uveďte, či ide o neštandardný splatný účet"
DocType: Training Event,Advance,záloha
DocType: Project,% Complete Method,Úplná metóda
DocType: Detected Disease,Tasks Created,Úlohy boli vytvorené
apps/erpnext/erpnext/stock/doctype/item/item.py,Default BOM ({0}) must be active for this item or its template,Pre túto položku alebo jej šablónu musí byť aktívny predvolený kusovník ({0})
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Commission Rate %,Miera Komisie
DocType: Service Level Priority,Response Time,Doba odozvy
DocType: Woocommerce Settings,Woocommerce Settings,Nastavenia služby Woocommerce
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Quantity must be positive,Množstvo musí byť kladné
DocType: Contract,CRM,CRM
DocType: Purchase Taxes and Charges,Parenttype,Parenttype
DocType: Tax Rule,Billing State,Štát fakturácie
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Quantity for Item {0} must be less than {1},Množstvo pre položku {0} musí byť menšie ako {1}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Transfer Material,Preneste materiál
DocType: Shipping Rule,Shipping Account,Prepravný účet
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Approval Notification in HR Settings.,Prosím nastavte predvolenú šablónu pre Notifikáciu ponechania schválenia v nastavení HR.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Television,televízia
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Debit ({0}),Debet ({0})
DocType: Healthcare Practitioner,Inpatient Visit Charge,Poplatok za návštevu v nemocnici
DocType: Bank Statement Settings,Transaction Data Mapping,Mapovanie transakčných dát
apps/erpnext/erpnext/crm/doctype/lead/lead.py,A Lead requires either a person's name or an organization's name,Olovo vyžaduje buď meno osoby alebo názov organizácie
DocType: Student,Guardians,strážcovia
apps/erpnext/erpnext/public/js/stock_analytics.js,Select Brand...,Vybrať značku ...
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Middle Income,Stredný príjem
DocType: Shipping Rule,Calculate Based On,Vypočítať na základe
DocType: Company,Default warehouse for Sales Return,Predvolený sklad pre predajný výnos
apps/erpnext/erpnext/stock/doctype/item/item.py,Barcode {0} already used in Item {1},Čiarový kód {0} sa už použil v položke {1}
DocType: Lead,Campaign Name,Názov kampane
DocType: Purchase Invoice,Rejected Warehouse,Zamietnutý sklad
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} musí byť odoslané
DocType: Expense Claim Advance,Expense Claim Advance,Preddavok na reklamáciu výdavkov
DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Úprava zaokrúhľovania (mena spoločnosti)
DocType: Item,Publish in Hub,Publikovať v Hub
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,GSTIN,GSTIN
DocType: GSTR 3B Report,August,august
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter Purchase Receipt first,Najskôr zadajte prosím Potvrdenie o kúpe
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Start Year,Začiatok roka
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Target ({}),Cieľ ({})
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set Default Payroll Payable Account in Company {0},Nastaviť predvolený mzdový účet v spoločnosti {0}
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html,Sales Summary,Súhrn predaja
DocType: Purchase Invoice,In Words (Company Currency),V slovách (firemná mena)
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Uveďte menu v spoločnosti
DocType: Pricing Rule,Price,cena
DocType: Material Request Item,Min Order Qty,Min Objedn
DocType: Agriculture Task,Holiday Management,Riadenie dovoleniek
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 súhrnnej skupiny dennej práce povolte predvolený prichádzajúci účet
apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py,You can only select a maximum of one option from the list of check boxes.,Zo zoznamu začiarkavacích políčok môžete vybrať maximálne jednu možnosť.
DocType: Program Enrollment,Public Transport,Verejná doprava
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} je možné zachovať pre dávku {1} a položku {2}.
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Upload a statement,Odovzdať vyhlásenie
DocType: Item,Max Sample Quantity,Max. Množstvo vzorky
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Source and target warehouse must be different,Zdrojový a cieľový sklad musia byť odlišné
DocType: Employee Benefit Application,Benefits Applied,Aplikované výhody
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Against Journal Entry {0} does not have any unmatched {1} entry,Proti položke žurnálu {0} nie je priradená žiadna položka {1}
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,"Special Characters except ""-"", ""#"", ""."", ""/"", ""{"" and ""}"" not allowed in naming series","Špeciálne pomenovanie okrem &quot;-&quot;, &quot;#&quot;, &quot;.&quot;, &quot;/&quot;, &quot;{&quot; A &quot;}&quot; nie je povolené v menovkách"
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Price or product discount slabs are required,Vyžadujú sa cenové alebo produktové zľavové dosky
apps/erpnext/erpnext/utilities/user_progress.py,Set a Target,Nastavte cieľ
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Attendance Record {0} exists against Student {1},Záznam o účasti {0} existuje proti študentovi {1}
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Date of Transaction,Dátum transakcie
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Cancel Subscription,Zrušiť odber
apps/erpnext/erpnext/support/doctype/issue/issue.py,Couldn't Set Service Level Agreement {0}.,Nepodarilo sa nastaviť zmluvu o úrovni služby {0}.
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Net Salary Amount,Čiastka čistého platu
DocType: Account,Liability,zodpovednosť
DocType: Employee,Bank A/C No.,Bankové č.
DocType: Inpatient Record,Discharge Note,Poznámka k vybitiu
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on MR,Činnosť v prípade kumulovaného mesačného rozpočtu prekročená na MR
DocType: Asset Movement,Asset Movement,Pohyb aktív
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Nepodarilo sa vytvoriť kreditnú poznámku automaticky, zrušte začiarknutie políčka „Poznámka k vydaniu“ a znova ho odošlite"
DocType: Supplier Scorecard,Per Month,Za mesiac
DocType: Routing,Routing Name,Názov smerovania
DocType: Disease,Common Name,Spoločný názov
DocType: Education Settings,LMS Title,Názov LMS
apps/erpnext/erpnext/config/non_profit.py,Loan Management,Správa úverov
DocType: Clinical Procedure,Consumable Total Amount,Celková suma spotrebného materiálu
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Enable Template,Povoliť šablónu
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Customer LPO,Zákaznícky LPO
apps/erpnext/erpnext/stock/doctype/item/item.py,Website Image {0} attached to Item {1} cannot be found,Obrázok webovej stránky {0} pripojený k položke {1} nie je možné nájsť
DocType: Asset Maintenance Log,Planned,plánovaná
DocType: Asset,Custodian,strážca
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Filter based on Cost Center is only applicable if Budget Against is selected as Cost Center,"Filter založený na nákladovom stredisku je použiteľný iba v prípade, ak je ako nákladové stredisko vybraté Budget Against"
,Quoted Item Comparison,Porovnanie kótovanej položky
DocType: Journal Entry Account,Employee Advance,Advance zamestnancov
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward supplies liable to reverse charge (other than 1 & 2 above),Vnútorné dodávky podliehajúce spätnému plateniu (iné ako 1 a 2 vyššie)
DocType: Quotation,Shopping Cart,Nákupný vozík
apps/erpnext/erpnext/hr/doctype/employee/employee.py,User {0} does not exist,Používateľ {0} neexistuje
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Loans and Advances (Assets),Úvery a preddavky (aktíva)
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.,"Riadok {0}: Skontrolujte, či je v prípade preddavku položka „Je vopred“ proti účtu {1}."
DocType: Leave Control Panel,Designation (optional),Označenie (nepovinné)
DocType: Salary Slip,Total Principal Amount,Celková suma istiny
DocType: Opportunity,Customer / Lead Address,Adresa zákazníka / zákazníka
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Soap & Detergent,Mydlo a čistiaci prostriedok
,Purchase Analytics,Nákup Analytics
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Opportunity,príležitosť
DocType: Employee,Prefered Contact Email,Preferovaný kontaktný e-mail
apps/erpnext/erpnext/config/help.py,Opening Accounting Balance,Otvorenie účtovného zostatku
DocType: POS Profile,[Select],[Vybrať]
DocType: Stock Reconciliation,MAT-RECO-.YYYY.-,MAT-RECO-.YYYY.-
DocType: Tally Migration,Master Data,Hlavné dáta
DocType: Certification Application,Yet to appear,Napriek tomu sa objaví
apps/erpnext/erpnext/public/js/pos/pos.html,Customers in Queue,Zákazníci vo fronte
DocType: Supplier,Supplier Details,Podrobnosti o dodávateľovi
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,No gain or loss in the exchange rate,Žiadny zisk alebo strata výmenného kurzu
,GSTR-1,GSTR-1
DocType: Timesheet,Total Billable Hours,Celkový počet fakturovateľných hodín
DocType: Supplier,Represents Company,Predstavuje spoločnosť
DocType: POS Profile,Company Address,adresa firmy
,Lead Name,Vedúci názov
apps/erpnext/erpnext/config/agriculture.py,Diseases & Fertilizers,Choroby a hnojivá
apps/erpnext/erpnext/stock/get_item_details.py,Item {0} must be a Sub-contracted Item,Položka {0} musí byť subkontraktovaná položka
DocType: Landed Cost Voucher,Purchase Receipt Items,Položky nákupu
DocType: Production Plan,Ignore Existing Projected Quantity,Ignorovať existujúce plánované množstvo
DocType: Assessment Plan,Supervisor,vedúci
DocType: Salary Detail,Salary Detail,Detail platu
DocType: Budget,Budget Against,Rozpočet proti
DocType: Student Report Generation Tool,Add Letterhead,Pridajte Hlavičkový papier
apps/erpnext/erpnext/config/buying.py,Templates of supplier scorecard criteria.,Šablóny kritérií hodnotenia dodávateľov.
DocType: Asset,Default Finance Book,Predvolená finančná kniha
apps/erpnext/erpnext/stock/get_item_details.py,Please specify Company,Zadajte spoločnosť
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%. \ T
DocType: GoCardless Settings,Webhooks Secret,Webhooks Secret
,Asset Depreciations and Balances,Odpisy majetku a zostatky
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch Qty,Nové množstvo šarže
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of goods,Dovoz tovaru
DocType: Purchase Order Item Supplied,Raw Material Item Code,Kód položky suroviny
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Purchase Invoice {0} is already submitted,Nákupná faktúra {0} je už odoslaná
DocType: Fees,Student Email,E-mail študenta
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/accounts/doctype/journal_entry/journal_entry.py,Stock Entry {0} is not submitted,Položka položky {0} nie je odoslaná
DocType: Item Attribute Value,Item Attribute Value,Hodnota atribútu položky
DocType: Volunteer,Volunteer Skills,Dobrovoľnícke zručnosti
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Cannot enroll more than {0} students for this student group.,Pre túto skupinu študentov nie je možné zaregistrovať viac ako {0} študentov.
DocType: Travel Request,Costing Details,Podrobnosti kalkulácie
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: Journal Entry,Accounting Entries,Účtovné položky
DocType: Payment Entry,Internal Transfer,Interný prenos
DocType: Sales Invoice Item,Stock Details,Podrobnosti o skladoch
DocType: Leave Type,Is Carry Forward,Je Carry Forward
DocType: Lead,Product Enquiry,Dotaz na výrobok
DocType: Purchase Order,PUR-ORD-.YYYY.-,PUR-ORD-.YYYY.-
DocType: Supplier Scorecard,Evaluation Period,Obdobie hodnotenia
DocType: Volunteer Skill,Volunteer Skill,Dobrovoľnícka zručnosť
DocType: Purchase Order,Order Confirmation No,Potvrdenie objednávky č
,POS,POS
DocType: Training Event,Self-Study,Samoštúdium
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Above,vyššie
DocType: Setup Progress Action,Action Doctype,Akcia Doctype
DocType: POS Profile,Allow Print Before Pay,Povoliť tlač pred platbou
DocType: Production Plan,Select Items to Manufacture,Vyberte položky na výrobu
DocType: Leave Application,Leave Approver Name,Nechajte meno schvaľovateľa
DocType: Shareholder,Shareholder,akcionár
apps/erpnext/erpnext/config/selling.py,Default settings for selling transactions.,Predvolené nastavenia pre predajné transakcie.
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Please select Student Admission which is mandatory for the paid student applicant,"Vyberte študentský vstup, ktorý je povinný pre plateného študenta"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select BOM,Vyberte položku BOM
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Plány pre {0} presahy, chcete pokračovať po preskočení prekrytých slotov?"
DocType: Stock Entry,Customer or Supplier Details,Detaily zákazníka alebo dodávateľa
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Debit Account,Debetný účet
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Trial Period End Date Cannot be before Trial Period Start Date,Dátum ukončenia skúšobného obdobia nemôže byť pred dátumom začatia skúšobného obdobia
DocType: Employee,Rented,prenajaté
DocType: Employee Group Table,Employee Group Table,Tabuľka zamestnancov
DocType: Contract,HR Manager,Manažér ľudských zdrojov
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 spätnému plateniu
DocType: Payment Entry,Cheque/Reference No,Kontrola / referencia č
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js,Assessment Result,Výsledok hodnotenia
apps/erpnext/erpnext/public/js/templates/contact_list.html,New Contact,Nový kontakt
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Opportunities,príležitosti
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Čistá hotovosť z operácií
DocType: Leave Encashment,Leave Encashment,Opustiť Encashment
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Source warehouse is mandatory for row {0},Zdrojový sklad je povinný pre riadok {0}
DocType: Amazon MWS Settings,After Date,Po dátume
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Available (whether in full op part),ITC Available (či už v úplnej časti)
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: Activity Type is mandatory.,Riadok {0}: Typ aktivity je povinný.
DocType: Lead,Consultant,konzultant
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Select an employee to get the employee advance.,"Vyberte zamestnanca, aby ste dostali zamestnanca dopredu."
apps/erpnext/erpnext/assets/doctype/asset/asset.py,"Asset cannot be cancelled, as it is already {0}","Majetok sa nedá zrušiť, pretože je už {0}"
apps/erpnext/erpnext/setup/doctype/company/company.js,Wrong Password,Zlé heslo
DocType: Item,STO-ITEM-.YYYY.-,STO-ITEM-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Number / Name,Aktualizovať číslo účtu / meno
apps/erpnext/erpnext/hub_node/api.py,Unable to update remote activity,Nie je možné aktualizovať vzdialenú aktivitu
DocType: Accounts Settings,Use Custom Cash Flow Format,Použite vlastný formát toku hotovosti
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices,Otváracie faktúry
DocType: Stock Entry,Send to Warehouse,Odoslať do skladu
DocType: Training Event,Event Status,Stav udalosti
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: Account,Chargeable,zahrnuté v cene
DocType: Volunteer,Anytime,kedykoľvek
,Student Batch-Wise Attendance,Študent Batch-Wise Dochádzka
DocType: Normal Test Template,Normal Test Template,Normálna testovacia šablóna
apps/erpnext/erpnext/config/accounting.py,Tree of financial Cost Centers.,Strom finančných nákladových stredísk.
DocType: Work Order Operation,"in Minutes
Updated via 'Time Log'",v minútach aktualizované pomocou „denníka času“
DocType: Bin,Bin,popolnice
DocType: Call Log,Call Duration in seconds,Trvanie hovoru v sekundách
DocType: Payment Reconciliation Invoice,Invoice Number,Číslo faktúry
DocType: Delivery Trip,Fulfillment User,Splnenie užívateľa
DocType: Work Order Operation,Planned End Time,Čas plánovaného konca
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Section Code,Kód sekcie
DocType: Project,Monitor Progress,Monitorovanie pokroku
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select Batch No,Vyberte položku Batch No
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Payroll Number,Mzdové číslo
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Include UOM,Zahrnúť UOM
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Položky zásob akcií a položky GL sú pre vybrané nákupné doklady preúčtované
apps/erpnext/erpnext/support/doctype/issue/issue.js,Resetting Service Level Agreement.,Vynulovanie dohody o úrovni služby.
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Update Print Format,Aktualizovať formát tlače
DocType: Student,Siblings,súrodenci
DocType: Purchase Invoice,Hold Invoice,Faktúra zadržania
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Invalid reference {1},Riadok {0}: Neplatný odkaz {1}
,Profitability Analysis,Analýza ziskovosti
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,New Account Name,Nový názov účtu
DocType: Employee Benefit Claim,Expense Proof,Dôkaz nákladov
DocType: Restaurant Order Entry Item,Served,slúžil
DocType: Loan,Member,člen
DocType: Practitioner Service Unit Schedule,Practitioner Service Unit Schedule,Plán servisných jednotiek
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Wire Transfer,Drôtový prenos
DocType: Quality Review Objective,Quality Review Objective,Cieľ kontroly kvality
DocType: Bank Reconciliation Detail,Against Account,Proti účtu
DocType: Projects Settings,Projects Settings,Nastavenia projektov
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html,Actual Qty {0} / Waiting Qty {1},Skutočné množstvo {0} / Čakajúce množstvo {1}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} cannot be a Group,{0} {1}: Účet {2} nemôže byť Skupinou
DocType: Prescription Duration,Prescription Duration,Trvanie predpisovania
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Debit entry can not be linked with a {1},Riadok {0}: Zadanie debetu nie je možné prepojiť s hodnotou {1}
DocType: Program,Intro Video,Úvodné video
DocType: Purchase Invoice,Is Paid,Platí sa
DocType: Account,Debit,Dlh
,Item Balance (Simple),Zostatok položky (jednoduchý)
apps/erpnext/erpnext/utilities/activation.py,Purchase orders help you plan and follow up on your purchases,Objednávky vám pomôžu plánovať a sledovať vaše nákupy
DocType: Project,Project Type,Typ projektu
DocType: Program Enrollment Tool Student,Student Batch Name,Názov študentskej dávky
,Qty to Receive,Množstvo na príjem
DocType: Agriculture Task,Previous Business Day,Predchádzajúci pracovný deň
DocType: Travel Request Costing,Sponsored Amount,Sponzorovaná suma
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Please wait 3 days before resending the reminder.,Pred odoslaním pripomienky počkajte 3 dni.
DocType: Sales Invoice Item,Qty as per Stock UOM,Počet podľa zásob UOM
DocType: Opening Invoice Creation Tool Item,Quantity,množstvo
DocType: Delivery Stop,Estimated Arrival,Odhadovaný príchod
,Trial Balance for Party,Skúšobná bilancia pre stranu
DocType: Employee Separation,Employee Separation Template,Šablóna pre oddelenie zamestnancov
DocType: Quality Objective,Unit,jednotka
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Maximum benefit amount of component {0} exceeds {1},Maximálna výška výhody komponentu {0} presahuje hodnotu {1}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Venture Capital,Rizikový kapitál
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year End Date should be one year after Fiscal Year Start Date,Dátum ukončenia fiškálneho roka by mal byť jeden rok po dátume začiatku fiškálneho roka
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Daily Reminders,Denné pripomienky
DocType: Item,Default Sales Unit of Measure,Štandardná merná jednotka predaja
apps/erpnext/erpnext/regional/report/gst_itemised_sales_register/gst_itemised_sales_register.js,Company GSTIN,Spoločnosť GSTIN
DocType: Asset Finance Book,Rate of Depreciation,Sadzba odpisov
apps/erpnext/erpnext/regional/india/utils.py,Distance cannot be greater than 4000 kms,Vzdialenosť nemôže byť väčšia ako 4000 km
DocType: Support Search Source,Post Description Key,Príspevok Popis kľúč
DocType: Loyalty Program Collection,Minimum Total Spent,Minimálne celkové množstvo
DocType: Supplier Scorecard Period,Period Score,Skóre obdobia
apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py,Can't create standard criteria. Please rename the criteria,Nie je možné vytvoriť štandardné kritériá. Premenujte kritériá
DocType: Travel Itinerary,Arrival Datetime,Príchod Datetime
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py,Student LMS Activity,Aktivita študentského LMS
DocType: Stock Reconciliation Item,Quantity Difference,Množstvo Rozdiel
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Riadok # {0}: Pridelená suma nemôže byť vyššia ako nesplatená suma.
DocType: Sales Invoice Timesheet,Timesheet Detail,Detail časového rozvrhu
DocType: Employee Skill,Proficiency,zručnosť
DocType: SMS Log,Sent To,Odoslaná
DocType: Item,Hub Publishing Details,Podrobnosti o publikovaní rozbočovača
apps/erpnext/erpnext/utilities/activation.py,"Student Batches help you track attendance, assessments and fees for students","Študentské dávky vám pomôžu sledovať účasť, hodnotenie a poplatky pre študentov"
DocType: Employee Tax Exemption Declaration Category,Declared Amount,Deklarovaná suma
DocType: Selling Settings,Auto close Opportunity after 15 days,Automatické zatvorenie Príležitosť po 15 dňoch
DocType: Share Transfer,Issue,Problém
DocType: Volunteer,Availability Timeslot,Časy dostupnosti
DocType: Program,Program Abbreviation,Skratka programu
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Start Date,Dátum začiatku projektu
DocType: Purchase Invoice,Additional DIscount Amount,Dodatočná čiastka DIscount
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Položka {0} sa nenašla v tabuľke „Dodávky surovín“ v objednávke {1}
DocType: BOM,Manage cost of operations,Správa nákladov na operácie
apps/erpnext/erpnext/accounts/doctype/account/account.py,You are not authorized to set Frozen value,Nemáte oprávnenie na nastavenie zmrazenej hodnoty
DocType: Contract,Lapsed,odpadlý
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Investments,investície
DocType: Inpatient Record,Date of Birth,Dátum narodenia
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 rolí System Manager a Item Manager, aby ste sa mohli zaregistrovať na Marketplace."
DocType: Item Attribute,Item Attribute Values,Hodnoty atribútu položky
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please save the patient first,Najskôr uložte pacienta
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Half Day Date should be between From Date and To Date,Polovičný dátum by mal byť medzi dátumom a dátumom
DocType: Inpatient Record,Expected Discharge,Očakávaný výdaj
DocType: Travel Request,Travel Type,Typ cesty
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Customer is required,Zákazník je povinný
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Pre položku {0} je zadané neplatné množstvo. Množstvo by malo byť väčšie ako 0.
apps/erpnext/erpnext/education/doctype/instructor/instructor.js,As Supervisor,Ako supervízor
DocType: Payroll Entry,Employees,zamestnanci
DocType: Sales Order,Billing Status,Stav fakturácie
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Please select Category first,Najprv vyberte kategóriu
apps/erpnext/erpnext/config/manufacturing.py,BOM Browser,Prehliadač kusovníka
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Create Student Groups,Vytvorte študentské skupiny
DocType: Work Order Operation,In Minutes,V zápisnici
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Net Pay cannot be less than 0,Čistý plat nesmie byť nižší ako 0
DocType: Maintenance Schedule,Schedules,poriadky
DocType: Employee Training,Employee Training,Vzdelávanie zamestnancov
DocType: Loan,Rate of Interest (%) / Year,Úroková miera (%) / rok
DocType: Normal Test Items,Require Result Value,Vyžadovať hodnotu výsledku
DocType: Loan,Loan Type,Typ úveru
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Item Code required at Row No {0},Kód položky sa vyžaduje v riadku č. {0}
DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikácia balíka pre doručenie (pre tlač)
DocType: Assessment Plan,Assessment Name,Názov hodnotenia
DocType: Travel Itinerary,Departure Datetime,Čas odchodu
DocType: Delivery Note Item,From Warehouse,Zo skladu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} against {2} {3},Suma {0} {1} proti {2} {3}
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variant,Vytvorte variant
DocType: Contract Template,Fulfilment Terms and Conditions,Podmienky plnenia
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 zapracovania
DocType: Pricing Rule,Price or Product Discount,Cena alebo zľava na výrobok
DocType: Quality Inspection Reading,Reading 1,Čítanie 1
DocType: Student Admission Program,Maximum Age,Maximálny vek
DocType: Payroll Period,Payroll Periods,Obdobie miezd
apps/erpnext/erpnext/buying/report/subcontracted_raw_materials_to_be_transferred/subcontracted_raw_materials_to_be_transferred.py,Transferred Quantity,Prenesené množstvo
DocType: Marketplace Settings,Marketplace Settings,Nastavenia Marketplace
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é pre {0} kvôli hodnoteniu {1}.
apps/erpnext/erpnext/stock/get_item_details.py,Price List not selected,Cenník nie je vybratý
DocType: Exotel Settings,API Token,Token API
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,Workstation is closed on the following dates as per Holiday List: {0},Pracovná stanica je zatvorená v nasledujúcich dňoch podľa zoznamu prázdnin: {0}
DocType: Customer,"Reselect, if the chosen address is edited after save","Znova vyberte, ak je vybraná adresa upravená po uložení"
apps/erpnext/erpnext/stock/doctype/item/item.py,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Predvolená jednotka miery pre položku {0} nemôže byť zmenená priamo, pretože ste už vykonali niektoré transakcie s iným UOM. Budete musieť vytvoriť novú položku, ktorá bude používať iné predvolené UOM."
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dodávateľ&gt; Typ dodávateľa
apps/erpnext/erpnext/stock/doctype/item/item.js,Changing Customer Group for the selected Customer is not allowed.,Zmena zákazníckej skupiny pre vybratého zákazníka nie je povolená.
DocType: Serial No,Creation Document Type,Typ dokumentu vytvorenia
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Dostupné množstvo dávky v sklade
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Invoice Grand Total,Celkový súčet faktúr
apps/erpnext/erpnext/setup/doctype/territory/territory.js,This is a root territory and cannot be edited.,Toto je koreňové územie a nedá sa upraviť.
DocType: Patient,Surgical History,Chirurgická história
apps/erpnext/erpnext/config/quality_management.py,Tree of Quality Procedures.,Strom postupov kvality.
DocType: Bank Account,Contact HTML,Kontaktovať HTML
,Employee Information,Informácie o zamestnancovi
DocType: Assessment Plan,Examiner,skúšajúci
DocType: Employee Tax Exemption Proof Submission Detail,Actual Amount,Skutočná čiastka
DocType: Contract,Fulfilled,splnené
apps/erpnext/erpnext/controllers/buying_controller.py,Row {0}: Enter location for the asset item {1},Riadok {0}: Zadajte miesto pre položku aktíva {1}
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,The selected payment entry should be linked with a debtor bank transaction,Vybraná položka platby by mala byť prepojená s transakciou dlžníckej banky
DocType: Purchase Invoice,Taxes and Charges Calculation,Výpočet daní a poplatkov
DocType: Setup Progress Action,Action Document,Akčný dokument
DocType: Clinical Procedure,Procedure Prescription,Postup Predpis
DocType: Guardian,Guardian Name,Meno strážcu
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Successfully Reconciled,Úspešne Zosúladené
DocType: Accounting Period,Period Name,Názov obdobia
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Vytiahnite položky z dodacieho listu
DocType: Content Question,Content Question,Obsah Otázka
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html,In Stock: ,Skladom:
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement tracking is not enabled.,Sledovanie úrovne služby nie je povolené.
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Please save before assigning task.,Pred priradením úlohy ho uložte.
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py,Company is manadatory for company account,Spoločnosť je ručiteľom pre firemný účet
DocType: Sales Order Item,Delivery Warehouse,Skladový sklad
DocType: Shopify Settings,Enable Shopify,Povoliť službu Shopify
DocType: Patient,Additional information regarding the patient,Ďalšie informácie týkajúce sa pacienta
DocType: Landed Cost Voucher,Purchase Receipts,Príjmy z nákupu
apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js,New Employee,Nový zamestnanec
DocType: Purchase Invoice,Update Auto Repeat Reference,Aktualizácia referencie automatického opakovania
DocType: Fees,Fees,poplatky
DocType: Student Group,Student Group Name,Názov študentskej skupiny
DocType: Supplier Scorecard Scoring Standing,Employee,zamestnanec
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available-for-use Date should be after purchase date,Dostupný na použitie Dátum by mal byť po dátume nákupu
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Please define grade for Threshold 0%,Definujte stupeň pre prahovú hodnotu 0%
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Aplikácie používajúce aktuálny kľúč nebudú mať prístup, ste si istí?"
DocType: Quality Meeting,Minutes,minúty
DocType: Quiz Result,Correct,korektné
DocType: Employee Tax Exemption Declaration,Total Declared Amount,Celková deklarovaná čiastka
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py,Material,materiál
DocType: Appointment Type,Is Inpatient,Je netrpezlivý
DocType: Leave Encashment,Encashment Amount,Suma inkasa
DocType: BOM,Conversion Rate,Konverzný kurz
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,CEO,CEO
DocType: Bin,Reserved Qty for sub contract,Vyhradené množstvo pre subkontrakt
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Create Payment Entry,Vytvoriť položku platby
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js,Submit Proof,Odoslať dôkaz
DocType: Payment Term,Credit Months,Úverové mesiace
DocType: Bank Guarantee,Providing,ak
DocType: Sales Invoice,Total Billing Amount,Celková suma fakturácie
DocType: Maintenance Visit,Maintenance Visit,Návšteva údržby
DocType: Item,Country of Origin,Krajina pôvodu
DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Kritériá analýzy poľnohospodárstva
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Additional Salary Component Exists.,Doplnková zložka mzdy existuje.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Grocery,potraviny
DocType: Restaurant Table,Minimum Seating,Minimálne sedenie
DocType: Vital Signs,Furry,srstnatý
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"Can not filter based on Account, if grouped by Account","Nemožno filtrovať na základe účtu, ak je zoskupený podľa účtu"
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Bank Entries,Bankové záznamy
DocType: Soil Texture,Sandy Clay Loam,Sandy Clay Loam
DocType: Crop Cycle,LInked Analysis,LInked analýza
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Valid From Date must be lesser than Valid Upto Date.,Platný dátum od dátumu musí byť menší ako platný dátum.
DocType: Additional Salary,Salary Component,Komponent mzdy
DocType: Asset Maintenance Team,Maintenance Team Members,Členovia tímu údržby
DocType: Student Admission Program,Minimum Age,Minimálny vek
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Available Selling,Dostupný predaj
DocType: Purchase Invoice,Taxes and Charges Deducted,Odpočítané dane a poplatky
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Lab Test,Vytvorte laboratórny test
DocType: Hotel Settings,Hotel Settings,Nastavenia hotela
DocType: Naming Series,Select Transaction,Vyberte Transakciu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Declare Lost,Deklaruj stratu
DocType: Warranty Claim,If different than customer address,Ak sa líši od adresy zákazníka
DocType: Chart of Accounts Importer,Chart Tree,Graf Strom
DocType: Contract,Contract,zmluva
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,Please select the Multiple Tier Program type for more than one collection rules.,Vyberte viacnásobný typ programu pre viac ako jedno kolekčné pravidlo.
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,{0} for {1},{0} pre {1}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For Quantity (Manufactured Qty) is mandatory,Pre množstvo (Vyrobené množstvo) je povinné
apps/erpnext/erpnext/public/js/setup_wizard.js,"e.g. ""Primary School"" or ""University""",napr. &quot;Základná škola&quot; alebo &quot;univerzita&quot;
DocType: Pricing Rule,Apply Multiple Pricing Rules,Použiť pravidlá viacerých cien
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py,Review Invitation Sent,Poslanie pozvania bolo odoslané
DocType: Item,No of Months,Počet mesiacov
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Požadované sériové čísla pre serializovanú položku {0}
apps/erpnext/erpnext/config/manufacturing.py,Bill of Materials (BOM),Kusovník (kusovník)
DocType: Accounts Settings,Allow Stale Exchange Rates,Povoliť výmenné výmenné kurzy
DocType: BOM,Website Description,Popis webových stránok
DocType: POS Closing Voucher,Expense Details,Podrobnosti o výdavkoch
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,From Range has to be less than To Range,Od Range musí byť menšie ako To Range
DocType: Homepage,Products to be shown on website homepage,"Produkty, ktoré sa majú zobrazovať na domovskej stránke webovej stránky"
DocType: Tally Migration,Is Master Data Processed,Spracujú sa kmeňové dáta
DocType: Item Price,Quantity  that must be bought or sold per UOM,"Množstvo, ktoré sa musí kúpiť alebo predať za UOM"
DocType: Project,Total Sales Amount (via Sales Order),Celková suma predaja (prostredníctvom zákazky odberateľa)
apps/erpnext/erpnext/utilities/user_progress.py,Box,truhlík
DocType: QuickBooks Migrator,Default Cost Center,Štandardné stredisko nákladov
DocType: Purchase Order Item,Billed Amt,Fakturované poplatky
apps/erpnext/erpnext/accounts/utils.py,Please set default {0} in Company {1},Nastavte predvolenú hodnotu {0} v spoločnosti {1}
DocType: Cheque Print Template,Distance from left edge,Vzdialenosť od ľavého okraja
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Položka 4
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}",Záloha zaplatená pred {0} {1} nemôže byť vyššia ako celková suma {2}
DocType: Account,Income Account,Účet príjmov
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py,All Warehouses,Všetky sklady
DocType: Contract,Signee Details,Podrobnosti o signee
DocType: Shift Type,Allow check-out after shift end time (in minutes),Povoliť odhlásenie po ukončení zmeny (v minútach)
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py,Procurement,Obstarávanie
DocType: Item Group,Check this if you want to show in website,"Ak chcete zobraziť na webovej stránke, začiarknite toto políčko"
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Fiscal Year {0} not found,Fiškálny rok {0} nebol nájdený
DocType: Bank Statement Settings,Bank Statement Settings,Nastavenia výpisu z účtu
DocType: Quality Procedure Process,Link existing Quality Procedure.,Prepojiť existujúci postup kvality.
apps/erpnext/erpnext/config/getting_started.py,Import Chart Of Accounts from CSV / Excel files,Importovať graf účtov zo súborov CSV / Excel
DocType: Appraisal Goal,Score (0-5),Skóre (0-5)
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute {0} selected multiple times in Attributes Table,Atribút {0} zvolený viackrát v tabuľke atribútov
DocType: Purchase Invoice,Debit Note Issued,Vydané debetné oznámenie
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Vyberte položku, kde je položka „Je položka položky“ „Nie“ a „Je položka predaja“ „Áno“ a neexistuje žiadny iný balík produktov"
apps/erpnext/erpnext/hr/utils.py,Employee {0} of grade {1} have no default leave policy,Zamestnanec {0} triedy {1} nemá žiadnu predvolenú politiku opustenia
DocType: Leave Policy Detail,Leave Policy Detail,Opustiť podrobnosti politiky
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Warehouse not found in the system,Sklad sa nenašiel v systéme
DocType: Healthcare Practitioner,OP Consulting Charge,OP Poplatok za poradenstvo
DocType: Bank Statement Transaction Payment Item,Invoices,faktúry
DocType: Currency Exchange,Currency Exchange,Zmenáreň
DocType: Payroll Entry,Fortnightly,dvojtýždňové
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} not in stock,Sériové číslo {0} nie je na sklade
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Material Request not created, as quantity for Raw Materials already available.","Žiadosť o materiál nebola vytvorená, pretože množstvo surovín je už k dispozícii."
DocType: Woocommerce Settings,Creation User,Používateľ vytvorenia
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-mailu, telefónu, rozhovoru, návštevy atď."
DocType: Asset Settings,Asset Settings,Nastavenia aktív
DocType: Compensatory Leave Request,Worked On Holiday,Pracoval na dovolenke
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Either location or employee must be required,Musí byť požadované umiestnenie alebo zamestnanec
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is cancelled,Položka {0} sa zruší
DocType: Course Scheduling Tool,Course End Date,Dátum ukončenia kurzu
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Warning: Leave application contains following block dates,Upozornenie: Ponechať aplikáciu obsahuje nasledujúce dátumy blokov
DocType: Asset Maintenance Task,Preventive Maintenance,Preventívna údržba
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Abbreviation,Inštitút Skratka
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Účet rozdielu musí byť účtom typu aktív / pasív, pretože toto vyrovnanie zásob je vstupný záznam"
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Contract End Date must be greater than Date of Joining,Dátum ukončenia zmluvy musí byť väčší ako dátum pripojenia
DocType: Employee Grade,Default Leave Policy,Predvolená politika ponechania
DocType: Daily Work Summary Group,Select Users,Vyberte položku Používatelia
DocType: Workstation,Net Hour Rate,Čistá hodinová sadzba
DocType: Clinical Procedure,Age,Vek
DocType: Travel Request,Event Details,Podrobnosti udalosti
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Accumulated Monthly,Akumulované Mesačne
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Update Cost,Aktualizovať náklady
DocType: Sales Order,Fully Delivered,Plne dodané
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter company first,Najskôr zadajte spoločnosť
apps/erpnext/erpnext/config/selling.py,Confirmed orders from Customers.,Potvrdené objednávky od zákazníkov.
DocType: Dosage Strength,Dosage Strength,Dávková sila
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Fill the form and save it,Vyplňte formulár a uložte ho
DocType: Program Enrollment Tool,Enrollment Details,Podrobnosti zápisu
DocType: Subscription Invoice,Subscription Invoice,Faktúra predplatného
DocType: Leave Allocation,Total Leaves Encashed,Celkový počet opustených listov
DocType: Quality Inspection,Verified By,Overený
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invoices,Získať faktúry
DocType: Bank Transaction,Settled,usadil
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Re-open,Re-open
DocType: Period Closing Voucher,Closing Fiscal Year,Ukončenie fiškálneho roka
DocType: Purchase Invoice,Release Date,Dátum vydania
DocType: Purchase Invoice,Advances,pokroky
DocType: Shipping Rule,Specify conditions to calculate shipping amount,Zadajte podmienky pre výpočet sumy za prepravu
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Technology,technológie
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',"Riadok môže odkazovať iba v prípade, že typ poplatku je „V predchádzajúcej výške riadku“ alebo „Celkom predchádzajúceho riadku“"
DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Ak je začiarknuté, č. pracovných dní budú zahŕňať sviatky, čo zníži hodnotu platu za deň"
DocType: Location,Location Name,Názov miesta
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í spoločnosti {3}
DocType: Employee Benefit Application,Remaining Benefits (Yearly),Zostávajúce výhody (ročne)
DocType: Asset Finance Book,Depreciation Start Date,Dátum začiatku odpisovania
DocType: Activity Cost,Billing Rate,Fakturačná sadzba
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Warning: Another {0} # {1} exists against stock entry {2},Upozornenie: Ďalšia {0} # {1} existuje proti skladovej položke {2}
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Please enable Google Maps Settings to estimate and optimize routes,"Ak chcete odhadnúť a optimalizovať trasy, povoľte nastavenie služby Mapy Google"
DocType: Purchase Invoice Item,Page Break,Zlom strany
DocType: Supplier Scorecard Criteria,Max Score,Max
DocType: Support Search Source,Support Search Source,Zdroj vyhľadávania podpory
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Financial Services,Finančné služby
DocType: Volunteer,Availability,Dostupnosť
apps/erpnext/erpnext/config/quality_management.py,Tree of Procedures,Strom procedúr
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,"Povoliť, aby sa položka v transakcii pridala viackrát"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} nie je odoslané
DocType: Work Order,Backflush raw materials from work-in-progress warehouse,Spätné spracovanie surovín z nedokončeného skladu
apps/erpnext/erpnext/stock/doctype/item/item.py,You have to enable auto re-order in Stock Settings to maintain re-order levels.,"Aby ste udržali úrovne opätovného objednania, musíte povoliť automatické opätovné objednanie v nastaveniach skladu."
DocType: Maintenance Team Member,Maintenance Team Member,Člen tímu údržby
DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,Minimálna vzdialenosť medzi radmi rastlín pre optimálny rast
DocType: Employee Health Insurance,Health Insurance Name,Názov zdravotného poistenia
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Assets,Aktíva zásob
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á je možné vytvoriť v rámci skupín, ale zápisy môžu byť vykonané proti skupinám"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Upper Income,Horné príjmy
DocType: Company,Discount Allowed Account,Účet s povolenou zľavou
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Restart Subscription,Reštartujte predplatné
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,You can not change rate if BOM mentioned agianst any item,"Nemôžete zmeniť rýchlosť, ak BOM spomenul akúkoľvek položku"
apps/erpnext/erpnext/hub_node/api.py,Please login as another user to register on Marketplace,Prihláste sa ako iný používateľ a zaregistrujte sa na Marketplace
DocType: Asset,Insurance Details,Podrobnosti poistenia
DocType: Subscription,Past Due Date,Dátum splatnosti
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,No GST No. found for the Company.,Pre spoločnosť nebolo nájdené žiadne číslo GST.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Pin Code,Z PIN kódu
DocType: Contract,Signed On,Podpísané
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á položka pre {2} môže byť vykonaná iba v mene: {3}
DocType: Assessment Criteria,Assessment Criteria,Kritériá hodnotenia
DocType: Lab Test Template,Is Billable,Je fakturovateľný
DocType: Naming Series,User must always select,Používateľ musí vždy vybrať
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, ktoré nie sú v platných sviatkoch"
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šetky góly by mal byť 100. Je to {0}
DocType: BOM,Scrap Items,Položky šrotu
DocType: Special Test Template,Result Component,Výsledok Komponent
apps/erpnext/erpnext/regional/india/utils.py,Please mention Basic and HRA component in Company,Uveďte prosím základný a HRA komponent v spoločnosti
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,{0} does not belong to Company {1},{0} nepatrí spoločnosti {1}
DocType: Attendance Request,Half Day Date,Dátum pol dňa
DocType: Delivery Note,Billing Address Name,Názov fakturačnej adresy
,GST Itemised Purchase Register,GST Položkový nákupný register
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Alternate Item,Alternatívna položka
DocType: Certification Application,Name of Applicant,Meno žiadateľa
DocType: Leave Type,Earned Leave,Zarobená dovolenka
DocType: GSTR 3B Report,June,jún
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é stredisko
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Can be approved by {0},Môže byť schválený {0}
apps/erpnext/erpnext/stock/doctype/item/item.py,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Jednotka miery {0} bola zadaná viac ako raz v tabuľke konverzných faktorov
DocType: Purchase Invoice Item,Net Rate (Company Currency),Čistá sadzba (mena spoločnosti)
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,All BOMs,Všetky kusovníky
DocType: Department,Days for which Holidays are blocked for this department.,"Počet dní, počas ktorých sú pre toto oddelenie zablokované sviatky."
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,"Cannot Submit, Employees left to mark attendance","Nedá sa odoslať, Zamestnanci sú ponechaní na označenie dochádzky"
DocType: BOM,Quality Inspection Template,Šablóna kontroly kvality
DocType: Plant Analysis,Result Datetime,Výsledok Datetime
DocType: Purchase Taxes and Charges,Valuation,ocenenie
,Student Monthly Attendance Sheet,Študent mesačný dochádzkový list
DocType: Academic Term,Term End Date,Dátum ukončenia lehoty
DocType: Pricing Rule Detail,Child Docname,Názov dieťaťa
apps/erpnext/erpnext/public/js/setup_wizard.js,Services,služby
apps/erpnext/erpnext/controllers/accounts_controller.py,Cannot set quantity less than received quantity,Nie je možné nastaviť menšie množstvo ako prijaté množstvo
DocType: Purchase Order Item,Supplier Part Number,Číslo dielu dodávateľa
DocType: Lab Test Template,Standard Selling Rate,Štandardná predajná sadzba
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please set an active menu for Restaurant {0},Nastavte aktívne menu pre reštauráciu {0}
apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,"Ak chcete pridať používateľov do služby Marketplace, musíte byť používateľom s úlohami System Manager a Item Manager."
DocType: Asset Finance Book,Asset Finance Book,Finančná kniha aktív
DocType: Quality Goal Objective,Quality Goal Objective,Cieľ cieľa kvality
DocType: Employee Transfer,Employee Transfer,Prevod zamestnancov
,Sales Funnel,Predajný lievik
DocType: Agriculture Analysis Criteria,Water Analysis,Analýza vody
DocType: Shift Type,Begin check-in before shift start time (in minutes),Začať odbavenie pred začiatkom posunu (v minútach)
DocType: Accounts Settings,Accounts Frozen Upto,Účty Frozen Upto
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js,There is nothing to edit.,Nič sa nedá upraviť.
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","Operácia {0} dlhšia ako ktorákoľvek dostupná pracovná doba v pracovnej stanici {1}, rozdelí operáciu do viacerých operácií"
DocType: Item Variant Settings,Do not update variants on save,Neaktualizujte varianty pri ukladaní
DocType: Grading Scale Interval,Threshold,Prah
DocType: Timesheet,% Amount Billed,Vyúčtovaná suma v%
DocType: Warranty Claim,Resolved By,Vyriešený By
apps/erpnext/erpnext/utilities/user_progress.py,"Add users to your organization, other than yourself.","Pridajte používateľov do vašej organizácie, okrem seba."
DocType: Global Defaults,Default Company,Predvolená spoločnosť
DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Hotovostný účet sa použije na vytvorenie predajnej faktúry
apps/erpnext/erpnext/controllers/selling_controller.py,Sales Order {0} is {1},Zákazka odberateľa {0} je {1}
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,Delay in payment (Days),Oneskorenie platby (dni)
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Enter depreciation details,Zadajte podrobnosti o odpisoch
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Customer PO,Zákaznícka objednávka
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Expected Delivery Date should be after Sales Order Date,Očakávaný dátum dodania by mal byť po dátume zákazky odberateľa
apps/erpnext/erpnext/controllers/accounts_controller.py,Item quantity can not be zero,Množstvo položky nemôže byť nulové
apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Neplatný atribút
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},Vyberte položku BOM proti položke {0}
DocType: Bank Statement Transaction Invoice Item,Invoice Type,Typ faktúry
DocType: Price List,Price List Master,Cenník Master
,Lost Opportunity,Stratená príležitosť
DocType: Maintenance Visit,Maintenance Date,Dátum údržby
DocType: Volunteer,Afternoon,Popoludnie
DocType: Vital Signs,Nutrition Values,Hodnoty výživy
DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Prítomnosť horúčky (teplota&gt; 38,5 ° C / 101,3 ° F alebo trvalá teplota&gt; 38 ° C / 100,4 ° F)"
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Reversed,ITC Reversed
DocType: Project,Collect Progress,Collect Progress
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Energy,energie
,Items To Be Requested,"Položky, ktoré sa majú požadovať"
DocType: Soil Analysis,Ca/K,Ca / K
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order already created for all items with BOM,Pracovný príkaz už vytvorený pre všetky položky s kusovníkom
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Billed Amount,Fakturovaná čiastka
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Odčítané údaje odčítavača kilometrov by mali byť väčšie ako počiatočné počítadlo kilometrov vozidla {0}
DocType: Employee Transfer Property,Employee Transfer Property,Prenos majetku zamestnanca
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Pending Activities,Čakajúce aktivity
apps/erpnext/erpnext/utilities/user_progress.py,List a few of your customers. They could be organizations or individuals.,Zoznam niekoľkých svojich zákazníkov. Môžu to byť organizácie alebo jednotlivci.
DocType: Bank Guarantee,Bank Account Info,Informácie o bankovom účte
DocType: Quality Goal,Weekday,všedný deň
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Name,Meno Guardian1
DocType: Salary Component,Variable Based On Taxable Salary,Variabilný na základe zdaniteľného platu
DocType: Accounting Period,Accounting Period,Účtovného obdobia
DocType: Company,Standard Working Hours,Štandardné pracovné hodiny
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,In Stock,Skladom
DocType: Amazon MWS Settings,Market Place Account Group,Skupina Market Account Account Group
DocType: Stock Reconciliation Item,Before reconciliation,Pred zmierením
DocType: Fee Component,Fees Category,Kategória poplatkov
DocType: Sales Order,%  Delivered,Dodané
DocType: Sales Invoice,Redemption Cost Center,Centrum nákladov na spätné odkúpenie
DocType: Vital Signs,Respiratory rate,Dychová frekvencia
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Get Students From,Povinné pole - Získať študentov od
DocType: Item Group,Item Classification,Klasifikácia položky
DocType: Asset,Is Existing Asset,Existuje existujúce aktívum
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,Cancel Material Visits {0} before cancelling this Maintenance Visit,Zrušiť návštevy materiálu {0} pred zrušením tejto návštevy údržby
DocType: Workstation,Workstation Name,Názov pracovnej stanice
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} pre zúčtovanie faktúr {2}
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Material Transfer,Prenos materiálu
DocType: Delivery Note,% Installed,% Nainštalované
DocType: Agriculture Task,Agriculture Task,Úloha poľnohospodárstva
DocType: Dosage Form,Dosage Form,Forma dávkovania
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Select the program first,Najprv vyberte program
DocType: Project,Expected Start Date,Očakávaný dátum začiatku
DocType: Share Transfer,Share Transfer,Prevod akcií
apps/erpnext/erpnext/config/help.py,Leave Management,Opustiť riadenie
DocType: Loan Application,Total Payable Interest,Celkový splatný úrok
DocType: Employee,Current Address,Aktuálna adresa
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Cannot {0} {1} {2} without any negative outstanding invoice,Nie je možné {0} {1} {2} bez zápornej faktúry
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Transaction not allowed against stopped Work Order {0},Transakcia nie je povolená proti zastavenej objednávke {0}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to ledger.,Sklady s existujúcou transakciou nemožno konvertovať na účtovnú knihu.
DocType: Payroll Entry,Deduct Tax For Unsubmitted Tax Exemption Proof,Odpočítanie dane za nepodložený dôkaz o oslobodení od dane
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date updated,Dátum vyrovnania Dátum aktualizácie
DocType: Delivery Trip,Delivery Stops,Zastavenie doručenia
DocType: Setup Progress,Setup Progress,Nastavenie Pokrok
,Ordered Items To Be Billed,Objednané položky na fakturáciu
DocType: Taxable Salary Slab,To Amount,Suma
DocType: Purchase Invoice,Is Return (Debit Note),Is Return (Debet Note)
apps/erpnext/erpnext/config/desktop.py,Getting Started,Začíname
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge,Zlúčiť
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.,Dátum začiatku fiškálneho roka a dátum ukončenia fiškálneho roka nie je možné zmeniť po uložení fiškálneho roka.
DocType: Production Plan,Get Material Request,Získať požiadavku na materiál
DocType: C-Form Invoice Detail,Invoice No,Faktúra č
DocType: Pricing Rule,Max Qty,Max
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Riadok {0}: Pridelená čiastka {1} musí byť nižšia alebo rovná výške platby {2}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,úkolová práca
DocType: Sales Invoice Item,Drop Ship,Drop Ship
DocType: Hub User,Hub User,Užívateľ rozbočovača
DocType: Lab Test Template,No Result,Žiadne výsledky
DocType: Bank Statement Transaction Entry,Match Transaction to Invoices,Porovnanie transakcií s faktúrami
DocType: Sales Invoice,Commission,provízie
DocType: Sales Invoice Item,Sales Order Item,Položka zákazky odberateľa
DocType: Maintenance Schedule Detail,Actual Date,Aktuálny dátum
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance start date can not be before delivery date for Serial No {0},Dátum začiatku údržby nemôže byť pred dátumom dodania pre sériové číslo {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Exchange Rate is mandatory,Riadok {0}: Kurz je povinný
DocType: Purchase Invoice,Select Supplier Address,Vyberte položku Adresa dodávateľa
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Available quantity is {0}, you need {1}","Dostupné množstvo je {0}, ktoré potrebujete {1}"
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Secret,Zadajte tajné rozhranie API pre spotrebiteľov
DocType: Program Enrollment Fee,Program Enrollment Fee,Poplatok za zápis programu
DocType: Employee Checkin,Shift Actual End,Shift Skutočný koniec
DocType: Serial No,Warranty Expiry Date,Dátum uplynutia platnosti záruky
DocType: Hotel Room Pricing,Hotel Room Pricing,Ceny hotelových izieb
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Outward taxable supplies(other than zero rated, nil rated and exempted","Zdaniteľné dodávky (iné ako nulové, s nulovým ratingom a oslobodené od dane)"
DocType: Issue,Resolution By,Rozlíšenie By
DocType: Loyalty Program,Customer Territory,Zákaznícke územie
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication,Posledné oznámenie
DocType: Timesheet,Total Billed Hours,Celkový počet fakturovaných hodín
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Current invoice {0} is missing,Chýba aktuálna faktúra {0}
DocType: Healthcare Settings,Patient Registration,Registrácia pacienta
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice No exists in Purchase Invoice {0},Faktúra pre dodávateľa neexistuje v nákupnej faktúre {0}
DocType: Service Day,Workday,pracovný deň
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,No Items added to cart,Žiadne položky pridané do košíka
DocType: Target Detail,Target Qty,Cieľový počet
apps/erpnext/erpnext/stock/doctype/item/item.py,"To merge, following properties must be same for both items","Ak chcete zlúčiť, tieto vlastnosti musia byť rovnaké pre obe položky"
DocType: Drug Prescription,Drug Prescription,Lieky na predpis
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Buildings,budovy
DocType: Student Applicant,Application Date,Dátum žiadosti
DocType: Assessment Result,Result,výsledok
DocType: Leave Block List,Leave Block List Allowed,Nechajte zoznam blokov povolený
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Riadok # {0}: Rýchlosť nemôže byť väčšia ako rýchlosť používaná v {1} {2}
DocType: Purchase Order Item,Blanket Order,Objednávka prikrývky
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance for employee {0} is already marked,Účasť zamestnancov {0} je už označená
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py,Assessment Result record {0} already exists.,Hodnotenie Výsledok {0} už existuje.
DocType: Purchase Invoice,Rounding Adjustment,Úprava zaokrúhľovania
DocType: Quality Review Table,Quality Review Table,Tabuľka hodnotenia kvality
DocType: Member,Membership Expiry Date,Dátum skončenia členstva
DocType: Asset Finance Book,Expected Value After Useful Life,Očakávaná hodnota po užitočnom živote
DocType: GSTR 3B Report,November,november
DocType: Loan Application,Rate of Interest,Miera záujmu
DocType: Bank Statement Transaction Payment Item,Bank Statement Transaction Payment Item,Položka Platba bankovým výpisom
DocType: Restaurant Reservation,Waitlisted,poradovníka
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,You need to enable Shopping Cart,Musíte povoliť Nákupný košík
DocType: HR Settings,Leave Status Notification Template,Ponechajte šablónu oznámenia o stave
DocType: Salary Slip,Leave Without Pay,Dovolenka bez platenia
DocType: Clinical Procedure Item,Actual Qty (at source/target),Skutočné množstvo (pri zdroji / cieli)
DocType: Purchase Invoice,Tax ID,DIČ
apps/erpnext/erpnext/templates/pages/cart.html,See past orders,Pozrite si predchádzajúce objednávky
DocType: Stock Reconciliation Item,Current Qty,Aktuálny počet
apps/erpnext/erpnext/buying/utils.py,UOM Conversion factor is required in row {0},V riadku {0} sa vyžaduje konverzný faktor UOM
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges",Tabuľka podrobností o daniach z riadku položky ako reťazec a uložená v tomto poli. Používa sa na dane a poplatky
DocType: Appraisal Goal,Key Responsibility Area,Oblasť kľúčovej zodpovednosti
DocType: Purchase Receipt Item,Sample Quantity,Vzorové množstvo
DocType: Journal Entry Account,Expense Claim,Nárok na výdavky
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date and Closing Date should be within same Fiscal Year,Dátum otvorenia a dátum uzávierky by mali byť v rámci toho istého fiškálneho roka
DocType: Soil Texture,Silt Composition (%),Silt zloženie (%)
DocType: Tax Withholding Rate,Tax Withholding Rate,Sadzba zrážkovej dane
DocType: Restaurant,Default Tax Template,Predvolená šablóna dane
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Transfer Asset,Prenos aktív
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp/Lead %,Opp / Lead%
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please cancel Purchase Invoice {0} first,Najskôr zrušte nákupnú faktúru {0}
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Complete Job,Dokončite úlohu
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Select Possible Supplier,Vyberte možnosť Možný dodávateľ
DocType: POS Profile,Customer Groups,Skupiny zákazníkov
DocType: Hub Tracked Item,Hub Category,Kategória rozbočovača
apps/erpnext/erpnext/utilities/activation.py,"Quotations are proposals, bids you have sent to your customers","Ponuky sú návrhy, ktoré ste poslali svojim zákazníkom"
DocType: Quality Inspection Reading,Reading 5,Čítanie 5
DocType: Shopping Cart Settings,Display Settings,Nastavenia zobrazenia
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please set Number of Depreciations Booked,Nastavte počet rezervovaných rezervácií
DocType: Shift Type,Consequence after,Dôsledok po
apps/erpnext/erpnext/templates/pages/help.html,What do you need help with?,S čím potrebujete pomôcť?
DocType: Journal Entry,Printing Settings,Nastavenia tlače
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Banking,bankovníctvo
DocType: Purchase Invoice Advance,Purchase Invoice Advance,Nákup preddavku na faktúru
DocType: Student Applicant,EDU-APP-.YYYY.-,EDU-APP-.YYYY.-
DocType: Purchase Invoice Item,PR Detail,PR Detail
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Billing Address is same as Shipping Address,Fakturačná adresa je rovnaká ako adresa pre odoslanie
DocType: Account,Cash,peňažný
DocType: Employee,Leave Policy,Opustiť politiku
DocType: Shift Type,Consequence,dôsledok
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Address,Adresa študenta
DocType: GST Account,CESS Account,Účet CESS
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,{0} {1}: Nákladové stredisko sa vyžaduje pre účet Zisk a strata {2}. Nastavte pre spoločnosť štandardné nákladové stredisko.
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 podriadenú spoločnosť {0} sa rodičovský účet {1} nenašiel. Vytvorte materský účet v príslušnom certifikáte pravosti
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js,General Ledger,Hlavná kniha
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Reminder to update GSTIN Sent,Pripomienka k aktualizácii GSTIN Sent
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Select Days,Vyberte dni
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Next Contact By cannot be same as the Lead Email Address,Nasledujúci kontakt nemôže byť rovnaký ako úvodná e-mailová adresa
DocType: Packing Slip,To Package No.,Na číslo balíka
DocType: Course,Course Name,Názov kurzu
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Serial no is required for the asset {0},Pre aktívum {0} sa vyžaduje sériové číslo
DocType: Asset,Maintenance,údržba
DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Potvrdiť predajnú cenu za položku proti nákupnej sadzbe alebo sadzbe ocenenia
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,The following Work Orders were created:,Boli vytvorené tieto pracovné príkazy:
DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,IFSC Code,Kód IFSC
DocType: Bank Statement Transaction Payment Item,Mode of Payment,Spôsob platby
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Suma dane po výške zľavy
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Get Suppliers By,Získajte dodávateľov podľa
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}","Riadok {0}: Ak chcete nastaviť {1} periodicitu, rozdiel medzi a do dátumu musí byť väčší alebo rovný {2}"
DocType: Purchase Invoice Item,Valuation Rate,Miera ocenenia
DocType: Shopping Cart Settings,Default settings for Shopping Cart,Predvolené nastavenia pre Nákupný košík
DocType: Quiz,Score out of 100,Skóre zo 100
DocType: Manufacturing Settings,Capacity Planning,Plánovanie kapacity
apps/erpnext/erpnext/utilities/user_progress.py,Go to Instructors,Prejsť na inštruktorov
DocType: Activity Cost,Projects,projekty
DocType: Item Barcode,Barcode Type,Typ čiarového kódu
DocType: Employee Incentive,Incentive Amount,Incentívna suma
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js,"To set this Fiscal Year as Default, click on 'Set as Default'","Ak chcete nastaviť tento fiškálny rok ako predvolený, kliknite na položku Nastaviť ako predvolené."
DocType: C-Form,II,II
DocType: Cashier Closing,From Time,Z času
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant Details Report,Report Podrobnosti o variante
,BOM Explorer,BOM Explorer
DocType: Currency Exchange,For Buying,Na nákup
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 rozvrhu
DocType: Target Detail,Target Distribution,Distribúcia cieľa
DocType: Staffing Plan,Staffing Plan Details,Podrobnosti o personálnom pláne
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}
DocType: Pricing Rule,Rule Description,Opis pravidla
DocType: Delivery Trip,Total Estimated Distance,Celková odhadovaná vzdialenosť
DocType: Opportunity,Lost Reason,Stratený dôvod
DocType: Depreciation Schedule,Make Depreciation Entry,Vykonajte odpisy
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Serial nos {0} does not belongs to the location {1},Sériové čísla {0} nepatria k lokalite {1}
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Úloha povolená na nastavenie zmrazených účtov a úprav zmrazených záznamov
DocType: Employee,Health Concerns,Zdravotné obavy
DocType: Company,Company Info,Informácie o spoločnosti
DocType: Activity Cost,Activity Cost,Náklady na aktivitu
DocType: Journal Entry,Payment Order,Platobný príkaz
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Pricing,stanovenie ceny
,Item Delivery Date,Dátum doručenia položky
DocType: Quality Goal,January-April-July-October,Január-apríl-júl-október
DocType: Purchase Order Item,Warehouse and Reference,Sklad a referencie
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with child nodes cannot be converted to ledger,Účet s podriadenými uzlami nemožno konvertovať na účtovnú knihu
DocType: Soil Texture,Clay Composition (%),Zloženie hlinky (%)
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,Číslo kusovníka pre hotovú dobrú položku
DocType: Journal Entry,User Remark,Poznámka používateľa
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Your order is out for delivery!,Vaša objednávka je na doručenie!
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ť typu Prijímať, Platiť a Interný prevod"
DocType: HR Settings,Payroll Settings,Nastavenie miezd
DocType: GST HSN Code,GST HSN Code,GST Kód HSN
DocType: Period Closing Voucher,Period Closing Voucher,Poukážka na ukončenie obdobia
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Name,Meno Guardian2
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please enter Expense Account,Zadajte prosím nákladový účet
DocType: Issue,Resolution By Variance,Rozlíšenie podľa variácie
DocType: Employee,Resignation Letter Date,Dátum rezignácie Dátum
DocType: Soil Texture,Sandy Clay,Sandy Clay
DocType: Upload Attendance,Attendance To Date,Dochádzka do dňa
DocType: Invoice Discounting,Loan Start Date,Dátum začiatku úveru
DocType: Workstation,Consumable Cost,Náklady na spotrebný materiál
DocType: Leave Type,Encashment,inkaso
DocType: Employee Tax Exemption Declaration,Income From Other Sources,Príjmy z iných zdrojov
DocType: Crop,Produced Items,Vyrobené položky
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Approval Status must be 'Approved' or 'Rejected',Stav schválenia musí byť „Schválené“ alebo „Zamietnuté“
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,View Now,Zobraziť teraz
DocType: Item Price,Valid Upto,Platné hore
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Reference Doctype must be one of {0},Referenčný Doctype musí byť jeden z {0}
DocType: Employee Checkin,Skip Auto Attendance,Preskočiť automatickú účasť
DocType: Payment Request,Transaction Currency,Mena transakcie
DocType: Loan,Repayment Schedule,Splátkový kalendár
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Create Sample Retention Stock Entry,Vytvorte položku skladu vzorky
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Open,Nastaviť ako Otvorené
DocType: Job Card,Requested Qty,Požadované množstvo
DocType: POS Profile,Apply Discount On,Použiť zľavu na
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sub contracting,Vyhradené pre subdodávateľov
apps/erpnext/erpnext/stock/doctype/item/item.py,Item variant {0} exists with same attributes,Variant položky {0} existuje s rovnakými atribútmi
DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Ak nie je priradený žiadny čas, komunikácia bude spracovaná touto skupinou"
DocType: Member,Membership Type,Typ členstva
DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Ukáže študentovi ako prítomný v mesačnej študentskej správe
apps/erpnext/erpnext/accounts/page/bank_reconciliation/linked_payment_header.html,Payment Name,Názov platby
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)
DocType: Shopify Settings,Delivery Note Series,Séria dodacích listov
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Academic Year,Povinná oblasť - akademický rok
DocType: Vehicle Log,Fuel Price,Cena paliva
DocType: Travel Itinerary,Mode of Travel,Spôsob cestovania
DocType: Special Test Items,Special Test Items,Špeciálne testovacie položky
DocType: Purchase Invoice,Edit Posting Date and Time,Upraviť dátum a čas účtovania
DocType: Sales Order,Not Billed,Neúčtované
DocType: Employee Transfer,Employee Transfer Detail,Podrobnosti o prevode zamestnancov
DocType: Project,Task Completion,Dokončenie úlohy
DocType: Shopify Webhook Detail,Webhook ID,ID Webhook
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Travel Expenses,Cestovné náklady
apps/erpnext/erpnext/hr/utils.py,Future dates not allowed,Budúce termíny nie sú povolené
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Varaiance ,Varaiance
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the Mode of Payment in Payment Schedule,Riadok {0}: Nastavte spôsob platby v pláne platieb
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Academic Term: ,Akademický termín:
DocType: Quality Feedback Parameter,Quality Feedback Parameter,Parameter spätnej väzby kvality
apps/erpnext/erpnext/accounts/page/pos/pos.js,Please select Apply Discount On,Vyberte možnosť Použiť zľavu na
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Row # {0}: ,Riadok # {0}:
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Celkové platby
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please enter Account for Change Amount,Zadajte účet pre zmenu čiastky
DocType: Tax Withholding Account,Tax Withholding Account,Zrážkový účet
DocType: Account,Stock Received But Not Billed,"Tovar bol prijatý, ale nebol fakturovaný"
apps/erpnext/erpnext/accounts/doctype/account/account.py,Please add the account to root level Company - %s,Pridajte účet do koreňovej úrovne Spoločnosť -% s
DocType: Sample Collection,Collected By,Zozbierané spoločnosťou
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Upozorniť e-mailom na vytvorenie automatickej požiadavky na materiál
DocType: Asset Repair,Downtime,prestoje
DocType: Cost Center,Cost Center Number,Číslo nákladového strediska
DocType: Driver,Applicable for external driver,Platí pre externého vodiča
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Start on,Začnite
DocType: Sales Invoice,Payment Due Date,Dátum splatnosti platby
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Ak má táto položka varianty, nemôže byť vybratá v zákazkách odberateľa atď."
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Following course schedules were created,Boli vytvorené nasledujúce plány kurzov
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Timesheet created:,Vytvorený časový rozvrh:
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Otvoriť kusovník {0}
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Transfered,prevedené
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Payable account,Kreditom na účet musí byť platobný účet
DocType: Item,Item Attribute,Atribút položky
apps/erpnext/erpnext/config/quality_management.py,Goal and Procedure,Cieľ a postup
DocType: Asset,Frequency of Depreciation (Months),Frekvencia odpisov (mesiace)
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Real Estate,Nehnuteľnosť
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Parents Teacher Meeting Attendance,Návšteva učiteľov rodičov
DocType: Employee Grade,Employee Grade,Zamestnanecký stupeň
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Celkom {0} pre všetky položky je nula, možno by ste mali zmeniť „Distribute Charges Based On“"
DocType: Sales Invoice Timesheet,Time Sheet,Časový výkaz
DocType: Hotel Room Reservation,Late Checkin,Neskoré Checkin
DocType: Company,Default Selling Terms,Predvolené podmienky predaja
DocType: Project,Costing and Billing,Kalkulácia a fakturácia
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Total Outgoing,Spolu Odchádzajúce
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Štandardná dohoda o úrovni služieb už existuje.
DocType: Packing Slip,If more than one package of the same type (for print),Ak je viac ako jeden balík rovnakého typu (pre tlač)
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Please select Company and Posting Date to getting entries,"Ak chcete získať záznamy, vyberte spoločnosť a dátum účtovania"
DocType: Healthcare Practitioner,Default Currency,Predvolená mena
DocType: Sales Invoice,Packing List,Zoznam obalov
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Secretary,sekretárka
DocType: Travel Itinerary,Gluten Free,Bezlepkový
DocType: Hub Tracked Item,Hub Node,Uzol uzla
apps/erpnext/erpnext/projects/report/billing_summary.py,Employee ID,zamestnanecké ID
DocType: Salary Structure Assignment,Salary Structure Assignment,Priradenie mzdovej štruktúry
DocType: POS Closing Voucher Taxes,POS Closing Voucher Taxes,Daň z uzávierok POS
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,Action Initialised,Akcia Inicializovaná
DocType: POS Profile,Applicable for Users,Platí pre používateľov
,Delayed Order Report,Správa o oneskorenom príkaze
DocType: Training Event,Exam,skúška
apps/erpnext/erpnext/accounts/general_ledger.py,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Nesprávny počet nájdených položiek hlavnej knihy. Možno ste v transakcii vybrali nesprávny účet.
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Sales Pipeline,Predajné potrubie
,Leaderboard,leaderboard
DocType: Account,Inter Company Account,Interný firemný účet
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Closed order cannot be cancelled. Unclose to cancel.,Uzavretú objednávku nemožno zrušiť. Zrušenie ukončenia zrušíte.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} does not exist,{0} {1} neexistuje
DocType: Job Opening,Planned number of Positions,Plánovaný počet pozícií
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ý
apps/erpnext/erpnext/accounts/page/pos/pos.js,Please select customer,Vyberte zákazníka
DocType: Account,Round Off,Zaokrúhliť
DocType: Pricing Rule,Conditions will be applied on all the selected items combined. ,Podmienky budú aplikované na všetky vybrané položky kombinované.
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure,konfigurácia
DocType: Hotel Room,Capacity,kapacita
DocType: Employee Checkin,Shift End,Koniec posunu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Greater Than Amount,Väčšie ako množstvo
DocType: Installation Note Item,Installed Qty,Nainštalované množstvo
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Batch {0} of Item {1} is disabled.,Dávka {0} položky {1} je zakázaná.
DocType: Hotel Room Reservation,Hotel Reservation User,Užívateľ hotelovej rezervácie
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Zmluva o úrovni služby s typom entity {0} a entitou {1} už existuje.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Item Group not mentioned in item master for item {0},Skupina položiek neuvedená v riadku položky pre položku {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Name error: {0},Chyba názvu: {0}
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Territory is Required in POS Profile,Územie je vyžadované v POS profile
DocType: Purchase Invoice Item,Service End Date,Dátum ukončenia služby
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Quotation,citát
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Exchange Rate must be same as {0} {1} ({2}),Výmenný kurz musí byť rovnaký ako {0} {1} ({2})
DocType: Service Level,Holiday List (ignored during SLA calculation),Zoznam dovoleniek (pri výpočte SLA ignorovaný)
DocType: Student Admission Program,Student Admission Program,Študentský prijímací program
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} can not be a ledger,Účet {0}: Rodičovský účet {1} nemôže byť knihou
DocType: Sales Order,% of materials billed against this Sales Order,% materiálov účtovaných voči tejto zákazke odberateľa
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: Stock Entry Detail,Subcontracted Item,Subdodávaná položka
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.py,Loan Start Date and Loan Period are mandatory to save the Invoice Discounting,Dátum začiatku úveru a doba úveru sú povinné na uloženie zľavy na faktúru
DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Appointment charges.,"Účty východiskových pohľadávok, ktoré sa majú použiť, ak nie sú stanovené v položke Pacient na účtovanie poplatkov za termínovanie."
DocType: Student Attendance Tool,Students HTML,Študenti HTML
DocType: Student Guardian,Student Guardian,Študent Guardian
DocType: GoCardless Settings,GoCardless Settings,Nastavenia GoCardless
DocType: Delivery Note,Transport Receipt Date,Dátum prijatia prepravného dokladu
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js,Show Opening Entries,Zobraziť položky otvorenia
DocType: Vital Signs,Heart Rate / Pulse,Tepová frekvencia / pulz
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Assessment Groups,Všetky hodnotiace skupiny
DocType: Asset,Asset Name,Názov majetku
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""",Môže existovať iba jedna podmienka pravidla odoslania s hodnotou 0 alebo prázdnou hodnotou pre hodnotu „To Value“
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Optimizing routes.,Optimalizácia trás.
DocType: Shopify Tax Account,Shopify Tax/Shipping Title,Shopify Tax / Shipping Title
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,To date can not be equal or less than from date,K dnešnému dňu nemôže byť rovná alebo nižšia ako od dátumu
apps/erpnext/erpnext/utilities/user_progress.py,You added ,Pridali ste
DocType: Assessment Result,Total Score,Konečné skóre
DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Ak ste v šablóne dane z predaja a poplatkov vytvorili štandardnú šablónu, vyberte ju a kliknite na tlačidlo nižšie."
DocType: Budget,Cost Center,Nákladové stredisko
apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Celkové pridelené percento pre obchodný tím by malo byť 100
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot deliver Serial No {0} of item {1} as it is reserved \
											to fullfill Sales Order {2}","Sériové číslo {0} položky {1} nie je možné doručiť, pretože je vyhradené na vyplnenie objednávky odberateľa {2}"
apps/erpnext/erpnext/accounts/utils.py,Payment Entry has been modified after you pulled it. Please pull it again.,Položka platby bola zmenená po jej vytiahnutí. Vytiahnite ho znova.
DocType: Employee,Bio / Cover Letter,Bio / Cover Letter
DocType: Stock Ledger Entry,Stock Value Difference,Rozdiel hodnoty zásob
DocType: Academic Year,Academic Year Name,Názov akademického roka
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Bank Accounts,Bankové účty
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,The Payment Term at row {0} is possibly a duplicate.,Platobné obdobie v riadku {0} je pravdepodobne duplikát.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Unblock Invoice,Odblokovať faktúru
DocType: Pricing Rule,Percentage,percento
DocType: Sensitivity Test Items,Sensitivity Test Items,Položky testu citlivosti
apps/erpnext/erpnext/config/retail.py,To make Customer based incentive schemes.,Urobiť motivačné systémy založené na zákazníkoch.
,Purchase Register,Nákupný register
DocType: Depreciation Schedule,Schedule Date,Plán Dátum
DocType: Packing Slip,Package Weight Details,Podrobnosti o hmotnosti balenia
DocType: Job Applicant,Job Opening,Voľné pracovné miesto
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 zamestnancov Checkin. Obnoviť len vtedy, ak ste si istí, že všetky protokoly sú synchronizované zo všetkých miest. Prosím, neupravujte to, ak si nie ste istí."
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Skutočné náklady
apps/erpnext/erpnext/controllers/accounts_controller.py,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Celková záloha ({0}) proti objednávke {1} nemôže byť väčšia ako celkový súčet ({2})
apps/erpnext/erpnext/stock/doctype/item/item.py,Item Variants updated,Varianty položky boli aktualizované
DocType: Item,Batch Number Series,Dávkové číslo série
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Projects,Otvorené projekty
DocType: Shopify Settings,Import Delivery Notes from Shopify on Shipment,Dovozné dodacie listy z Shopify on Shipment
DocType: QuickBooks Migrator,Token Endpoint,Koncový bod Token
apps/erpnext/erpnext/utilities/user_progress.py,List a few of your suppliers. They could be organizations or individuals.,Zoznam niekoľkých vašich dodávateľov. Môžu to byť organizácie alebo jednotlivci.
DocType: Amazon MWS Settings,MWS Credentials,MWS poverenia
DocType: Shopping Cart Settings,Shopping Cart Settings,Nastavenia nákupného košíka
DocType: Sales Invoice Item,Enable Deferred Revenue,Povoliť odložené príjmy
apps/erpnext/erpnext/config/help.py,Managing Projects,Riadenie projektov
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Message Sent,Správa poslaná
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Same item has been entered multiple times. {0},Rovnaká položka bola zadaná viackrát. {0}
DocType: Pricing Rule,Margin,okraj
apps/erpnext/erpnext/accounts/utils.py,{0} '{1}' not in Fiscal Year {2},{0} &#39;{1}&#39; nie je vo fiškálnom roku {2}
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,This bank account is already synchronized,Tento bankový účet je už synchronizovaný
DocType: Fee Schedule,Fee Structure,Štruktúra poplatkov
apps/erpnext/erpnext/public/js/templates/item_quick_entry.html,Variant Attributes,Variantné atribúty
DocType: Employee,Confirmation Date,Dátum potvrdenia
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please set a default Holiday List for Employee {0} or Company {1},Nastavte predvolený zoznam dovoleniek pre zamestnanca {0} alebo spoločnosť {1}
DocType: Job Applicant Source,Job Applicant Source,Zdroj žiadateľa o zamestnanie
DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Otvorenie nástroja na vytvorenie faktúry
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0} does not exist,Účet {0} neexistuje
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Ignore Existing Ordered Qty,Ignorovať existujúce objednané množstvo
DocType: Material Request Item,Lead Time Date,Dátum dodacieho času
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Accounts Receivable Summary,Prehľad pohľadávok
DocType: Asset,Available-for-use Date,Dátum k dispozícii na použitie
DocType: HR Settings,Employee record is created using selected field. ,Záznam zamestnanca sa vytvorí pomocou vybraného poľa.
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}: Typ referenčného dokumentu musí byť jeden z nákupnej objednávky, nákupnej faktúry alebo položky denníka"
DocType: Payment Entry,Type of Payment,Typ platby
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Leave the field empty to make purchase orders for all suppliers,"Nechajte pole prázdne, aby ste mohli vykonať objednávky pre všetkých dodávateľov"
apps/erpnext/erpnext/stock/utils.py,Item {0} ignored since it is not a stock item,"Položka {0} bola ignorovaná, pretože nejde o skladovú položku"
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot have Valuation Rate",&quot;Položka poskytovaná zákazníkom&quot; nemôže mať sadzbu ocenenia
DocType: Soil Texture,Clay,hlina
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} má v súčasnosti {1} postavenie Scorecard a nákupné objednávky tohto dodávateľa by mali byť vydané s opatrnosťou.
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","Ak je položka variantom inej položky, potom sa zo šablóny nastaví popis, obrázok, ceny, dane atď., Pokiaľ to nie je výslovne uvedené"
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Total Target,Celkový cieľ
DocType: Location,Longitude,zemepisná dĺžka
DocType: Accounts Settings,Determine Address Tax Category From,Určiť kategóriu dane z adresy
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,"Upload a bank statement, link or reconcile a bank account","Odovzdanie výpisu z banky, prepojenie alebo zladenie bankového účtu"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Identifying Decision Makers,Identifikácia rozhodovacích orgánov
DocType: Stock Entry Detail,Reference Purchase Receipt,Referenčný doklad o kúpe
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invocies,Získať faktúry
DocType: Tally Migration,Is Day Book Data Imported,Importujú sa údaje zo dňa
,Sales Partners Commission,Komisia pre predajných partnerov
DocType: Shift Type,Enable Different Consequence for Early Exit,Povoliť rôzne dôsledky pre predčasné ukončenie
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Legal,právnej
DocType: Loan Application,Required by Date,Vyžaduje dátum
DocType: Quiz Result,Quiz Result,Výsledok testu
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Close Loan,Zatvorte úver
DocType: Lead,From Customer,Od zákazníka
DocType: Payment Reconciliation,Minimum Invoice Amount,Minimálna výška faktúry
apps/erpnext/erpnext/stock/doctype/material_request/material_request_dashboard.py,Related,príbuzný
DocType: Drug Prescription,Description/Strength,Opis / Sila
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work Order cannot be raised against a Item Template,Pracovný príkaz nemožno vzniesť proti šablóne položky
DocType: Employee External Work History,Salary,plat
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Nastaviť stav
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward supplies from ISD,Vnútorné dodávky od ISD
,Vehicle Expenses,Náklady na vozidlo
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set 'Apply Additional Discount On',Nastavte možnosť Použiť dodatočnú zľavu
DocType: Closed Document,Closed Document,Uzavretý dokument
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py,Please select weekly off day,Vyberte týždenne mimo deň
DocType: Leave Type,Applicable After (Working Days),Použiteľné po (pracovné dni)
DocType: Timesheet Detail,Hrs,hod
DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Kritériá hodnotenia dodávateľov
DocType: Amazon MWS Settings,FR,FR
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Error: {0} is mandatory field,Chyba: {0} je povinné pole
DocType: Quality Feedback Template Parameter,Quality Feedback Template Parameter,Parameter kvality šablóny spätnej väzby
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date of Joining must be greater than Date of Birth,Dátum pripojenia musí byť väčší ako dátum narodenia
DocType: Bank Statement Transaction Invoice Item,Invoice Date,Dátum vystavenia faktúry
DocType: Healthcare Settings,Create Lab Test(s) on Sales Invoice Submit,Vytvorte Lab Testy na predajnej faktúre
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} sa nenašla žiadna aktívna kusovník. Dodanie sériovým číslom nie je možné zabezpečiť
DocType: Employee Education,Post Graduate,Postgraduálne
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Účet {0} bol zadaný viackrát
DocType: Employee Benefit Application Detail,Pay Against Benefit Claim,Platiť proti nároku nárok
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Principal Amount,Hlavná čiastka
apps/erpnext/erpnext/setup/doctype/company/company.py,Main,Hlavné
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,Serial No {0} does not exist,Sériové číslo {0} neexistuje
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Program,Vyberte položku Program
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Discharge,Rozpis Absolutórium
apps/erpnext/erpnext/stock/doctype/batch/batch.py,"Set items shelf life in days, to set expiry based on manufacturing_date plus self life","Nastaviť skladovateľnosť položiek v dňoch, nastaviť čas vypršania založený na výrobnom termíne plus životnosť"
DocType: Bank Reconciliation,Get Payment Entries,Získať položky platby
DocType: Amazon MWS Settings,Max Retry Limit,Maximálny limit opakovania
DocType: Woocommerce Settings,Endpoint,Endpoint
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é stredisko sa vyžaduje v riadku {0} v tabuľke daní pre typ {1}
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,Currency Exchange must be applicable for Buying or for Selling.,Výmena mien musí byť platná pre nákup alebo predaj.
DocType: Cheque Print Template,Cheque Width,Skontrolujte šírku
DocType: Woocommerce Settings,Secret,tajomstvo
DocType: Restaurant Order Entry,Current Order,Aktuálna objednávka
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Item must be added using 'Get Items from Purchase Receipts' button,Položka sa musí pridať pomocou tlačidla „Získať položky z nákupných dokladov“
,Delay Days,Dni oneskorenia
DocType: Company,Default Income Account,Účet východiskového príjmu
DocType: Patient Appointment,Get prescribed procedures,Získajte predpísané postupy
DocType: Lead,Market Segment,Segment trhu
apps/erpnext/erpnext/projects/doctype/task/task_list.js,Set as Completed,Nastaviť ako dokončené
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Completed Qty can not be greater than 'Qty to Manufacture',Dokončené množstvo nemôže byť väčšie ako „množstvo na výrobu“
apps/erpnext/erpnext/config/support.py,Service Level.,Úroveň služieb.
DocType: Stock Entry,MAT-STE-.YYYY.-,MAT-STE-.YYYY.-
DocType: Fiscal Year,Year Start Date,Rok Dátum začiatku
DocType: Work Order Operation,(Hour Rate / 60) * Actual Operation Time,(Hour Rate / 60) * Aktuálny prevádzkový čas
DocType: C-Form,Received Date,Dátum prijatia
apps/erpnext/erpnext/config/accounting.py,Financial / accounting year.,Finančný / účtovný rok.
DocType: Pricing Rule,Pricing Rule,Cenové pravidlo
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Optional Holiday List not set for leave period {0},Nepovinný zoznam dovoleniek nie je nastavený na dobu dovolenky {0}
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please set User ID field in an Employee record to set Employee Role,"Nastavte pole ID používateľa v zázname Zamestnanec, aby ste nastavili funkciu Zamestnanec"
apps/erpnext/erpnext/support/doctype/issue/issue.py,Allow Resetting Service Level Agreement from Support Settings.,Povoliť obnovenie dohody o úrovni služby z nastavení podpory.
DocType: Training Event,Training Event,Tréningová akcia
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ých je približne 120 mmHg systolický, a 80 mmHg diastolický, skrátene &quot;120/80 mmHg&quot;"
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 položky."
DocType: Item,Copy From Item Group,Kopírovať zo skupiny položiek
,Bank Remittance,Bankový prevod
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 nebola nájdená pre položku {0}, ktorá je potrebná na účtovné zápisy pre {1} {2}. Ak položka funguje ako položka s nulovou hodnotou ocenenia v {1}, uveďte to v tabuľke {1} Položka. V opačnom prípade vytvorte prichádzajúcu skladovú transakciu pre položku alebo uveďte hodnotu ocenenia v zázname položky a potom skúste odoslať / zrušiť túto položku"
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Half day date should be in between from date and to date,Polovičný dátum by mal byť medzi dátumom a dátumom
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Accrual Journal Entry for salaries from {0} to {1},Záznam o časovom rozlíšení platov od {0} do {1}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Material Receipt,Príjem materiálu
DocType: Employee Transfer,Re-allocate Leaves,Znova rozdeľte listy
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,To Date should be within the Fiscal Year. Assuming To Date = {0},"Dátum by mal byť v rámci fiškálneho roka. Za predpokladu, že dátum = {0}"
DocType: Employee Promotion,Employee Promotion Details,Podrobnosti o propagácii zamestnancov
DocType: Project User,Project Status,Stav projektu
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction can not be deleted,Účet s existujúcou transakciou nie je možné vymazať
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js,This is a root supplier group and cannot be edited.,Toto je skupina dodávateľov root a nedá sa upraviť.
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py,Could not find path for ,Nepodarilo sa nájsť cestu pre
DocType: Item Customer Detail,Item Customer Detail,Položka Detail zákazníka
DocType: Grant Application,Assessment  Mark (Out of 10),Značka hodnotenia (z 10)
DocType: Shareholder,ACC-SH-.YYYY.-,ACC-SH-.YYYY.-
DocType: Lab Test,LabTest Approver,Schvaľovateľ LabTestu
DocType: Task,Is Milestone,Je míľnik
DocType: Program Enrollment Tool,Get Students,Získajte študentov
DocType: Program Enrollment,Self-Driving Vehicle,Vozidlo s vlastným pohonom
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} must be a Fixed Asset Item,Položka {0} musí byť pevnou položkou aktív
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Rent,Kancelárske nájomné
DocType: Asset,In Maintenance,V Údržbe
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. Na to musíte urobiť novú položku.
DocType: Purchase Invoice,Unpaid,nezaplatený
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Name / Number,Aktualizovať názov účtu / číslo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Intern,internovať
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show only POS,Zobraziť iba POS
DocType: Cashier Closing,Custody,starostlivosť
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,From Date cannot be greater than To Date,Od dátumu nemôže byť väčšia ako dátum
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 mzdovej štruktúry nemôžete požiadať o dávky
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup defaults,Nastavenie predvolených nastavení zlyhalo
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account Number {0} already used in account {1},Číslo účtu {0} sa už použilo v účte {1}
DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,E-maily výplata zamestnanca na základe preferovaného e-mailu vybraného zamestnanca
DocType: Company,Asset Depreciation Cost Center,Nákladové stredisko odpisovania aktív
DocType: Lead,Address Desc,Adresa Desc
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Exception occurred while reconciling {0},Vyskytla sa výnimka pri zosúlaďovaní {0}
DocType: Woocommerce Settings,Enable Sync,Povoliť synchronizáciu
DocType: Student Applicant,Approved,schválený
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,From Date should be within the Fiscal Year. Assuming From Date = {0},Od dátumu by mal byť v rámci fiškálneho roka. Za predpokladu od dátumu = {0}
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.
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,{} is an invalid Attendance Status.,{} je neplatný stav dochádzky.
DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Účet dočasného otvorenia
DocType: Purchase Invoice,Cash/Bank Account,Hotovostný / bankový účet
DocType: Quality Meeting Table,Quality Meeting Table,Tabuľka kvality stretnutia
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Termín Dátum začiatku nemôže byť skôr ako Dátum začiatku akademického roka, na ktorý je termín spojený (akademický rok {}). Opravte dátumy a skúste to znova."
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 1,Rozsah starnutia 1
DocType: Employee Tax Exemption Proof Submission,Tax Exemption Proofs,Dôkazy o oslobodení od dane
DocType: Purchase Invoice,Price List Currency,Cenník Mena
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Batch: ,šarže:
DocType: Purchase Invoice,Total Advance,Celková záloha
DocType: Employee,Emergency Phone,Núdzový telefón
DocType: Inpatient Occupancy,Check Out,Odhlásiť sa
DocType: Loyalty Program,Conversion Factor,Faktor konverzie
DocType: BOM Operation,Operating Cost(Company Currency),Prevádzkové náklady (mena spoločnosti)
apps/erpnext/erpnext/config/website.py,"Settings for online shopping cart such as shipping rules, price list etc.","Nastavenia pre nákupný košík online, ako sú prepravné pravidlá, cenník atď."
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Edit Publishing Details,Upraviť podrobnosti publikovania
DocType: Soil Texture,Soil Texture Criteria,Kritériá štruktúry pôdy
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Compare List function takes on list arguments,Funkcia Porovnať zoznam nadobúda zoznam argumentov
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Department...,Vyberte oddelenie ...
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: {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row #{0}: Please specify Serial No for Item {1},Riadok # {0}: Zadajte sériové číslo položky {1}
DocType: Plant Analysis Criteria,Minimum Permissible Value,Minimálna prípustná hodnota
DocType: Stock Entry,Source Warehouse Address,Adresa zdrojového skladu
DocType: Compensatory Leave Request,Compensatory Leave Request,Žiadosť o kompenzačný príspevok
DocType: Lead,Mobile No.,Mobilné číslo.
DocType: GSTR 3B Report,July,júl
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Eligible ITC,Vhodné ITC
DocType: Fertilizer,Density (if liquid),Hustota (ak je kvapalina)
DocType: Employee,External Work History,História vonkajšej práce
DocType: Quality Inspection,Outgoing,Vychádzajúce
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill JSON cannot be generated for Sales Return as of now,e-Way Bill JSON sa teraz nedá vygenerovať pre Sales Return
DocType: Email Digest,Add Quote,Pridať cenovú ponuku
DocType: Inpatient Record,Discharge,výtok
DocType: Amazon MWS Settings,MWS Auth Token,MWS Auth Token
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,"Food, Beverage & Tobacco","Potraviny, nápoje a tabak"
apps/erpnext/erpnext/education/doctype/course/course.js,Course Schedule,Rozvrh kurzu
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Detail položky Múdry daň
DocType: Shift Type,Attendance will be marked automatically only after this date.,Dochádzka bude automaticky označená až po tomto dátume.
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to UIN holders,Dodávky pre držiaky UIN
apps/erpnext/erpnext/hooks.py,Request for Quotations,Žiadosť o ponuky
apps/erpnext/erpnext/accounts/doctype/account/account.py,Currency can not be changed after making entries using some other currency,Menu nie je možné zmeniť po zadaní údajov pomocou inej meny
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/config/accounting.py,Bank/Cash transactions against party or for internal transfer,Bankové / hotovostné transakcie proti strane alebo pre interný prevod
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py,Disabled template must not be default template,Zakázaná šablóna nesmie byť predvolenou šablónou
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Absent,Mark Absent
DocType: Salary Component,Statistical Component,Štatistická zložka
DocType: Bin,Reserved Quantity,Vyhradené množstvo
DocType: Vehicle,Insurance Company,Poisťovňa
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Note: Item {0} entered multiple times,Poznámka: Položka {0} zadaná viackrát
DocType: Plant Analysis,Collection Datetime,Čas zberu
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Total Achieved,Dosiahnuté celkom
DocType: Course Topic,Topic,téma
DocType: Employee Promotion,Promotion Date,Dátum propagácie
DocType: Bank Account,Account Details,detaily účtu
DocType: POS Profile,Allow user to edit Rate,Povoliť používateľovi upraviť sadzbu
DocType: Healthcare Settings,Result Emailed,Výsledok e-mailom
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js,View Leads,Zobraziť vedie
DocType: Fee Validity,Visited yet,Navštívené
DocType: Purchase Invoice,Terms,podmienky
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Disbursed Amount cannot be greater than Loan Amount {0},Vyplatená čiastka nemôže byť vyššia ako suma úveru {0}
DocType: Share Balance,Issued,vydal
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Admission,Plán Vstup
apps/erpnext/erpnext/public/js/templates/contact_list.html,No contacts added yet.,Zatiaľ neboli pridané žiadne kontakty.
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Create Print Format,Vytvoriť formát tlače
DocType: Asset,Policy number,Číslo politiky
DocType: GL Entry,Against Voucher,Proti kupónu
DocType: Bank Statement Transaction Payment Item,Payment Reference,Variabilný symbol
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Student Mobile No.,Študentské mobilné číslo
DocType: Cheque Print Template,Cheque Print Template,Skontrolujte šablónu tlače
DocType: Loyalty Program Collection,For how much spent = 1 Loyalty Point,Pre koľko utratených = 1 vernostný bod
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,Email Digest: ,Email Digest:
DocType: Accounts Settings,Show Inclusive Tax In Print,Zobraziť inkluzívnu daň v tlači
DocType: Student Report Generation Tool,Include All Assessment Group,Zahrňte všetky hodnotiace skupiny
DocType: Employee Benefit Application,Employee Benefits,Zamestnanecké výhody
apps/erpnext/erpnext/controllers/status_updater.py,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Tento dokument je nad {0} {1} pre položku {4}. Robíte ďalší {3} proti rovnakému {2}?
DocType: Leave Type,Is Optional Leave,Je voliteľné ponechať
DocType: Cash Flow Mapping,Is Finance Cost,Finančné náklady
DocType: Vehicle,Doors,dvere
DocType: Shopify Settings,Customer Settings,Nastavenia zákazníka
DocType: Purchase Invoice Item,Include Exploded Items,Zahrnúť rozložené položky
DocType: Assessment Plan,Evaluate,Ohodnotiť
DocType: Purchase Invoice Item,Is Free Item,Je bezplatná položka
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Present,Celkový súčet
DocType: Call Log,Recording URL,Adresa URL nahrávania
DocType: Item,Is Item from Hub,Je položka z rozbočovača
apps/erpnext/erpnext/config/quality_management.py,Quality Procedure.,Postup kvality.
DocType: Share Balance,No of Shares,Počet akcií
DocType: Quality Action,Preventive,preventívna
DocType: Support Settings,Forum URL,Adresa URL fóra
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Vital Signs,Vitálne znaky
DocType: Academic Term,Academics User,Užívatelia akademickej obce
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Get Items from BOM,Získať položky z kusovníka
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Serial No is mandatory for Item {0},Sériové číslo je povinné pre položku {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Get Items from Prescriptions,Získať položky z receptov
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},"{0} {1} nie je možné zrušiť, pretože sériové číslo {2} nepatrí do skladu {3}"
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,View Orders,Zobraziť objednávky
DocType: Staffing Plan Detail,Number Of Positions,Počet pozícií
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Walk In,Vstúpiť
DocType: Shopify Settings,Import Sales Invoice from Shopify if Payment is marked,"Ak je platba označená, importujte predajnú faktúru zo služby Shopify"
DocType: Certification Application,Certification Status,Stav certifikácie
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Source Location is required for the asset {0},Pre zdroj {0} sa vyžaduje umiestnenie zdroja
DocType: Employee,Encashment Date,Dátum zúčtovania
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 vyplnený Denník údržby majetku
DocType: Quiz,Latest Attempt,Posledný pokus
DocType: Leave Block List,Allow Users,Povoliť používateľom
apps/erpnext/erpnext/accounts/doctype/account/account.js,Chart Of Accounts,Účtová osnova
DocType: Customer,Primary Address,Primárna adresa
DocType: Room,Room Name,Názov izby
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,No outstanding invoices found for the {0} <b>{1}</b>.,Pre {0} <b>{1}</b> neboli nájdené žiadne nevyrovnané faktúry.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Tax Id: ,Id dane:
DocType: Serial No,Creation Document No,Dokument o vytvorení č
apps/erpnext/erpnext/stock/doctype/item/item.js,Projected,premietaný
DocType: Purchase Invoice Item,Rejected Qty,Zamietnuté Počet
DocType: Pricing Rule,Free Item,Voľná položka
DocType: Salary Component,Is Payable,Je splatná
DocType: Clinical Procedure Template,Allow Stock Consumption,Povoliť spotrebu zásob
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Akademický termín s týmto „akademickým rokom“ {0} a „termínovým menom“ {1} už existuje. Upravte tieto položky a skúste to znova.
DocType: Payment Entry,Initiated,inicioval
apps/erpnext/erpnext/config/selling.py,Blanket Orders from Costumers.,Deka objednávky od zákazníkov.
DocType: Sales Order Item,Used for Production Plan,Používa sa na plán výroby
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 2,Rozsah starnutia 2
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Time logs are required for job card {0},Pre kartu úlohy {0} sú potrebné časové denníky
DocType: Expense Claim,Vehicle Log,Denník vozidla
DocType: Grading Scale,Grading Scale Intervals,Intervaly mierky
DocType: Accounts Settings,Report Settings,Nastavenia prehľadu
apps/erpnext/erpnext/config/retail.py,Point-of-Sale Profile,Profil predajného miesta
DocType: Lab Test Groups,Lab Test Groups,Laboratórne testovacie skupiny
DocType: Stock Settings,Default Valuation Method,Štandardná metóda oceňovania
DocType: Item,Safety Stock,Bezpečnosť skladom
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Print settings updated in respective print format,Nastavenia tlače sa aktualizovali v príslušnom formáte tlače
DocType: Support Settings,Issues,problémy
apps/erpnext/erpnext/utilities/user_progress.py,Student Application,Aplikácia študenta
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Extra Large,Extra veľké
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.js,Please add valid Plaid api keys in site_config.json first,Najprv pridajte platné kľúče apidi Plaid v lokalite site_config.json
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Remaining Balance,Zostávajúci zostatok
DocType: Lead,Industry,priemysel
DocType: Payment Entry,Cheque/Reference Date,Kontrolný / referenčný dátum
DocType: Asset Movement,Stock Manager,Skladový manažér
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,No items to be received are overdue,"Žiadne položky, ktoré majú byť prijaté, sú oneskorené"
apps/erpnext/erpnext/config/non_profit.py,Grant information.,Poskytnite informácie.
apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',"Ak je skupina podľa skupiny „Spoločnosť“, nastavte filter spoločnosti"
DocType: Stock Settings,Action if Quality inspection is not submitted,"Činnosť, ak nie je predložená kontrola kvality"
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 pokusy"
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled or stopped,{0} {1} sa zruší alebo zastaví
DocType: Asset Maintenance Log,Has Certificate,Má certifikát
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,"Search by item code, serial number, batch no or barcode","Vyhľadávanie podľa kódu položky, sériového čísla, čísla šarže alebo čiarového kódu"
DocType: Item Price,Multiple Item prices.,Viacnásobné ceny položiek.
DocType: Request for Quotation,Request for Quotation,Žiadosť o cenovú ponuku
DocType: Stock Reconciliation Item,Current Valuation Rate,Aktuálna sadzba ocenenia
DocType: Tax Rule,Shipping County,Lodná župa
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Perception Analysis,Analýza vnímania
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item {0} is not active or end of life has been reached,Položka {0} nie je aktívna alebo bol dosiahnutý koniec životnosti
apps/erpnext/erpnext/stock/doctype/item/item.js,Single Variant,Jedna varianta
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Riadok # {0}: Typ referenčného dokumentu musí byť jedným z nárokov na výdavky alebo položky denníka
DocType: Purchase Invoice,Print Language,Jazyk tlače
DocType: Pricing Rule,Pricing Rule Help,Pomoc pri určovaní cien
DocType: Shareholder,Contact List,Zoznam kontaktov
DocType: Employee,Better Prospects,Lepšie vyhliadky
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 nie je vytvorený pre všetky položky. Kliknite na položku Generovať plán
DocType: Authorization Rule,Itemwise Discount,Itemwise Zľava
DocType: Inpatient Record,Patient Encounter,Stretnutie pacienta
apps/erpnext/erpnext/config/non_profit.py,Define various loan types,Definujte rôzne typy úverov
DocType: Supplier,Supplier Type,Typ dodávateľa
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Collected: {0},Zozbierané celkom: {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Credit Card,Kreditná karta
DocType: Warranty Claim,SER-WRN-.YYYY.-,SER-WRN-.YYYY.-
DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Nastavenie Scorecard dodávateľa
DocType: Amazon MWS Settings,Amazon MWS Settings,Nastavenia Amazon MWS
DocType: Program Enrollment,Walking,chôdza
DocType: SMS Log,Requested Numbers,Požadované čísla
DocType: Woocommerce Settings,Freight and Forwarding Account,Nákladný a zasielateľský účet
apps/erpnext/erpnext/accounts/party.py,Please select a Company,Vyberte spoločnosť
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
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. (neskôr ich môžete upraviť).
DocType: Salary Component,Create Separate Payment Entry Against Benefit Claim,Vytvorenie samostatného zadania platby proti nároku
apps/erpnext/erpnext/utilities/bot.py,Did not find any item called {0},Nenašli sa žiadne položky s názvom {0}
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
DocType: Student,Nationality,národnosť
DocType: BOM Item,Scrap %,Šrot%
DocType: Item,Inspection Criteria,Kritériá kontroly
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup company,Nepodarilo sa nastaviť spoločnosť
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To account must be a Balance Sheet account,Debet Na účet musí byť účet súvahy
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Number of Order,Číslo objednávky
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} je spojené s {2}, ale účet strany je {3}"
DocType: Purchase Invoice,Items,predmety
DocType: C-Form,I,ja
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Work-in-Progress Warehouse is required before Submit,Pred odoslaním sa vyžaduje sklad Work-in-Progress Warehouse
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Sales Order {0} has reservation for item {1}, you can
		only deliver reserved {1} against {0}. Serial No {2} cannot
		be delivered","Zákazka odberateľa {0} má rezerváciu pre položku {1}, rezervovanú {1} môžete doručiť iba proti {0}. Sériové číslo {2} nie je možné doručiť"
DocType: Quality Goal,Monitoring Frequency,Monitorovanie frekvencie
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,Closing Balance,Konečný zostatok
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Sold Asset,Náklady na predaný majetok
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Qty can not be entered in Purchase Return,Riadok # {0}: Zamietnutý počet nie je možné zadať do položky Nákup
DocType: Asset Maintenance Log,ACC-AML-.YYYY.-,ACC-AML-.YYYY.-
DocType: GSTR 3B Report,JSON Output,Výstup JSON
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Increment cannot be 0,Prírastok nemôže byť 0
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} must be submitted,Musí byť predložený kusovník {0}
DocType: Amazon MWS Settings,Synch Orders,Objednávky synchronizácie
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Disburse Loan,Vyplatiť úver
DocType: Item,Delivered by Supplier (Drop Ship),Dodané dodávateľom (Drop Ship)
apps/erpnext/erpnext/templates/pages/cart.html,Place Order,Miesto objednávky
DocType: Employee,Place of Issue,Miesto vydania
DocType: Purchase Receipt,Transporter Details,Transporter Podrobnosti
,Gross and Net Profit Report,Správa o hrubom a čistom zisku
DocType: Appraisal Template,Appraisal Template Title,Názov šablóny hodnotenia
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Orders Created: {0},Vytvorené pracovné príkazy: {0}
DocType: Packed Item,To Warehouse (Optional),Do skladu (voliteľné)
DocType: Appointment Type,Physician,lekár
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Until,kým
DocType: Leave Policy,Leave Policy Details,Opustiť podrobnosti o politike
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> Toto vygeneruje heslo ako SAL-Jane-1972
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,PDC/LC Ref,PDC / LC Ref
DocType: Naming Series,Update Series Number,Aktualizujte číslo série
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,"Nechajte nezaškrtnuté, ak nechcete uvažovať o dávkach pri vytváraní skupín založených na kurze."
DocType: Assessment Plan Criteria,Maximum Score,Maximálne skóre
DocType: Website Filter Field,Website Filter Field,Pole Filtrovanie webových stránok
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Probationary Period,Skúšobná doba
DocType: Travel Request,Require Full Funding,Vyžadovať úplné financovanie
DocType: Batch,Manufacturing Date,Dátum výroby
apps/erpnext/erpnext/utilities/activation.py,Group your students in batches,Zoskupte svojich študentov v sériách
DocType: Payroll Entry,Bimonthly,dvojmesačník
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Eliminated due to disposal of assets,Odpisy Zlikvidované z dôvodu vyradenia majetku
DocType: Maintenance Visit,Purposes,účely
apps/erpnext/erpnext/hooks.py,Shipments,zásielky
DocType: Program Enrollment Tool,New Academic Term,Nový akademický termín
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Nothing is included in gross,Nič nie je zahrnuté v hrubom vyjadrení
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,New Warehouse Name,Názov nového skladu
apps/erpnext/erpnext/selling/report/sales_partner_transaction_summary/sales_partner_transaction_summary.js,Show Return Entries,Zobraziť položky vrátenia
DocType: Soil Texture,Soil Type,Typ pôdy
DocType: Loyalty Program,Multiple Tier Program,Program viacnásobnej úrovne
DocType: BOM Update Tool,The BOM which will be replaced,"BOM, ktorý bude nahradený"
DocType: Patient,Risk Factors,Rizikové faktory
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sale,Vyhradené na predaj
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Prescriptions,predpisy
apps/erpnext/erpnext/config/accounting.py,Bills raised to Customers.,Účty vznesené voči zákazníkom.
apps/erpnext/erpnext/config/hr.py,Performance,výkon
DocType: Training Event,Seminar,seminár
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Credit ({0}),Kredit ({0})
DocType: Payment Request,Subscription Plans,Plány predplatného
DocType: GSTR 3B Report,March,marec
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split Batch,Rozdelená dávka
DocType: School House,House Name,Názov domu
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Outstanding for {0} cannot be less than zero ({1}),Výnimka pre {0} nemôže byť nižšia ako nula ({1})
DocType: Vehicle,Petrol,benzín
DocType: Customer,Bypass credit limit check at Sales Order,Obísť kontrolu úverového limitu na zákazke odberateľa
DocType: Employee External Work History,Employee External Work History,História externej práce zamestnancov
DocType: HR Settings,Expense Approver Mandatory In Expense Claim,Schvaľovateľ výdavkov Povinný v nárokoch na výdavky
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Optional. Sets company's default currency, if not specified.","Voliteľné. Nastaví predvolenú menu spoločnosti, ak nie je špecifikovaná."
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Monthly Repayment Amount cannot be greater than Loan Amount,Výška mesačnej splátky nemôže byť vyššia ako výška úveru
DocType: Leave Allocation,Allocation,Pridelenie
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid attachment {0},Upozornenie: Neplatná príloha {0}
DocType: Vehicle,License Plate,Poznávacia značka
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Paid Amount cannot be greater than total negative outstanding amount {0},Platená čiastka nemôže byť vyššia ako celková záporná čiastka {0}
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js,Stock quantity to start procedure is not available in the warehouse. Do you want to record a Stock Transfer,Skladové množstvo nie je v sklade k dispozícii. Chcete nahrávať akciový prenos
DocType: Bank Guarantee,Clauses and Conditions,Ustanovenia a podmienky
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please select correct account,Vyberte správny účet
DocType: Content Activity,Content Activity,Aktivita obsahu
DocType: Pricing Rule Detail,Pricing Rule Detail,Detail cenového pravidla
DocType: Loan,Monthly Repayment Amount,Výška mesačnej splátky
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Dodávaná položka objednávky
DocType: Leave Control Panel,Employment Type (optional),Typ zamestnania (nepovinné)
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid {0} for Inter Company Transaction.,Neplatná hodnota {0} pre internú transakciu.
DocType: Asset Movement,From Employee,Od zamestnanca
DocType: Attendance,Attendance Date,Dátum dochádzky
apps/erpnext/erpnext/setup/doctype/company/company.js,There were errors.,Vyskytli sa chyby.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consumer Products,Spotrebiteľské produkty
DocType: Email Digest,Add/Remove Recipients,Pridať alebo odstrániť príjemcov
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Suma dane po výške zľavy (mena spoločnosti)
DocType: Account,Capital Work in Progress,Prebiehajúca kapitálová práca
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Prehliadať kusovník
DocType: Cash Flow Mapping,Select Maximum Of 1,Vyberte Maximum Of 1
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čiatku splácania úveru
DocType: Stock Settings,Batch Identification,Identifikácia šarže
DocType: Pricing Rule Brand,Pricing Rule Brand,Značka cenových pravidiel
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js,This is a root sales person and cannot be edited.,Toto je koreňová predajná osoba a nemožno ju upravovať.
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Payroll date can not be less than employee's joining date,Dátum mzdy nemôže byť menší ako dátum nástupu zamestnanca
DocType: Fee Validity,Max number of visit,Maximálny počet návštev
DocType: Item,Serial Nos and Batches,Sériové čísla a dávky
DocType: HR Settings,Password Policy,Politika hesiel
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,There were errors creating Course Schedule,Došlo k chybám pri vytváraní rozvrhu kurzu
DocType: Student Attendance Tool,Batch,várka
DocType: Amazon MWS Settings,ERPNext Integrations,ERPNext Integrácie
DocType: Batch,Source Document Name,Názov zdrojového dokumentu
DocType: Restaurant,Invoice Series Prefix,Predpona série faktúr
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/public/js/call_popup/call_popup.js,Call Summary,Prehľad hovorov
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Currency for {0} must be {1},Mena pre {0} musí byť {1}
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,From Date must be before To Date,Od dátumu musí byť pred dátumom
DocType: Delivery Settings,Dispatch Notification Attachment,Prílohu oznámenia o odoslaní
apps/erpnext/erpnext/controllers/accounts_controller.py,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Celková čiastka platby v platobnom pláne musí byť rovná Grand / Rounded Total
,Itemwise Recommended Reorder Level,Itemwise Odporúčaná úroveň poradia
DocType: Course Activity,Video,video
DocType: Salary Slip Loan,Salary Slip Loan,Plat Slip Loan
DocType: Account,Balance Sheet,Súvaha
DocType: Email Digest,Payables,záväzky
apps/erpnext/erpnext/controllers/stock_controller.py,Create Quality Inspection for Item {0},Vytvoriť kontrolu kvality pre položku {0}
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Created,Poplatok bol vytvorený
,Customer Acquisition and Loyalty,Získavanie a vernosť zákazníkov
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Student Group Name is mandatory in row {0},Meno študentskej skupiny je povinné v riadku {0}
apps/erpnext/erpnext/config/accounting.py,Exchange Rate Revaluation master.,Kapitál z precenenia výmenného kurzu.
apps/erpnext/erpnext/controllers/status_updater.py,Status must be one of {0},Stav musí byť: {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",V prípade karty {0} môžete zadať iba položku typu položky &quot;Prevod materiálu pre výrobu&quot;
DocType: Asset,Insurance Start Date,Dátum začiatku poistenia
DocType: Target Detail,Target Detail,Detail cieľa
DocType: Packing Slip,Net Weight UOM,Čistá hmotnosť UOM
DocType: Purchase Invoice Item,Net Amount (Company Currency),Čistá čiastka (mena spoločnosti)
DocType: Bank Statement Transaction Settings Item,Mapped Data,Namapované údaje
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Securities and Deposits,Cenné papiere a vklady
DocType: Promotional Scheme Price Discount,Discount Type,Typ zľavy
DocType: Hotel Settings,Default Taxes and Charges,Štandardné dane a poplatky
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py,This is based on transactions against this Supplier. See timeline below for details,To je založené na transakciách voči tomuto dodávateľovi. Podrobnosti nájdete v časovej osi nižšie
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 hodnotu {1}
DocType: Delivery Note Item,Against Sales Invoice,Proti predajnej faktúre
DocType: Loyalty Point Entry,Purchase Amount,Suma nákupu
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Cannot set as Lost as Sales Order is made.,Nie je možné nastaviť ako Lost ako zákazka odberateľa.
DocType: Salary Structure,Salary Component for timesheet based payroll.,Plat Komponent pre mzdu založenú na časovom rozvrhu.
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py,Suplier Name,Meno dodávateľa
DocType: Account Subtype,Account Subtype,Podtyp účtu
DocType: Manufacturing Settings,Allow multiple Material Consumption against a Work Order,Povoliť viac materiálovú spotrebu oproti pracovnému príkazu
apps/erpnext/erpnext/templates/pages/help.html,Open a new ticket,Otvorte nový lístok
apps/erpnext/erpnext/public/js/conf.js,Report an Issue,Nahlásiť problém
DocType: Support Search Source,Link Options,Možnosti prepojenia
DocType: Selling Settings,Sales Update Frequency,Frekvencia aktualizácie predaja
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Pin Code,Pripnúť kód
apps/erpnext/erpnext/config/crm.py,Newsletters,spravodajcu
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,License,licencie
DocType: Employee Tax Exemption Declaration,Other Incomes,Iné príjmy
DocType: Job Card,Job Started,Job Started
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set recurring after saving,Po uložení nastavte opakovanie
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á so záporným množstvom v spiatočnom doklade
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for Hold,Dôvod pre Hold
apps/erpnext/erpnext/regional/report/hsn_wise_summary_of_outward_supplies/hsn_wise_summary_of_outward_supplies.js,HSN/SAC,HSN / SAC
DocType: Homepage,"URL for ""All Products""",Adresa URL pre „všetky produkty“
DocType: Lead,Organization Name,Názov organizácie
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from and valid upto fields are mandatory for the cumulative,Platné od a platné upto polia sú povinné pre kumulatívne
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Batch No must be same as {1} {2},Riadok # {0}: Číslo dávky musí byť rovnaké ako {1} {2}
DocType: Employee Checkin,Shift Start,Shift Start
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock transactions before {0} are frozen,Transakcie akcií pred {0} sú zmrazené
DocType: Driver,Issuing Date,Dátum vydania
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requestor,žiadateľ
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Nákladové stredisko {2} nepatrí spoločnosti {3}
DocType: Certification Application,Not Certified,Nie je certifikovaný
DocType: Work Order,Check if material transfer entry is not required,"Skontrolujte, či nie je potrebný vstup na prepravu materiálu"
DocType: BOM,Raw Material Cost,Náklady na suroviny
DocType: Project,Second Email,Druhý e-mail
DocType: Vehicle Log,Service Detail,Detail služby
DocType: Manufacturing Settings,Default 10 mins,Predvolené 10 minút
DocType: Subscription Plan,Billing Interval,Interval fakturácie
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Total Debit must be equal to Total Credit. The difference is {0},Celkový debet musí byť rovný celkovému kreditu. Rozdiel je {0}
DocType: Supplier,Name and Type,Názov a typ
DocType: Cheque Print Template,Cheque Height,Skontrolujte výšku
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please enter relieving date.,Zadajte dátum uvoľnenia.
DocType: Loyalty Program,Loyalty Program Help,Pomoc pre vernostný program
DocType: Journal Entry,Inter Company Journal Entry Reference,Inter Company Journal Entry Reference
DocType: Quality Meeting,Agenda,program
apps/erpnext/erpnext/config/hr.py,Shift Management,Riadenie posunu
DocType: Quality Action,Corrective,nápravný
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js,Group By,Skupina By
DocType: Bank Account,Address and Contact,Adresa a kontakt
DocType: Payment Term,Day(s) after invoice date,Deň (dni) po dátume faktúry
DocType: Woocommerce Settings,API consumer secret,Tajomstvo API
DocType: Shift Assignment,Shift Assignment,Posunutie priradenia
DocType: Maintenance Visit,MAT-MVS-.YYYY.-,MAT-MVS-.YYYY.-
DocType: Issue,First Responded On,Prvá reakcia bola zapnutá
DocType: Work Order Operation,Estimated Time and Cost,Odhadovaný čas a náklady
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/accounts/doctype/sales_invoice/sales_invoice.js,Return / Credit Note,Return / Credit Note
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Select Default Supplier,Vyberte položku Predvolený dodávateľ
DocType: Water Analysis,Appearance,vzhľad
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Voucher #,Poukážka #
DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Nastavenie typu účtu pomáha pri výbere tohto účtu v transakciách.
apps/erpnext/erpnext/config/projects.py,Define Project type.,Definujte typ projektu.
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to install presets,Nepodarilo sa nainštalovať predvoľby
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Root Company,Root Company
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,Default Activity Cost exists for Activity Type - {0},Pre typ aktivity existuje predvolená cena aktivity - {0}
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Target Location,Target Location
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Count,Počet kusov
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Invoice Patient Registration,Registrácia pacienta faktúry
DocType: Training Event Employee,Training Event Employee,Zamestnanec školenia
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?,Stratíte záznamy o predtým vytvorených faktúrach. Naozaj chcete reštartovať toto predplatné?
DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Podrobnosti šablóny mapovania cash flow
DocType: Drug Prescription,Interval UOM,Interval UOM
DocType: Shift Type,Grace Period Settings For Auto Attendance,Nastavenia doby odozvy pre automatickú účasť
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Z meny a do meny nemôže byť rovnaká
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Pharmaceuticals,Pharmaceuticals
DocType: Employee,HR-EMP-,HR-EMP
DocType: Service Level,Support Hours,Hodiny podpory
apps/erpnext/erpnext/controllers/selling_controller.py,{0} {1} is cancelled or closed,{0} {1} sa zruší alebo zatvorí
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Riadok {0}: Záloha voči zákazníkovi musí byť kreditná
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Voucher (Consolidated),Skupina podľa kupónu (Konsolidované)
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Please set default account in Expense Claim Type {0},Nastavte predvolený účet v type nároku na výdavky {0}
,BOM Search,Vyhľadávanie kusovníka
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Dispatch State,Štát odoslania
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Continue Configuration,Pokračujte v konfigurácii
DocType: Item Alternative,Item Alternative,Položka Alternatíva
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Healthcare Practitioner...,Vyberte položku Healthcare Practitioner ...
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} za obdobie miezd {2}
apps/erpnext/erpnext/controllers/accounts_controller.py,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Poznámka: Záznam o platbe nebude vytvorený, pretože nebol zadaný „Hotovostný alebo bankový účet“"
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non GST Inward Supplies,Vnútorné dodávky bez GST
DocType: Detected Disease,Disease,choroba
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Less Than Amount,Menej ako suma
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,'To Date' is required,Vyžaduje sa &#39;To Date&#39;
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Capital Equipments,Kapitálové Zariadenia
DocType: Bank Statement Settings,Statement Headers,Záhlavia výpisu
DocType: Packing Slip,Gross Weight UOM,Hrubá hmotnosť UOM
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please check Multi Currency option to allow accounts with other currency,"Ak chcete povoliť účty s inou menou, začiarknite možnosť Viac mien"
DocType: Loan,Repay Fixed Amount per Period,Splatiť pevnú čiastku za obdobie
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Show Variant Attributes,Zobraziť atribúty variantov
DocType: GL Entry,Credit Amount,Výška úveru
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Total Amount Credited,Celková suma kreditu
DocType: Support Search Source,Post Route Key List,Zoznam kľúčov trasy
apps/erpnext/erpnext/accounts/utils.py,{0} {1} not in any active Fiscal Year.,{0} {1} nie je v žiadnom aktívnom fiškálnom roku.
DocType: Quality Action Resolution,Problem,problém
DocType: Training Event,Conference,konferencie
DocType: Mode of Payment Account,Mode of Payment Account,Spôsob Platobného účtu
DocType: Leave Encashment,Encashable days,Zaplniteľné dni
DocType: Healthcare Settings,Collect Fee for Patient Registration,Zbierajte poplatok za registráciu pacienta
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Disable Template,Zakázať šablónu
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Filter Employees By (Optional),Filtrovať zamestnancov podľa (voliteľné)
apps/erpnext/erpnext/setup/default_success_action.py,{0} has been submitted successfully,{0} bola úspešne odoslaná
DocType: Workstation,Wages per hour,Mzdy za hodinu
DocType: Item,Max Discount (%),Max. Zľava (%)
DocType: Employee,Salary Mode,Platový režim
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,"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: Opportunity,Contact Info,Kontaktné informácie
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Transaction reference no {0} dated {1},Referenčné číslo transakcie {0} zo dňa {1}
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Currency is required for Price List {0},Pre cenník {0} sa vyžaduje mena
DocType: Program,Program Name,Názov programu
apps/erpnext/erpnext/accounts/doctype/account/account.js,This is a root account and cannot be edited.,Toto je konto root a nedá sa upraviť.
apps/erpnext/erpnext/projects/doctype/task/task.py,'Expected Start Date' can not be greater than 'Expected End Date',„Očakávaný dátum začiatku“ nemôže byť väčší ako „očakávaný dátum ukončenia“
DocType: Employee Tax Exemption Declaration Category,Employee Tax Exemption Declaration Category,Kategória vyhlásenia o oslobodení zamestnancov od dane
DocType: Work Order,Item To Manufacture,Položka na výrobu
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,In Qty,V množstve
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","&quot;Is Fixed Asset&quot; nie je možné zrušiť, pretože proti položke existuje záznam o aktívach"
DocType: Salary Component,Flexible Benefits,Flexibilné výhody
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Approval Notification,Opustiť oznámenie o schválení
DocType: Employee Tax Exemption Proof Submission,Total Actual Amount,Celková skutočná suma
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party is mandatory,Strana je povinná
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Check all,Skontrolujte všetko
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.","Ak je pre Vernostné body neobmedzená doba platnosti, ponechajte prázdnu dobu platnosti alebo 0."
DocType: Attendance Request,Explanation,vysvetlenie
DocType: Journal Entry Account,Exchange Rate,Výmenný kurz
DocType: Task,Total Costing Amount (via Time Sheet),Celková čiastka nákladov (prostredníctvom časového výkazu)
DocType: Tax Rule,Billing County,Fakturačný kraj
DocType: Lead Source,Lead Source,Zdroj olova
DocType: Email Digest,Next email will be sent on:,Ďalší e-mail bude odoslaný na:
DocType: Batch,Source Document Type,Typ zdrojového dokumentu
DocType: Project,Frequency To Collect Progress,Frekvencia zberu pokroku
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Head of Marketing and Sales,Vedúci marketingu a predaja
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Supplier Quotation {0} created,Vytvorila sa dodávateľská ponuka {0}
apps/erpnext/erpnext/setup/doctype/company/company.js,Successfully deleted all transactions related to this company!,Všetky transakcie súvisiace s touto spoločnosťou boli úspešne odstránené!
DocType: Purchase Taxes and Charges,On Net Total,On Net Total
DocType: Bank Transaction Mapping,Column in Bank File,Stĺpec v bankovom súbore
DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Hold,vydržať
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,You can not enter current voucher in 'Against Journal Entry' column,Nemôžete zadať aktuálny poukaz v stĺpci „Proti denníku“
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid authentication error,Chyba pri overovaní pravosti
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Please select Company and Party Type first,Najprv vyberte spoločnosť a typ strany
apps/erpnext/erpnext/utilities/user_progress.py,Go to ,Ísť do
,Work Orders in Progress,Prebiehajúce pracovné príkazy
DocType: Payment Reconciliation,To Invoice Date,Do dátumu faktúry
DocType: Staffing Plan Detail,Vacancies,voľné miesta
DocType: Purchase Order Item,Last Purchase Rate,Posledná nákupná sadzba
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Sales Expenses,Predajné náklady
DocType: Healthcare Settings,Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,"Účty v prípade zlyhania príjmu, ktoré sa majú použiť, ak nie sú stanovené lekárom, aby si účtovali poplatky za vymenovanie."
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Student Group is already updated.,Skupina študentov je už aktualizovaná.
DocType: Driver,Fleet Manager,Manažér flotily
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,You are not authorized to approve leaves on Block Dates,Nemáte oprávnenie schvaľovať listy na Blokových dátumoch
,Purchase Invoice Trends,Kúpiť trendy faktúr
DocType: Purchase Taxes and Charges,On Previous Row Amount,Na predchádzajúcej výške riadku
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py,No Tax Withholding data found for the current Fiscal Year.,Pre aktuálny fiškálny rok neboli zistené žiadne zrážkové údaje.
DocType: Travel Itinerary,Taxi,taxi
DocType: Contract,Inactive,neaktívne
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Actual qty in stock,Skutočné množstvo na sklade
DocType: Student Sibling,Student Sibling,Študent Sibling
apps/erpnext/erpnext/utilities/user_progress.py,Go to Rooms,Prejsť na Izby
apps/erpnext/erpnext/utilities/activation.py,Create Employee Records,Vytvorte záznamy zamestnancov
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Ordered Qty: Quantity ordered for purchase, but not received.","Objednané množstvo: Množstvo objednané na nákup, ale neprijaté."
DocType: Patient,Patient ID,ID pacienta
DocType: Employee,Permanent Address Is,Trvalá adresa je
DocType: Hotel Room Reservation,Guest Name,Meno hosťa
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Accumulated Values in Group Company,Akumulované hodnoty v spoločnosti skupiny
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Resume,Pokračovať
,BOM Stock Calculated,Skladom kusovníka Vypočítané
DocType: Employee Transfer,New Employee ID,Nové ID zamestnanca
apps/erpnext/erpnext/config/accounting.py,Tax template for selling transactions.,Vzor dane pre predajné transakcie.
DocType: Currency Exchange,To Currency,Do meny
DocType: Course Schedule,Instructor Name,Meno inštruktora
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Research,výskum
DocType: Additional Salary,Employee Name,Meno zamestnanca
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance can not be marked for future dates,Účasť nie je možné označiť pre budúce dátumy
DocType: Supplier Scorecard Scoring Standing,Min Grade,Min
DocType: Work Order,Manufactured Qty,Vyrobené Množstvo
DocType: Patient,Alcohol Current Use,Súčasné používanie alkoholu
DocType: Leave Application,Total Leave Days,Celkové dni dovoleniek
DocType: Asset Repair,Repair Status,Stav opravy
DocType: Territory,Territory Manager,Správca územia
DocType: Lab Test,Sample ID,ID vzorky
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html,Cart is Empty,Košík je prázdny
apps/erpnext/erpnext/hr/doctype/shift_type/shift_type.js,Attendance has been marked as per employee check-ins,Účasť bola označená ako check-in zamestnanca
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset {0} must be submitted,Musí sa odoslať položka {0}
,Absent Student Report,Absent Student Report
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Included in Gross Profit,Zahrnuté v hrubom zisku
apps/erpnext/erpnext/accounts/page/pos/pos.js,Price List not found or disabled,Cenník nebol nájdený alebo zakázaný
DocType: Travel Request Costing,Funded Amount,Financovaná 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: Subscription,Trial Period End Date,Dátum ukončenia skúšobného obdobia
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: BOM Update Tool,The new BOM after replacement,Nový kusovník po výmene
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 5,Položka 5
DocType: Employee,Passport Number,Číslo pasu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Opening,Dočasné otvorenie
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Pricing Rules are further filtered based on quantity.,Pravidlá tvorby cien sa ďalej filtrujú na základe množstva.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Appraisal {0} created for Employee {1} in the given date range,Hodnotenie {0} vytvorené pre zamestnanca {1} v danom rozsahu dátumov
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Variance,odchýlka
DocType: Sales Order,Partly Delivered,Čiastočne dodané
DocType: Item,Maintain Stock,Udržať zásoby
DocType: Job Card,Started Time,Začiatok času
DocType: Item,Average time taken by the supplier to deliver,"Priemerný čas, ktorý dodávateľ dodá"
DocType: Stock Entry,Per Transferred,Per Transferred
DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),"Označuje, že balík je súčasťou tejto dodávky (iba koncept)"
DocType: Upload Attendance,Get Template,Získať šablónu
DocType: Agriculture Task,Next Business Day,Nasledujúci pracovný deň
DocType: Payment Reconciliation,Receivable / Payable Account,Účet pohľadávok / záväzkov
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,You cannot credit and debit same account at the same time,Nemôžete súčasne pripisovať a debetovať ten istý účet
DocType: Agriculture Analysis Criteria,Weather,počasie
,Welcome to ERPNext,Vitajte v ERPNext
DocType: Payment Reconciliation,Maximum Invoice Amount,Maximálna čiastka faktúry
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Expense Claim for Vehicle Log {0},Žiadosť o výdavok pre protokol vozidla {0}
DocType: Healthcare Settings,Patient Encounters in valid days,Stretnutia pacienta v platné dni
,Student Fee Collection,Kolekcia študentských poplatkov
DocType: Selling Settings,Sales Order Required,Požadovaná zákazka odberateľa
DocType: Stock Entry Detail,Serial No / Batch,Sériové číslo / dávka
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Statement of Account,Výpis z účtu
DocType: Job Offer Term,Offer Term,Termín ponuky
apps/erpnext/erpnext/setup/doctype/company/company.py,Account {0} does not belong to company: {1},Účet {0} nepatrí spoločnosti: {1}
DocType: Tally Migration,Tally Migration,Tally Migrácia
DocType: Item,"Purchase, Replenishment Details","Podrobnosti o nákupe, doplnení"
DocType: Purchase Invoice,"Once set, this invoice will be on hold till the set date",Po nastavení bude táto faktúra pozastavená do stanoveného dátumu
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock cannot exist for Item {0} since has variants,"Akcia neexistuje pre položku {0}, pretože má varianty"
DocType: Lab Test Template,Grouped,zoskupené
DocType: GSTR 3B Report,January,január
DocType: Course Assessment Criteria,Course Assessment Criteria,Kritériá hodnotenia kurzu
DocType: Certification Application,INR,INR
apps/erpnext/erpnext/config/accounting.py,Profitability,Ziskovosť
DocType: Job Card Time Log,Completed Qty,Dokončené množstvo
DocType: Agriculture Task,Start Day,Deň začiatku
apps/erpnext/erpnext/config/integrations.py,GoCardless payment gateway settings,Nastavenia platobnej brány GoCardless
DocType: Asset Category Account,Depreciation Expense Account,Účet odpisov výdavkov
DocType: Production Plan Sales Order,Production Plan Sales Order,Výrobný plán Zákazka odberateľa
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 výrobku <b>{0}</b> a pre množstvo <b>{1}</b> sa nemôže líšiť
apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js,View Lab Tests,Zobraziť laboratórne testy
DocType: Article,Instructor,inštruktor
DocType: Shopping Cart Settings,Show Public Attachments,Zobraziť verejné prílohy
DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Polia budú skopírované iba v čase vytvorenia.
DocType: Delivery Note,Vehicle No,Vozidlo č
DocType: Lead,CRM-LEAD-.YYYY.-,CRM-LEAD-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry is already created,Položka platby je už vytvorená
apps/erpnext/erpnext/stock/doctype/item/item.js,Multiple Variants,Viac variantov
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please select a csv file,Vyberte súbor csv
DocType: Serial No,Serial No Details,Podrobnosti sériového čísla
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Source and Target Location cannot be same,Zdrojová a cieľová poloha nemôže byť rovnaká
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Show Employee,Zobraziť zamestnanca
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 nebolo možné ho znova vytvoriť
DocType: Payment Entry,Writeoff,odpísanie
DocType: Issue,ISS-.YYYY.-,ISS-.YYYY.-
DocType: Payment Order,Payment Request,Žiadosť o platbu
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 mať zaškrtnuté políčka nákupu a predaja.
apps/erpnext/erpnext/accounts/doctype/account/account.py,Cannot covert to Group because Account Type is selected.,"Nie je možné previesť na skupinu, pretože je vybratý Typ účtu."
DocType: Company,Exchange Gain / Loss Account,Účet výmeny / straty
DocType: Project Template,Project Template,Šablóna projektu
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Reorder Qty,Zoradiť počet kusov
apps/erpnext/erpnext/accounts/report/financial_statements.html,Too many columns. Export the report and print it using a spreadsheet application.,Príliš veľa stĺpcov. Exportujte prehľad a vytlačte ho pomocou tabuľkovej aplikácie.
DocType: Payroll Entry,Salary Slips Submitted,Predložené platové lístky
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,For Supplier,Pre dodávateľa
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}.,Účtovné položky už boli vykonané v mene {0} pre spoločnosť {1}. Vyberte účet pohľadávok alebo záväzkov s menou {0}.
DocType: Asset Value Adjustment,New Asset Value,Nová hodnota aktív
DocType: Volunteer,Volunteer Type,Typ dobrovoľníka
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Printed On,Vytlačené dňa
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js,Grant Leaves,Grant listy
DocType: Vehicle,Vehicle Value,Hodnota vozidla
,Project Billing Summary,Prehľad fakturácie projektu
DocType: Asset,Receipt,príjem
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule' to get schedule,"Ak chcete získať rozvrh, kliknite na položku Generovať plán"
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,TDS Rate %,TDS sadzba%
DocType: Training Event,Contact Number,Kontaktné číslo
DocType: POS Closing Voucher,POS Closing Voucher,Pokladničný poukaz POS
DocType: Quality Inspection Template,Quality Inspection Template Name,Názov šablóny kontroly kvality
apps/erpnext/erpnext/public/js/hub/marketplace.js,Added {0} users,Pridané {0} používateľov
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to Non-Group,"Prevod na skupinu, ktorá nie je skupina"
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Set as Lost,Nastaviť ako stratené
DocType: Journal Entry Account,Payroll Entry,Zadávanie miezd
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 o výmene mien pre {1} až {2}.
DocType: Delivery Note,Transporter Name,Názov transportéra
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é bol pracovný príkaz zvýšený, ale čaká na jeho výrobu."
DocType: Item,Has Variants,Má varianty
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Securities & Commodity Exchanges,Cenné papiere a komoditné burzy
DocType: Purchase Invoice Item,Deferred Expense,Odložený náklad
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py,Salary Slip ID,ID platového sklzu
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Membership ID,ID členstva
,Sales Register,Obchodný register
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Prosím, nastavte systém pomenovania zamestnancov v ľudských zdrojoch&gt; HR nastavenia"
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Please specify a valid 'From Case No.',Zadajte platný výraz „Od prípadu č.“
DocType: Customer,Primary Address and Contact Detail,Podrobnosti primárnej adresy a kontaktu
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,This is based on transactions against this Customer. See timeline below for details,Toto je založené na transakciách s týmto Zákazníkom. Podrobnosti nájdete v časovej osi nižšie
DocType: Hotel Room,Hotels,hotely
apps/erpnext/erpnext/regional/india/utils.py,You must be a registered supplier to generate e-Way Bill,"Ak chcete vytvoriť e-Way Bill, musíte byť registrovaným dodávateľom"
DocType: Shipping Rule,Valid for Countries,Platné pre krajiny
,Territory Target Variance Based On Item Group,Teritoriálna cieľová variácia založená na skupine položiek
DocType: Rename Tool,Rename Tool,Premenovať nástroj
DocType: Loan Application,Total Payable Amount,Celková splatná suma
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/manufacturing/doctype/bom/bom.py,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Riadok {0}: Mena kusovníka # {1} by sa mala rovnať zvolenej mene {2}
DocType: Pricing Rule,Product,výrobok
apps/erpnext/erpnext/utilities/bot.py,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} jednotiek [{1}] (# Form / Item / {1}) nájdete v [{2}] (# Form / Warehouse / {2})
DocType: Vital Signs,Weight (In Kilogram),Hmotnosť (v kilograme)
DocType: Department,Leave Approver,Nechajte schvaľovateľa
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,transakcie
DocType: Issue,Resolution Details,Podrobnosti o rozlíšení
DocType: Sales Invoice Item,Delivery Note Item,Položka dodacieho listu
DocType: QuickBooks Migrator,Connected to QuickBooks,Pripojené k QuickBooks
DocType: Item,Shelf Life In Days,Skladovateľnosť v dňoch
apps/erpnext/erpnext/config/buying.py,Key Reports,Kľúčové správy
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Possible Supplier,Možný dodávateľ
,Issued Items Against Work Order,Vydané položky proti pracovnému poriadku
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.py,Please enter GSTIN and state for the Company Address {0},Zadajte adresu GSTIN a uveďte adresu spoločnosti {0}
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Creating {0} Invoice,Vytvorenie {0} faktúry
DocType: Student,Joining Date,Dátum pripojenia
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 nastavte dátum začiatku a konca.
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requesting Site,Žiadajúca lokalita
DocType: Purchase Invoice,Against Expense Account,Proti výdavkovému účtu
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Cannot create a Delivery Trip from Draft documents.,Nepodarilo sa vytvoriť cestu doručenia z dokumentov konceptu.
apps/erpnext/erpnext/config/crm.py,Lead to Quotation,Uveďte ponuku
DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,"Skontrolujte, či študent sídli v hosteli ústavu."
apps/erpnext/erpnext/education/utils.py,Student {0} - {1} appears Multiple times in row {2} & {3},Študent {0} - {1} sa objaví Viacnásobne v riadku {2} &amp; {3}
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Creating Payment Entries......,Vytvorenie platobných položiek ......
DocType: Production Plan,Total Planned Qty,Celkový plánovaný počet
DocType: Subscription Plan,Cost,náklady
DocType: Healthcare Service Unit Type,Healthcare Service Unit Type,Typ jednotky zdravotnej starostlivosti
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,Please enter atleast 1 invoice in the table,Do tabuľky zadajte aspoň 1 faktúru
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Sales Order {0} is not submitted,Zákazka odberateľa {0} nie je odoslaná
apps/erpnext/erpnext/education/api.py,Attendance has been marked successfully.,Účasť bola úspešne označená.
apps/erpnext/erpnext/accounts/doctype/tax_category/tax_category_dashboard.py,Pre Sales,Predpredaj
apps/erpnext/erpnext/config/projects.py,Project master.,Riaditeľ projektu.
DocType: Daily Work Summary,Daily Work Summary,Zhrnutie dennej práce
DocType: Asset,Partially Depreciated,Čiastočne odpisované
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,'Days Since Last Order' must be greater than or equal to zero,„Dni od poslednej objednávky“ musia byť väčšie alebo rovné nule
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,For Default Supplier (optional),Pre predvoleného dodávateľa (voliteľné)
DocType: Employee,Leave Encashed?,Opustiť Encashed?
DocType: Certified Consultant,Discuss ID,Diskutovať o ID
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Please set GST Accounts in GST Settings,Nastavte GST účty v nastaveniach GST
DocType: Quiz,Latest Highest Score,Najnovšie najvyššie skóre
DocType: Supplier,Billing Currency,Fakturačná mena
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Student Activity,Aktivita študenta
apps/erpnext/erpnext/setup/doctype/territory/territory.py,Either target qty or target amount is mandatory,Povinné je buď cieľové množstvo alebo cieľová suma
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ým fiškálnym rokom. Obnovte svoj prehliadač, aby sa zmena prejavila."
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Address 2,Z adresy 2
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Of the supplies shown in 3.1 (a) above, details of inter-State supplies made to unregisterd
	persons, composition taxable persons and UIN holders","Z dodávok uvedených v bode 3.1 písm. A) sa uvádzajú podrobnosti o medzištátnych dodávkach poskytnutých neregistrovaným osobám, zloženým zdaniteľným osobám a držiteľom UIN"
DocType: Company,Default Inventory Account,Predvolený účet zásob
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Dátum konca roka nemôže byť skorší ako dátum začiatku roka. Opravte dátumy a skúste to znova.
DocType: Target Detail,Target  Amount,Cieľová čiastka
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Hotel Rooms of type {0} are unavailable on {1},Izby hotela typu {0} nie sú k dispozícii na {1}
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,New Customer Revenue,Nové výnosy zákazníkov
DocType: Landed Cost Item,Applicable Charges,Platné poplatky
,Point of Sale,Miesto predaja
DocType: Authorization Rule,Approving User  (above authorized value),Schválenie používateľa (nad autorizovanou hodnotou)
DocType: Service Level Agreement,Entity,bytosť
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} transferred from {2} to {3},Suma {0} {1} prevedená z {2} na {3}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Customer {0} does not belong to project {1},Zákazník {0} nepatrí do projektu {1}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Party Name,Z názvu strany
DocType: Asset Maintenance Log,Maintenance Status,Stav údržby
DocType: Production Plan Item,Pending Qty,Čakajúce množstvo
apps/erpnext/erpnext/controllers/accounts_controller.py, or ,alebo
DocType: Sales Order,Not Delivered,Nedoručený
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leave Type {0} cannot be allocated since it is leave without pay,"Typ dovolenky {0} nemožno prideliť, pretože ide o dovolenku bez platu"
DocType: GL Entry,Debit Amount,Suma debetu
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Already record exists for the item {0},Pre položku {0} už existuje záznam
DocType: Video,Vimeo,Vimeo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Sub Assemblies,Podskupiny
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.","Ak bude naďalej platiť viacero pravidiel tvorby cien, používatelia budú požiadaní, aby nastavili prioritu manuálne, aby sa vyriešil konflikt."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Nie je možné odpočítať, keď je kategória pre „Ocenenie“ alebo „Ocenenie a Spolu“"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,BOM and Manufacturing Quantity are required,Vyžaduje sa kusovník a výrobné množstvo
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} has reached its end of life on {1},Položka {0} dosiahla koniec svojej životnosti {1}
DocType: Quality Inspection Reading,Reading 6,Čítanie 6
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Company field is required,Vyžaduje sa pole spoločnosti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Material Consumption is not set in Manufacturing Settings.,Spotreba materiálu nie je nastavená vo výrobných nastaveniach.
DocType: Assessment Group,Assessment Group Name,Názov hodnotiacej skupiny
DocType: Purchase Invoice Item,Manufacturer Part Number,Typ. Označenie
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Payroll Payable,Splatné mzdy
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Row #{0}: {1} can not be negative for item {2},Riadok # {0}: {1} nemôže byť záporný pre položku {2}
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Balance Qty,Zostatok Množstvo
DocType: Question,Multiple Correct Answer,Viacnásobná správna odpoveď
DocType: Loyalty Program,1 Loyalty Points = How much base currency?,1 Vernostné body = Koľko základnej meny?
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Poznámka: Zostatok na dovolenke {0} nie je dostatočný
DocType: Clinical Procedure,Inpatient Record,Záznam pacienta
DocType: Sales Invoice Item,Customer's Item Code,Kód položky zákazníka
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Item Code,Zmeniť kód položky
DocType: Student Group Instructor,Student Group Instructor,Študent Group Instructor
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Transaction Type,Typ transakcie
apps/erpnext/erpnext/regional/india/utils.py,House rented dates should be atleast 15 days apart,Dom prenajaté termíny by mali byť aspoň 15 dní od seba
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,View Form,Zobraziť formulár
apps/erpnext/erpnext/stock/doctype/item/item.py,Valuation Rate is mandatory if Opening Stock entered,"Miera ocenenia je povinná, ak je zadaná Otvorená zásoba"
DocType: Employee,Exit Interview Details,Ukončite podrobnosti rozhovoru
DocType: Sales Invoice,Accounting Details,Účtovné údaje
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Plán údržby {0} musí byť zrušený pred zrušením tejto zákazky odberateľa
DocType: Driver,HR-DRI-.YYYY.-,HR-DRI-.YYYY.-
DocType: Customer,Mention if non-standard receivable account,"Uveďte, či ide o neštandardný účet pohľadávok"
DocType: Lab Test,Prescription,predpis
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Closed,Nastaviť ako zatvorené
DocType: Asset,Opening Accumulated Depreciation,Otvorenie akumulovaných odpisov
DocType: Soil Texture,Sand Composition (%),Zloženie piesku (%)
DocType: Communication Medium,Communication Medium Type,Typ komunikačného média
DocType: Production Plan,MFG-PP-.YYYY.-,MFG-PP-.YYYY.-
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Day Book Data,Importovať údaje dennej knihy
DocType: Asset,Asset Owner Company,Majiteľ spoločnosti
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Cost center is required to book an expense claim,Nákladové stredisko musí rezervovať nárok na výdavky
apps/erpnext/erpnext/stock/utils.py,{0} valid serial nos for Item {1},{0} platné sériové čísla pre položku {1}
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Cannot promote Employee with status Left,Nie je možné propagovať zamestnanca so stavom vľavo
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expiry (In Days),Vypršanie platnosti (v dňoch)
DocType: Supplier Scorecard Standing,Notify Other,Upozorniť iné
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Please select Company,Vyberte spoločnosť
,Item-wise Purchase Register,Nákupný register po položkách
DocType: Employee,Reason For Leaving,Dôvod na odchod
DocType: Salary Slip,Earning & Deduction,Zisk a odpočet
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Employee Referral,Postúpenie zamestnanca
,Qty to Order,Počet na objednávku
apps/erpnext/erpnext/config/buying.py,Request for purchase.,Žiadosť o nákup.
DocType: Bin,Moving Average Rate,Pohyblivá priemerná rýchlosť
apps/erpnext/erpnext/config/buying.py,Tax template for buying transactions.,Vzor dane pre nákupné transakcie.
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Send SMS,Odoslať SMS
apps/erpnext/erpnext/erpnext_integrations/utils.py,Unverified Webhook Data,Neoverené údaje Webhook
apps/erpnext/erpnext/config/help.py,Human Resource,Ľudský zdroj
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} has been modified. Please refresh.,{0} {1} bolo zmenené. Obnovte ho.
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},Stav zásob v dávke {0} sa stane {1} pre položku {2} na sklade {3}.
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Creating Accounts...,Vytváranie účtov ...
,Asset Depreciation Ledger,Majetok odpisovania majetku
DocType: Location,Tree Details,Podrobnosti o stromoch
DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Vytvorte chýbajúceho zákazníka alebo dodávateľa.
DocType: Vital Signs,Blood Pressure (diastolic),Krvný tlak (diastolický)
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: Item,Show in Website (Variant),Zobraziť na webovej stránke (variant)
apps/erpnext/erpnext/education/doctype/fees/fees.js,Please set the Email ID for the Student to send the Payment Request,Nastavte ID e-mailu pre študenta na odoslanie žiadosti o platbu
DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Vytvorte baliace pásky na balenie. Používa sa na oznámenie čísla obalu, obsahu balenia a jeho hmotnosti."
DocType: SMS Log,No of Requested SMS,Počet požadovaných SMS
apps/erpnext/erpnext/config/accounting.py,Banking and Payments,Bankovníctvo a platby
DocType: Instructor,Instructor Log,Log inštruktora
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álna výhoda zamestnanca {0} prevyšuje {1} sumou {2} dávky pre-rata komponentu dávky a predchádzajúcej nárokovanej sumy
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Please enter valid email address,Zadajte platnú e-mailovú adresu
apps/erpnext/erpnext/config/retail.py,Retail Operations,Maloobchodné operácie
DocType: Company,Phone No,Telefonne cislo
,Reqd By Date,Reqd Podľa dátumu
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Uncheck all,Odznačiť všetky
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Place,Na miesto
DocType: Manufacturing Settings,Default Work In Progress Warehouse,Default Work In Progress Warehouse
DocType: Fees,Include Payment,Zahrnúť platbu
DocType: Crop,Byproducts,vedľajšie produkty
DocType: Assessment Result,Student,študent
apps/erpnext/erpnext/config/crm.py,Manage Customer Group Tree.,Spravovať strom skupiny zákazníkov.
DocType: Payment Entry,Payment From / To,Platba z / do
apps/erpnext/erpnext/stock/utils.py,Serial number {0} entered more than once,Sériové číslo {0} bolo zadané viac ako raz
DocType: Website Item Group,Website Item Group,Skupina položiek webovej stránky
DocType: Amazon MWS Settings,CA,CA
DocType: Serial No,Under Warranty,V záruke
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,Invoice Posting Date,Dátum účtovania faktúry
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Delivery Note,Dodací list
DocType: Education Settings,Attendance Freeze Date,Dátum zmrazenia účasti
DocType: Warranty Claim,Item and Warranty Details,Podrobnosti o položke a záruke
DocType: Job Card,Time Logs,Časové denníky
DocType: Hotel Room,Extra Bed Capacity,Kapacita prístelky
DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,"Čistá mzda (slovami) bude viditeľná, keď uložíte platový sklz."
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Could not solve weighted score function. Make sure the formula is valid.,"Nepodarilo sa vyriešiť funkciu váženého skóre. Uistite sa, že vzorec je platný."
DocType: Asset,Asset Owner,Majiteľ majetku
apps/erpnext/erpnext/buying/utils.py,Warehouse is mandatory for stock Item {0} in row {1},Sklad je povinný na sklade Položka {0} v riadku {1}
DocType: Stock Entry,Total Additional Costs,Celkové dodatočné náklady
apps/erpnext/erpnext/regional/italy/utils.py,Please set at least one row in the Taxes and Charges Table,Nastavte aspoň jeden riadok v tabuľke Dane a poplatky
DocType: Asset Maintenance Team,Maintenance Team Name,Názov tímu údržby
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Chart of Cost Centers,Graf nákladových stredísk
apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Prejdite na položku Používatelia
DocType: Pricing Rule,Item Code,Kód položky
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,'Opening',", Otváranie &#39;"
DocType: Payment Entry,Set Exchange Gain / Loss,Nastaviť výmenu zisku / straty
DocType: Accounts Settings,Make Payment via Journal Entry,Uskutočnite platbu prostredníctvom vstupu do denníka
DocType: Bank,Bank Transaction Mapping,Mapovanie bankových transakcií
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,User has not applied rule on the invoice {0},Používateľ neuplatnil pravidlo na faktúre {0}
apps/erpnext/erpnext/config/accounting.py,Payment Terms based on conditions,Platobné podmienky založené na podmienkach
DocType: Purchase Order,% Received,% Prijaté
DocType: Sales Order Item,Work Order Qty,Počet pracovných objednávok
DocType: Job Card,WIP Warehouse,WIP Warehouse
DocType: Payment Request,ACC-PRQ-.YYYY.-,ACC-PRQ-.YYYY.-
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,User ID not set for Employee {0},ID používateľa nie je nastavené pre zamestnanca {0}
apps/erpnext/erpnext/education/doctype/guardian/guardian.py,User {0} created,Používateľ {0} bol vytvorený
DocType: Stock Settings,Item Naming By,Pomenovanie položky podľa
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js,Ordered,objednaný
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,No communication found.,Nebola nájdená žiadna komunikácia.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/regional/india_list.js,Generate e-Way Bill JSON,Generovanie e-Way Bill JSON
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js,This is a root customer group and cannot be edited.,Toto je skupina zákazníkov root a nedá sa upraviť.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Material Request {0} is cancelled or stopped,Požiadavka materiálu {0} sa zruší alebo zastaví
DocType: Shift Type,Strictly based on Log Type in Employee Checkin,Prísne na základe typu denníka v položke Zamestnanec Checkin
DocType: Purchase Order Item Supplied,Supplied Qty,Dodávané množstvo
DocType: Cash Flow Mapper,Cash Flow Mapper,Mapovač peňažných tokov
DocType: Soil Texture,Sand,piesok
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Employee cannot report to himself.,Zamestnanec sa nemôže hlásiť sám sebe.
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_log/shopify_log.js,Order rescheduled for sync,Objednávka bola naplánovaná na synchronizáciu
apps/erpnext/erpnext/stock/doctype/item/item.py,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Predvolená jednotka merania pre variant &#39;{0}&#39; musí byť rovnaká ako v šablóne &#39;{1}&#39;
DocType: Blanket Order,Purchasing,nákup
DocType: Driver,Cellphone Number,Mobilné číslo
DocType: Salary Slip,Gross Pay,Hrubá mzda
DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Cenník balíkov hotelových izieb
DocType: Pricing Rule,Is Cumulative,Je kumulatívny
apps/erpnext/erpnext/templates/pages/cart.html,Your cart is Empty,Vaša karta je prázdna
,Daily Timesheet Summary,Denné zhrnutie časového rozvrhu
apps/erpnext/erpnext/quality_management/doctype/quality_procedure/quality_procedure_tree.js,New Quality Procedure,Nový postup kvality
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,subdodávky
DocType: Fee Schedule Program,Total Students,Celkový počet študentov
apps/erpnext/erpnext/utilities/user_progress_utils.py,Local,miestna
DocType: Chapter Member,Leave Reason,Nechajte dôvod
DocType: Salary Component,Condition and Formula,Stav a vzorec
DocType: Quality Goal,Objectives,ciele
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ý za obdobie medzi {0} a {1}, obdobie odchodu aplikácie nemôže byť medzi týmto rozsahom dátumov."
DocType: BOM Item,Basic Rate (Company Currency),Základná sadzba (mena spoločnosti)
DocType: BOM Scrap Item,BOM Scrap Item,Položka kusovníka
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Serial #,Sériové číslo
DocType: Activity Type,Default Billing Rate,Predvolená fakturačná sadzba
DocType: Vital Signs,Coated,obalený
DocType: Patient Appointment,More Info,Viac informácií
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Bill of Materials,Kusovník
DocType: Purchase Invoice,Inter Company Invoice Reference,Referenčná faktúra medzi spoločnosťami
DocType: Crop Cycle,Cycle Type,Typ cyklu
DocType: Employee Separation,Exit Interview Summary,Ukončenie prehľadu rozhovoru
,Item Variant Details,Podrobnosti o variante položky
DocType: Contract,Partially Fulfilled,Čiastočne splnené
DocType: Journal Entry,ACC-JV-.YYYY.-,ACC-JV-.YYYY.-
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,To {0},Do {0}
DocType: GST Settings,GST Accounts,Účty GST
DocType: C-Form,Total Invoiced Amount,Celková fakturovaná suma
DocType: Manufacturing Settings,Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order,Zakáže vytváranie časových denníkov proti pracovným príkazom. Operácie nesmú byť sledované voči pracovnému poriadku
apps/erpnext/erpnext/stock/utils.py,Group node warehouse is not allowed to select for transactions,Sklad skupiny uzlov nie je oprávnený vybrať pre transakcie
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Hovor je odpojený
DocType: Subscriber,Subscriber Name,Meno účastníka
DocType: Purchase Order,Customer Mobile No,Zákazník Mobile č
DocType: Bank Guarantee,Receiving,príjem
DocType: Account,Is Group,Je skupina
DocType: Healthcare Practitioner,Contacts and Address,Kontakty a Adresa
DocType: Warehouse,Warehouse Name,Názov skladu
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as it is a Holiday.,Účasť nie je predložená na {0} ako je sviatok.
DocType: Leave Type,Rounding,zaokrúhľovania
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Ineligible ITC,Neoprávnené ITC
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,{0} created,{0} vytvorené
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,"Vyberte hlavu účtu banky, v ktorej bol uložený šek."
DocType: Service Level,Support and Resolution,Podpora a riešenie
DocType: Account,Bank,breh
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Receive at Warehouse Entry,Prijať pri vstupe do skladu
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Send Supplier Emails,Odoslať e-maily dodávateľa
DocType: Lab Test Groups,Add new line,Pridať nový riadok
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate item group found in the item group table,Duplicitná skupina položiek nájdená v tabuľke skupiny položiek
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Annual Salary,Ročný plat
DocType: Supplier Scorecard,Weighting Function,Funkcia váženia
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py,Error evaluating the criteria formula,Chyba pri hodnotení vzorca kritérií
,Lab Test Report,Laboratórny test
DocType: BOM,With Operations,S operáciami
apps/erpnext/erpnext/utilities/user_progress.py,People who teach at your organisation,"Ľudia, ktorí učia vo vašej organizácii"
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} does not belongs to company {1},Účet {0} nepatrí spoločnosti {1}
DocType: Item,Has Expiry Date,Dátum skončenia platnosti
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,Sum of Scores of Assessment Criteria needs to be {0}.,Súčet hodnotiacich kritérií musí byť {0}.
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Property already added,Vlastnosť už bola pridaná
DocType: Supplier,SUP-.YYYY.-,SUP-.YYYY.-
DocType: Expense Claim Account,Expense Claim Account,Účet nárokov na výdavky
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments available for Journal Entry,Pre zápis do denníka nie sú k dispozícii žiadne splátky
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} je neaktívny študent
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Vstup do skladu
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: Employee Onboarding,Activities,aktivity
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Atleast one warehouse is mandatory,Minimálne jeden sklad je povinný
,Customer Credit Balance,Zostatok kreditu zákazníka
DocType: BOM,Operations,operácie
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Create Salary Slips,Vytvorte platové lístky
,Monthly Attendance Sheet,Mesačný dochádzkový list
DocType: Vital Signs,Reflexes,reflexy
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,"Service Item,Type,frequency and expense amount are required","Vyžaduje sa servisná položka, typ, frekvencia a výška výdavkov"
DocType: Supplier Scorecard Period,Variables,premenné
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Multiple Loyalty Program found for the Customer. Please select manually.,Pre zákazníka bol nájdený viacnásobný vernostný program. Vyberte manuálne.
DocType: Patient,Medication,liečenie
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Select Loyalty Program,Vyberte Vernostný program
DocType: Employee Checkin,Attendance Marked,Účasť označená
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Raw Materials,Suroviny
DocType: Sales Order,Fully Billed,Plne účtované
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Please set Hotel Room Rate on {},Nastavte cenu hotelovej izby na {}
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Select only one Priority as Default.,Vyberte iba jednu prioritu ako predvolenú.
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 (Ledger) pre typ - {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Total Credit/ Debit Amount should be same as linked Journal Entry,Celková suma úveru / debetu by mala byť rovnaká ako viazaná položka denníka
DocType: Purchase Invoice Item,Is Fixed Asset,Je fixný majetok
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Party Name,Pre názov strany
apps/erpnext/erpnext/stock/doctype/item/item.js,This Item is a Variant of {0} (Template).,Táto položka je variantom {0} (šablóny).
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 aktualizovať alebo stanoviť množstvo a ocenenie zásob v systéme. Zvyčajne sa používa na synchronizáciu systémových hodnôt a toho, čo skutočne existuje vo vašich skladoch."
DocType: Cashier Closing,Net Amount,Čistá čiastka
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Selling Price List,Predajný cenník
DocType: Amazon MWS Settings,IT,IT
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,{0} must be negative in return document,{0} musí byť v dokumente s vrátením záporné
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please select a valid Date,Vyberte platný dátum
DocType: Agriculture Task,End Day,Deň ukončenia
apps/erpnext/erpnext/templates/emails/training_event.html,Please confirm once you have completed your training,"Potvrďte prosím, keď ste ukončili školenie"
apps/erpnext/erpnext/utilities/user_progress.py,Go to Letterheads,Prejsť na Hlavičkový papier
DocType: Leave Block List Allow,Allow User,Povoliť používateľovi
DocType: Sales Order,% of materials delivered against this Sales Order,% materiálu dodaného proti tejto zákazke odberateľa
DocType: Purpose of Travel,Purpose of Travel,Účel cesty
DocType: Healthcare Settings,Appointment Confirmation,Potvrdenie o vymenovaní
DocType: Shopping Cart Settings,Orders,objednávky
DocType: HR Settings,Retirement Age,Dôchodkový vek
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Projected Qty,Premietané množstvo
apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Vymazanie nie je povolené pre krajinu {0}
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} is already {2},Riadok # {0}: Hodnota {1} je už {2}
DocType: Delivery Note,Installation Status,Stav inštalácie
DocType: Item Attribute Value,Attribute Value,Hodnota atribútu
DocType: Sales Invoice,Base Change Amount (Company Currency),Základná čiastka zmeny (mena spoločnosti)
DocType: Leave Allocation,Unused leaves,Nepoužité listy
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Finished Item {0} must be entered for Manufacture type entry,Pre položku Typ výroby je potrebné zadať položku {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,'Entries' cannot be empty,&#39;Záznamy&#39; nemôžu byť prázdne
apps/erpnext/erpnext/utilities/user_progress.py,Go to Courses,Prejsť na kurzy
DocType: Fee Schedule,Fee Breakup for each student,Poplatok za porušenie pre každého študenta
DocType: Item,Will also apply for variants,Platí aj pre varianty
DocType: Shopify Settings,Shared secret,Zdieľané tajomstvo
DocType: POS Profile,Write Off Cost Center,Centrum pre odpis nákladov
DocType: Soil Texture,Silty Clay,Silty Clay
DocType: Loyalty Point Entry Redemption,Redeemed Points,Uplatnené body
DocType: GoCardless Mandate,Mandate,mandát
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Multiple,Vytvoriť viac
DocType: Supplier Scorecard,Scoring Standings,Bodovanie
DocType: Support Search Source,Result Title Field,Výsledok Názov Pole
DocType: Leave Allocation,New Leaves Allocated,Pridelené nové listy
DocType: Homepage,Homepage,Úvodná stránka
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Compensatory Off,Kompenzačné Vypnuté
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices Summary,Otvorenie súhrnu faktúr
DocType: Vehicle Service,Engine Oil,Motorový olej
DocType: Job Applicant,Applicant Name,Meno žiadateľa
DocType: Bank Transaction,Unreconciled,nezmierilo
DocType: Serial No,Delivery Document No,Dodací doklad č
DocType: Hub Users,Hub Users,Používatelia rozbočovača
DocType: Bin,Actual Quantity,Skutočné množstvo
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Debit Note {0} has been created automatically,Debetná poznámka {0} bola vytvorená automaticky
DocType: Payment Term,Credit Days,Kreditné dni
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Id,Id projektu
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Electronics,elektronika
apps/erpnext/erpnext/controllers/accounts_controller.py,Due Date is mandatory,Dátum splatnosti je povinný
DocType: BOM Explosion Item,Qty Consumed Per Unit,Množstvo spotrebované na jednotku
,Completed Work Orders,Dokončené pracovné zákazky
DocType: Loyalty Program,Help Section,Sekcia Pomoc
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance date can not be less than employee's joining date,Dátum účasti nemôže byť kratší ako dátum nástupu zamestnanca
DocType: BOM,Total Cost(Company Currency),Celkové náklady (mena spoločnosti)
DocType: Subscription,Net Total,Čistý súčet
DocType: Procedure Prescription,Referral,postúpenie
DocType: Vehicle,Model,Model
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Please specify from/to range,Zadajte rozsah z / do rozsahu
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Quantity to Manufacture must be greater than 0.,Množstvo na výrobu musí byť väčšie ako 0. \ T
DocType: Maintenance Visit,Maintenance Time,Čas údržby
DocType: Asset,Naming Series,Pomenovanie sérií
DocType: Contract,Contract Terms,Zmluvné podmienky
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,Either target qty or target amount is mandatory.,Povinné je buď cieľové množstvo alebo cieľová suma.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,Invalid {0},Neplatné číslo {0}
DocType: Item,FIFO,FIFO
DocType: Inpatient Record,HLC-INP-.YYYY.-,HLC-INP-.YYYY.-
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation cannot have more than 5 characters,Skratka nesmie obsahovať viac ako 5 znakov
DocType: Employee Benefit Application,Max Benefits (Yearly),Max. Výhody (ročne)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Create Material Request,Vytvoriť požiadavku na materiál
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js,Primary Address Details,Podrobnosti primárnej adresy
DocType: Project Template Task,Duration (Days),Trvanie (dni)
DocType: Customer Feedback Template Table,Customer Feedback Template Table,Tabuľka šablón spätnej väzby od zákazníkov
DocType: Purchase Invoice Item,Price List Rate,Cenníková sadzba
DocType: Budget,Action if Annual Budget Exceeded on PO,"Opatrenie, ak ročný rozpočet presiahne PO"
DocType: POS Profile,Campaign,kampaň
DocType: POS Profile,Accounting,Účtovné
DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Na tomto území nastavte rozpočty skupín položiek. Môžete tiež zahrnúť sezónnosť nastavením Distribúcie.
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Insurance Start date should be less than Insurance End date,Dátum začiatku poistenia by mal byť kratší ako dátum poistenia
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items in progress,Prebieha {0} položiek
DocType: Item,Foreign Trade Details,Podrobnosti zahraničného obchodu
DocType: Quality Review Table,Yes/No,Áno nie
DocType: Tally Migration,Is Master Data Imported,Importuje sa kmeňové dáta
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 Daňový riadok {0} musí mať účet typu Daň alebo príjem alebo Výdavky alebo Účtovateľné
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/utilities/user_progress.py,Learn More,Uč sa viac
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/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,V poradí na výmenu kusovníka. Môže to trvať niekoľko minút.
DocType: Lab Test,Result Date,Dátum výsledku
apps/erpnext/erpnext/config/accounting.py,Currency exchange rate master.,Hlavný menový kurz.
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js,Latest price updated in all BOMs,Posledná cena aktualizovaná vo všetkých kusovníkoch
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Series Updated Successfully,Séria bola úspešne aktualizovaná
DocType: Soil Texture,Clay Loam,Clay Loam
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select item code,Vyberte kód položky
apps/erpnext/erpnext/accounts/page/pos/pos.js,Default warehouse is required for selected item,Pre vybranú položku sa vyžaduje predvolený sklad
apps/erpnext/erpnext/stock/get_item_details.py,No Item with Serial No {0},Žiadna položka so sériovým číslom {0}
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,Party Type and Party is mandatory for {0} account,Typ a strana strany je povinný pre účet {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Accountant,účtovný
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/pos_closing_voucher.py,POS Closing Voucher alreday exists for {0} between date {1} and {2},Poukaz POS Uzavretý poukaz alreday existuje pre {0} medzi dátumom {1} a {2}
apps/erpnext/erpnext/config/help.py,Navigating,Navigácia
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,No outstanding invoices require exchange rate revaluation,Žiadne nevyrovnané faktúry nevyžadujú preceňovanie výmenného kurzu
DocType: Authorization Rule,Customer / Item Name,Názov zákazníka / položky
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Nové sériové číslo nemôže mať sklad. Sklad musí byť nastavený vstupom do skladu alebo nákupným dokladom
DocType: Issue,Via Customer Portal,Cez Zákaznícky portál
DocType: Work Order Operation,Planned Start Time,Čas plánovaného spustenia
apps/erpnext/erpnext/controllers/buying_controller.py,{0} {1} is {2},{0} {1} je {2}
DocType: Service Level Priority,Service Level Priority,Priorita úrovne služby
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Počet rezervovaných odpisov nesmie byť väčší ako celkový počet odpisov
apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js,Share Ledger,Podiel Ledger
DocType: Journal Entry,Accounts Payable,Záväzky
DocType: Job Offer,Select Terms and Conditions,Vyberte Zmluvné podmienky
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Ends On date cannot be before Next Contact Date.,Dátum ukončenia nemôže byť pred dátumom ďalšieho kontaktu.
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}
DocType: Employee Tax Exemption Sub Category,Tax Exemption Category,Kategória oslobodenia od dane
DocType: Sales Invoice,Debit To,Debetovať
DocType: Company,Date of Establishment,Dátum založenia
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Leave Type is madatory,Typ dovolenky je šialený
DocType: Sales Invoice,Sales Taxes and Charges Template,Predajné dane a poplatky šablóny
DocType: Purchase Receipt,Return Against Purchase Receipt,Return Against Purchase Receipt
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Student Group: ,Študentská skupina:
DocType: Cheque Print Template,Cheque Size,Skontrolujte veľkosť
,Consolidated Financial Statement,Konsolidovaná účtovná závierka
DocType: Cheque Print Template,Scanned Cheque,Naskenovaná kontrola
DocType: Restaurant Reservation,Reservation End Time,Čas ukončenia rezervácie
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,In Value,V hodnote
DocType: Job Opening,Staffing Plan,Personálny plán
DocType: Manufacturing Settings,Material Transferred for Manufacture,Materiál prevedený na výrobu
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for manufacturing,Vyhradené na výrobu
DocType: QuickBooks Migrator,Undeposited Funds Account,Účet neevidovaných fondov
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Material Request No,Žiadosť o materiál č
DocType: Payment Reconciliation,Unreconciled Payment Details,Podrobnosti o nesúhlasných platbách
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},Hodnoty RFQ nie sú povolené pre {0} kvôli hodnoteniu karty {1}
DocType: Bank Guarantee,Validity in Days,Platnosť v dňoch
DocType: Price List,Applicable for Countries,Platí pre krajiny
DocType: Supplier,Individual,jednotlivec
DocType: Clinical Procedure Template,Clinical Procedure Template,Šablóna klinického postupu
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Net Asset value as on,Čistá hodnota aktív k
DocType: Employee Group Table,ERPNext User ID,ERPNext ID užívateľa
DocType: Sales Invoice,Redemption Account,Účet spätného odkúpenia
apps/erpnext/erpnext/config/buying.py,Tree of Item Groups.,Strom skupín položiek.
DocType: BOM,Show Items,Zobraziť položky
DocType: Journal Entry,Paid Loan,Platený úver
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Do you really want to scrap this asset?,Naozaj chcete tento majetok vyradiť?
DocType: Production Plan Sales Order,Sales Order Date,Dátum zákazky odberateľa
DocType: Workstation,Operating Costs,Prevádzkové náklady
DocType: Supplier Quotation Item,Lead Time in days,Čas dodania v dňoch
DocType: Loan,Repay from Salary,Splácanie zo mzdy
DocType: Discounted Invoice,Discounted Invoice,Zvýhodnená faktúra
DocType: Leave Block List Allow,Leave Block List Allow,Nechajte zoznam blokov povolený
DocType: Serial No,AMC Expiry Date,Dátum ukončenia AMC
DocType: Asset,Number of Depreciations Booked,Počet rezervovaných odpisov
DocType: Student Group Creation Tool,Student Group Creation Tool,Nástroj na vytváranie študentských skupín
,Purchase Order Items To Be Billed,"Položky objednávky, ktoré sa majú fakturovať"
DocType: Leave Period,Holiday List for Optional Leave,Zoznam dovoleniek pre voliteľné dovolenky
DocType: Purchase Invoice,Scan Barcode,Skenovať čiarový kód
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Update Cost Center Number,Aktualizovať číslo nákladového strediska
DocType: Purchase Invoice Item,Service Start Date,Dátum spustenia služby
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Furnitures and Fixtures,Vybavenie a svietidlá
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Criteria weights must add up to 100%,Váhy kritérií musia pridať až 100%
DocType: Authorization Rule,Average Discount,Priemerná zľava
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Discount must be less than 100,Zľava musí byť nižšia ako 100
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Accumulated Depreciation as on,Akumulované odpisy k
DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Variabilita skóre skóre dodávateľa
DocType: Cheque Print Template,Message to show,Správa na zobrazenie
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,No Students in,Žiadni študenti v
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Accounts,Dočasné účty
DocType: Invoice Discounting,Bank Charges,Bankové poplatky
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods Transferred,Prevedený tovar
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js,Primary Contact Details,Podrobnosti o primárnom kontakte
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Incoming call from {0},Prichádzajúci hovor od {0}
DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Ak nie je začiarknuté, zoznam sa musí pridať na každé oddelenie, kde sa má použiť."
DocType: Item Group,Show this slideshow at the top of the page,Zobraziť túto prezentáciu v hornej časti stránky
apps/erpnext/erpnext/support/doctype/issue/issue.py,{0} parameter is invalid,Parameter {0} je neplatný
apps/erpnext/erpnext/templates/generators/bom.html,No description given,Nie je uvedený žiadny popis
DocType: Accounting Period,Closed Documents,Zatvorené dokumenty
DocType: Project,Gross Margin,Hrubá marža
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation Account,Účet precenenia výmenného kurzu
DocType: Quotation,Quotation To,Citácia
DocType: Bank Statement Settings Item,Bank Statement Settings Item,Položka nastavenia výpisu z účtu
DocType: Naming Series,Setup Series,Nastavenie série
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js,Reload Linked Analysis,Obnoviť prepojenú analýzu
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Množstvo musí byť menšie alebo rovné {0}
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Out Qty,Out Množstvo
DocType: Payment Request,Outward,von
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Sales Orders in the above table,Vo vyššie uvedenej tabuľke zadajte zákazky odberateľa
DocType: Invoice Discounting,Bank Charges Account,Účet bankových poplatkov
DocType: Journal Entry,Get Outstanding Invoices,Získajte nevyrovnané faktúry
DocType: Opportunity,Opportunity From,Príležitosť z
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Target Details,Podrobnosti o cieli
DocType: Item,Customer Code,Zákaznický kód
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Please enter Item first,Zadajte položku ako prvú
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Website Listing,Zoznam webových stránok
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.
DocType: Item Reorder,Re-order Qty,Re-order Qty
DocType: Asset,Maintenance Required,Vyžaduje sa údržba
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Name,Názov dokumentu
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Lead Owner cannot be same as the Lead,Vedúci vlastník nemôže byť rovnaký ako vedúci
apps/erpnext/erpnext/config/accounting.py,"e.g. Bank, Cash, Credit Card","napr. Banka, Hotovosť, Kreditná karta"
DocType: Item,Serial Number Series,Sériové číslo
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Postal Expenses,Poštové náklady
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Management,management
apps/erpnext/erpnext/config/retail.py,To view logs of Loyalty Points assigned to a Customer.,Zobrazenie denníkov vernostných bodov pridelených zákazníkovi.
DocType: Item,If subcontracted to a vendor,Ak je to subdodávateľom dodávateľa
apps/erpnext/erpnext/templates/pages/help.html,Visit the forums,Navštívte fóra
DocType: C-Form,C-Form,C-Form
DocType: Asset Maintenance,Maintenance Team,Tím údržby
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Half day Leave on {1},{0} o pol dňa Dovolenka o {1}
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: Patient,Occupational Hazards and Environmental Factors,Nebezpečenstvá pri práci a environmentálne faktory
DocType: Volunteer,Volunteer,dobrovoľník
DocType: Lab Test,Custom Result,Vlastný výsledok
DocType: Issue,Opening Date,Dátum otvorenia
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ú pre tú istú položku
DocType: Delivery Note,Delivery To,Doručiť do
DocType: Communication Medium,Timeslots,Časové úseky
DocType: Bank Statement Transaction Settings Item,Bank Data,Bankové údaje
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js,Scheduled Upto,Naplánované Upto
apps/erpnext/erpnext/config/crm.py,Track Leads by Lead Source.,Track Leads podľa Lead Source.
DocType: Clinical Procedure,Nursing User,Ošetrovateľský užívateľ
DocType: Support Settings,Response Key List,Zoznam kľúčov odpovedí
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Based On,Starnutie na základe
apps/erpnext/erpnext/stock/doctype/item/item.js,Balance,zostatok
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,"Sklad, kde uchovávate zásoby odmietnutých položiek"
apps/erpnext/erpnext/public/js/setup_wizard.js,Retail,Maloobchodné
DocType: Call Log,Missed,vynechal
,Maintenance Schedules,Plány údržby
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cannot convert Cost Center to ledger as it has child nodes,"Nie je možné previesť nákladové stredisko do hlavnej knihy, pretože má podradené uzly"
apps/erpnext/erpnext/controllers/item_variant.py,Please specify at least one attribute in the Attributes table,Zadajte aspoň jeden atribút v tabuľke Atribúty
DocType: Company,Create Chart Of Accounts Based On,Vytvoriť graf účtov založený na
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Predajnú faktúru {0} je potrebné zrušiť pred zrušením tejto objednávky odberateľa
DocType: Item,Default Purchase Unit of Measure,Predvolená jednotka miery nákupu
DocType: Location,Location Details,Podrobnosti o polohe
DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Základná sadzba (podľa inventára UOM)
DocType: Travel Request Costing,Travel Request Costing,Kalkulácia požiadaviek na cestovanie
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Sales Invoice,Vytvoriť predajnú faktúru
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py,From Time cannot be greater than To Time.,Od Času nemôže byť väčší ako Čas.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js,To Date cannot be less than From Date,Dátum nemôže byť menší ako Od dátumu
apps/erpnext/erpnext/config/crm.py,Manage Territory Tree.,Spravovať stromové územie.
DocType: GL Entry,Voucher Type,Typ poukážky
,Serial No Service Contract Expiry,Sériové vypršanie platnosti servisnej zmluvy
DocType: Certification Application,Certified,certifikované
DocType: Purchase Invoice Item,Manufacture,Výroba
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items produced,{0} vytvorených položiek
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Request for {0},Žiadosť o platbu pre {0}
apps/erpnext/erpnext/accounts/report/inactive_sales_items/inactive_sales_items.js,Days Since Last Order,Dni od poslednej objednávky
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please set default Cash or Bank account in Mode of Payment {0},Nastavte predvolený účet v hotovosti alebo banke v režime platby {0}
DocType: Student Group,Instructors,inštruktori
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Present,Mark Present
DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Pre pohodlie zákazníkov môžu byť tieto kódy použité v tlačových formátoch, ako sú faktúry a dodacie listy"
DocType: Amazon MWS Settings,Enable Amazon,Povoliť službu Amazon
DocType: Loan,Total Interest Payable,Celkové úroky
DocType: Topic,Topic Content,Obsah témy
DocType: Bank Account,Integration ID,ID integrácie
DocType: Sales Invoice,Company Address Name,Názov adresy spoločnosti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods In Transit,Tovar v tranzite
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,You can only redeem max {0} points in this order.,V tejto objednávke môžete použiť maximálne {0} bodov.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please set account in Warehouse {0},Nastavte účet v sklade {0}
DocType: Quality Action,Resolution,rezolúcia
DocType: Sales Invoice,Loyalty Points Redemption,Vykúpenie vernostných bodov
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Total Taxable Value,Celková zdaniteľná hodnota
DocType: Patient Appointment,Scheduled,Naplánovaný
DocType: Sales Partner,Partner Type,Typ partnera
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of services,Dovoz služieb
DocType: Employee Education,School/University,School / University
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}: UOM Conversion Factor is mandatory,Riadok {0}: Konverzný faktor UOM je povinný
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Reference No.,Referenčné číslo
DocType: Work Order,Additional Operating Cost,Dodatočné prevádzkové náklady
DocType: Loyalty Program Collection,Collection Factor (=1 LP),Faktor zberu (= 1 LP)
DocType: Serial No,Delivery Document Type,Typ dodacieho dokladu
DocType: Products Settings,Attributes,atribúty
DocType: Bank Guarantee,Bank Guarantee,Banková záruka
DocType: Territory,Territory Name,Názov územia
DocType: Item Price,Minimum Qty ,Minimálne množstvo
DocType: Supplier Scorecard,Per Week,Za týždeň
DocType: Supplier Scorecard,Warn for new Request for Quotations,Upozorniť na novú žiadosť o cenové ponuky
DocType: Account,Tax,daň
DocType: Delivery Stop,Visited,navštívil
DocType: Loyalty Program,Auto Opt In (For all customers),Automatické zapnutie (pre všetkých zákazníkov)
DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,"Sadzba, za ktorú sa Zákaznícka mena prevedie na základnú menu zákazníka"
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 majiteľ"
DocType: Restaurant,Restaurant,reštaurácie
DocType: Delivery Stop,Address Name,Meno adresy
DocType: Employee Promotion,Employee Promotion,Propagácia zamestnancov
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments selected for Journal Entry,Pre zápis do denníka nie sú vybrané žiadne splátky
DocType: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Nastaviť hodnotu faktúry pre B2C. B2CL a B2CS vypočítané na základe tejto fakturačnej hodnoty.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',"Nie je možné odpočítať, keď je kategória pre „Ocenenie“ alebo „Vaulácia a Spolu“"
DocType: Quality Goal,Revised On,Prepracované dňa
apps/erpnext/erpnext/healthcare/utils.py,The item referenced by {0} - {1} is already invoiced,"Položka, na ktorú odkazuje {0} - {1}, je už fakturovaná"
DocType: Driver,Suspended,suspendovaný
DocType: Asset Category Account,Accumulated Depreciation Account,Účet kumulovaných odpisov
DocType: Journal Entry Account,Credit in Company Currency,Úver v mene spoločnosti
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Entertainment & Leisure,Zábava a voľný čas
DocType: Email Digest,New Sales Invoice,Nová predajná faktúra
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Net Profit,Čistý zisk
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,Another Sales Person {0} exists with the same Employee id,Iná predajná osoba {0} existuje s rovnakým ID zamestnanca
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Closing (Dr),Zatvorenie (Dr)
DocType: Loyalty Point Entry,Loyalty Program Tier,Vernostný program Úroveň
DocType: Purchase Invoice,Total Taxes and Charges,Celkové dane a poplatky
DocType: Amazon MWS Settings,JP,JP
DocType: Work Order Operation,Operation Description,Popis činnosti
DocType: Bank Statement Transaction Entry,Bank Transaction Entries,Záznamy o bankových transakciách
DocType: HR Settings,Leave Approval Notification Template,Ponechajte šablónu oznámenia o schválení
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Typ dokumentu
DocType: Email Digest,New Purchase Invoice,Nová nákupná faktúra
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Requested Qty: Quantity requested for purchase, but not ordered.","Požadované množstvo: Množstvo požadované na nákup, ale nie je objednané."
DocType: Purchase Invoice,Supplier Name,meno dodavateľa
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Kliknite na položku Generovať plán, ak chcete pre položku {0} pridať položku Nie."
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Delivered Items,Náklady na dodané položky
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Consumed,spotrebovanej
DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Právny subjekt / dcérska spoločnosť so samostatnou účtovnou osnovou patriacou organizácii.
DocType: BOM,Show In Website,Zobraziť na webových stránkach
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.","Pravidlá tvorby cien sa potom filtrujú na základe Zákazníka, Skupiny zákazníkov, Územia, Dodávateľa, Typ dodávateľa, Kampaň, Predajný partner atď."
DocType: Payment Request,Payment Request Type,Typ žiadosti o platbu
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field To Shareholder cannot be blank,Pole Akcionár nemôže byť prázdne
DocType: QuickBooks Migrator,QuickBooks Migrator,QuickBooks Migrator
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,POS Profile is required to use Point-of-Sale,Profil POS je povinný používať Point-of-Sale
DocType: Purchase Order,Purchase Order Pricing Rule,Pravidlo ceny za objednávku
DocType: Expense Claim,Expenses,výdavky
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.js,Bank accounts added,Pridali sa bankové účty
DocType: Employee,Cheque,check
DocType: Purchase Invoice,Currency and Price List,Mena a cenník
DocType: Shopify Settings,Shop URL,Adresa URL obchodu
DocType: Asset Movement,Source Location,Zdroj Umiestnenie
apps/erpnext/erpnext/accounts/page/pos/pos.js,Enter value must be positive,Zadaná hodnota musí byť kladná
DocType: Accounts Settings,Allow Cost Center In Entry of Balance Sheet Account,Povolenie nákladového strediska V účte súvahy
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js,Attendance,prezencia
DocType: Training Event,Internet,internet
DocType: Monthly Distribution,Monthly Distribution Percentages,Mesačné percento distribúcie
DocType: Delivery Settings,Dispatch Notification Template,Šablóna oznámenia o odoslaní
apps/erpnext/erpnext/templates/print_formats/includes/total.html,Total (Without Tax),Spolu (bez dane)
DocType: Cash Flow Mapping,Cash Flow Mapping,Mapovanie toku hotovosti
DocType: Patient Encounter,HLC-ENC-.YYYY.-,HLC-ENC-.YYYY.-
DocType: Cash Flow Mapper,Section Leader,Vedúci sekcie
,Budget Variance Report,Správa o rozdieloch v rozpočte
DocType: Asset,Gross Purchase Amount,Hrubá suma nákupu
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date is mandatory,Polovičný deň je povinný
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: Loan,Applicant Type,Typ žiadateľa
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 2,Na adresu 2
DocType: Purchase Receipt,Range,rozsah
DocType: Budget,BUDGET,BUDGET
DocType: Journal Entry,Depreciation Entry,Odpisový zápis
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Cenníková sadzba (mena spoločnosti)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Not Paid and Not Delivered,Neplatené a nedoručené
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Sales Invoice {0} created,Bola vytvorená predajná faktúra {0}
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: Quality Review Table,Objective,objektívny
DocType: Inpatient Record,Admission Scheduled,Plánované prijatie
DocType: Purchase Order Item,To be delivered to customer,Dodať zákazníkovi
DocType: Attendance Request,On Duty,V službe
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Variable,premenlivý
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: Options,Option,voľba
DocType: Healthcare Settings,Out Patient SMS Alerts,Upozornenia pacienta SMS
apps/erpnext/erpnext/setup/doctype/company/company.py,Sales Account,Predajný účet
DocType: Weather,Weather Parameter,Parameter počasia
DocType: Leave Control Panel,Allocate,prideliť
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Detail plánu údržby
DocType: BOM Update Tool,BOM Update Tool,Nástroj na aktualizáciu kusovníka
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Notice Period,Obdobie oznámenia
,Lead Owner Efficiency,Efektívnosť hlavného vlastníka
DocType: SMS Center,Total Characters,Celkový počet znakov
DocType: Patient,Alcohol Past Use,Alkohol minulé použitie
DocType: Patient,Divorced,Rozvedeny
DocType: Sales Invoice,Allocate Advances Automatically (FIFO),Automatické prideľovanie záloh (FIFO)
DocType: Leave Type,Is Compensatory,Je kompenzačné
,Employees working on a holiday,Zamestnanci pracujúci na dovolenke
DocType: Healthcare Practitioner,Mobile,Mobilné
apps/erpnext/erpnext/utilities/activation.py,"Timesheets help keep track of time, cost and billing for activites done by your team","Časové rozvrhy pomáhajú sledovať čas, náklady a fakturáciu za aktivity vykonané vaším tímom"
DocType: Delivery Stop,Order Information,informacie o objednavke
apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,medzisúčet
DocType: Invoice Discounting,Invoice Discounting,Diskontovanie faktúr
apps/erpnext/erpnext/regional/italy/utils.py,Nos,nos
DocType: Stock Settings,Freeze Stock Entries,Zmrazenie skladových záznamov
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Item {0} not found,Položka {0} sa nenašla
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,You have entered duplicate items. Please rectify and try again.,Zadali ste duplicitné položky. Opravte to a skúste to znova.
DocType: Purchase Invoice Item,Rate,rýchlosť
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.py,Saving {0},Ukladanie {0}
DocType: SMS Center,Total Message(s),Celkový počet správ
DocType: Purchase Invoice,Accounting Dimensions,Účtovné rozmery
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Account,Skupina podľa účtu
DocType: Quotation,In Words will be visible once you save the Quotation.,V programe Words budú viditeľné po uložení ponuky.
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js,Quantity to Produce,Množstvo na výrobu
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 fakturovaná suma pre položku {1}."
DocType: Work Order Operation,Actual Start Time,Skutočný čas začiatku
DocType: Antibiotic,Laboratory User,Užívateľ laboratória
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Online Auctions,Online aukcie
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Priority {0} has been repeated.,Priorita {0} bola opakovaná.
DocType: Fee Schedule,Fee Creation Status,Stav vytvorenia poplatku
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Softwares,softvéry
apps/erpnext/erpnext/config/help.py,Sales Order to Payment,Zákazka odberateľa na platbu
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,This is based on transactions against this Healthcare Practitioner.,To je založené na transakciách s týmto lekárom.
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Assigning Structures...,Priradenie štruktúr ...
apps/erpnext/erpnext/config/manufacturing.py,Details of the operations carried out.,Podrobnosti o vykonaných operáciách.
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ískané z výpisu"
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Operation Time must be greater than 0 for Operation {0},Prevádzkový čas musí byť väčší ako 0 pre prevádzku {0}
apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Požiadavka musí mať aspoň jednu správnu možnosť
DocType: Shareholder,Folio no.,Folio č.
DocType: Inpatient Record,A Negative,Negatív
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} is mandatory for Item {1},{0} je povinné pre položku {1}
,Production Analytics,Výroba Analytics
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Set Supplier for item {1},Riadok # {0}: Nastaviť dodávateľa pre položku {1}
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter_dashboard.py,Records,záznamy
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Automatic Reconciliation,Automatické vyrovnanie
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Case No(s) already in use. Try from Case No {0},"Prípad (y), ktoré sa už používajú. Skúste z prípadu č. {0}"
DocType: Chapter Member,Website URL,Adresa URL webovej stránky
apps/erpnext/erpnext/accounts/doctype/account/account.py,Report Type is mandatory,Typ prehľadu je povinný
DocType: Vehicle,Policy No,Politika č
apps/erpnext/erpnext/hr/report/daily_work_summary_replies/daily_work_summary_replies.py,Replies,odpovede
DocType: Supplier Scorecard Scoring Variable,Variable Name,Názov premennej
DocType: Rename Tool,Utilities,utilities
DocType: Job Card,Total Completed Qty,Celkom dokončené množstvo
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials to Manufacture,Žiadne položky s kusovníkom k výrobe
DocType: Purchase Order Item,Blanket Order Rate,Deka objednávky
DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Sledujte samostatné výnosy a náklady pre vertikálne produkty alebo divízie.
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid SSL certificate on attachment {0},Upozornenie: Neplatný certifikát SSL o prílohe {0}
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp Count,Opp Count
apps/erpnext/erpnext/education/doctype/instructor/instructor.js,As Examiner,Ako skúšajúci
DocType: Company,Default Expense Claim Payable Account,Platobný účet s predvoleným výdavkom
DocType: Additional Salary,HR-ADS-.YY.-.MM.-,HR-ADS-.YY .-. MM.-
apps/erpnext/erpnext/templates/pages/search_help.py,Docs Search,Vyhľadávanie dokumentov
apps/erpnext/erpnext/hr/doctype/payroll_period/payroll_period.py,End Date can not be less than Start Date,Dátum ukončenia nemôže byť menší ako dátum začiatku
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/config/support.py,Single unit of an Item.,Jednotka jednotky.
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Quotations,citácie
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Could not generate Secret,Nepodarilo sa vygenerovať Secret
DocType: Purchase Taxes and Charges,Valuation and Total,Oceňovanie a súčet
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Member Activity,Činnosť člena
DocType: Upload Attendance,Import Attendance,Importovať účasť
DocType: POS Profile,Account for Change Amount,Účet pre zmenu čiastky
,Item Price Stock,Položka Cena Sklad
DocType: Asset,ACC-ASS-.YYYY.-,ACC-ASS-.YYYY.-
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,"Request for Quotation is disabled to access from portal, for more check portal settings.","Žiadosť o cenovú ponuku je zakázaná pre prístup z portálu, pre ďalšie nastavenia portálu."
DocType: Bank Statement Settings Item,Mapped Header,Mapované hlavičky
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,"Item Code, warehouse, quantity are required on row","Položka Kód, sklad, množstvo je potrebné na riadku"
DocType: Payment Order Reference,Bank Account Details,Podrobnosti o bankovom účte
DocType: Homepage,Homepage Slideshow,Domovská stránka Prezentácia
apps/erpnext/erpnext/templates/includes/product_page.js,Cannot find a matching Item. Please select some other value for {0}.,Nepodarilo sa nájsť zodpovedajúcu položku. Vyberte inú hodnotu pre {0}.
DocType: Travel Request,"Partially Sponsored, Require Partial Funding","Čiastočne Sponzorované, Vyžadovať čiastočné financovanie"
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Payment of {0} from {1} to {2},Platba {0} od {1} do {2}
,Serial No Status,Stav sériového čísla
DocType: Donor,Donor,darcu
DocType: BOM,Item UOM,Položka UOM
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Riadok {0}: vyberte pracovnú stanicu proti operácii {1}
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py,{0} must be submitted,{0} musí byť odoslané
DocType: Project,Estimated Cost,Odhadované náklady
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot/Lead %,Quot / Lead%
DocType: Bank Account,Last Integration Date,Dátum poslednej integrácie
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Search for a payment,Vyhľadajte platbu
apps/erpnext/erpnext/config/non_profit.py,Member information.,Informácie o členoch.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Zadanie reverzného denníka
apps/erpnext/erpnext/utilities/user_progress.py,Set a sales goal you'd like to achieve for your company.,"Nastavte cieľ predaja, ktorý chcete dosiahnuť pre vašu spoločnosť."
DocType: Lab Test Template,Special,špeciálna
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Subcontract: Raw materials quantity to make subcotracted items.,"Vyhradené množstvo pre subkontrakty: Množstvo surovín, aby sa subcotracted položky."
DocType: Patient Encounter,In print,V tlači
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/accounts/party.py,Billing currency must be equal to either default company's currency or party account currency,Fakturačná mena sa musí rovnať predvolenej mene spoločnosti alebo mene účtu strany
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js,Please enter Employee Id of this sales person,Zadajte Id zamestnanca tejto osoby
DocType: Shift Type,Early Exit Consequence after,Dôsledok predčasného ukončenia po
apps/erpnext/erpnext/config/getting_started.py,Create Opening Sales and Purchase Invoices,Vytvorenie otváracích predajov a nákupných faktúr
DocType: Disease,Treatment Period,Obdobie liečby
apps/erpnext/erpnext/config/settings.py,Setting up Email,Nastavenie e-mailu
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Debit Note Amount,Suma debetnej sumy
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Sadzba, pri ktorej je mena cenníka prepočítaná na základnú menu zákazníka"
apps/erpnext/erpnext/hooks.py,Certification,osvedčenie
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Tu si môžete udržať výšku, váhu, alergie, zdravotné problémy atď"
DocType: Journal Entry,Print Heading,Vytlačiť nadpis
DocType: Grant Application,Withdrawn,uzavretý
apps/erpnext/erpnext/public/js/utils/party.js,Select company first,Najprv vyberte spoločnosť
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Application period cannot be across two allocation records,Obdobie aplikácie nemôže byť naprieč dvoma alokačnými záznamami
apps/erpnext/erpnext/templates/pages/order.html,Rate:,rýchlosť:
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ávky
DocType: Employee Skill Map,Employee Skills,Zamestnanecké zručnosti
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Name: ,Meno študenta:
DocType: SMS Log,Sent On,Odoslané dňa
DocType: Bank Statement Transaction Invoice Item,Sales Invoice,Faktúra
DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",Pre študentskú skupinu založenú na kurze bude kurz validovaný pre každého študenta zo zapísaných kurzov v zápise do programu.
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Intra-State Supplies,Vnútroštátne dodávky
DocType: Employee,Create User Permission,Vytvoriť oprávnenie používateľa
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Please save the report again to rebuild or update,"Znova ho uložte, aby ste ho znova vytvorili alebo aktualizovali"
DocType: C-Form Invoice Detail,Territory,územie
DocType: C-Form,Quarter,štvrťrok
DocType: Purchase Invoice,Grand Total (Company Currency),Celkový súčet (mena spoločnosti)
DocType: Prescription Dosage,Prescription Dosage,Dávkovanie na predpis
DocType: Salary Slip,Hour Rate,Hodinová sadzba
DocType: Location,Latitude,zemepisná šírka
DocType: Expense Claim Detail,Expense Date,Dátum výdavkov
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show Payment Details,Zobraziť podrobnosti platby
DocType: Company,Default Payable Account,Predvolený účet
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to any Warehouse,Sériové číslo {0} nepatrí do žiadneho skladu
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Party,Skupina podľa strán
DocType: Volunteer,Evening,Večer
DocType: Campaign,SAL-CAM-.YYYY.-,SAL-CAM-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Exchange Gain/Loss,Výmena / strata
DocType: Payment Request,Make Sales Invoice,Urobiť predajnú faktúru
DocType: Opening Invoice Creation Tool,Create Missing Party,Vytvoriť chýbajúcu stranu
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For quantity {0} should not be grater than work order quantity {1},Pre množstvo {0} by nemalo byť strúhadlo väčšie ako množstvo objednávky {1}
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,{0}: {1} must be less than {2},{0}: {1} musí byť menšie ako {2}
DocType: Landed Cost Voucher,Additional Charges,Dodatočné poplatky
DocType: Assessment Result Tool,Assessment Result Tool,Nástroj na hodnotenie výsledkov
DocType: Journal Entry,Contra Entry,Contra Entry
DocType: Student Applicant,Application Status,Stav aplikácie
DocType: Journal Entry,Total Amount in Words,Celková suma v slovách
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment. ","Sledujte predajné kampane. Sledujte výsledky, ponuky, zákazky odberateľa atď. Z kampaní, aby ste zmerali návratnosť investícií."
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Missing Currency Exchange Rates for {0},Chýbajúce výmenné kurzy mien pre {0}
DocType: Pricing Rule Item Group,Pricing Rule Item Group,Skupina položiek cenového pravidla
DocType: Quality Inspection Reading,Reading 8,Čítanie 8
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,From Fiscal Year,Od fiškálneho roka
DocType: Tally Migration,Tally Creditors Account,Konto veriteľov
DocType: Student Report Generation Tool,Print Section,Tlač sekcie
apps/erpnext/erpnext/hr/doctype/department/department.js,This is a root department and cannot be edited.,Toto je koreňové oddelenie a nedá sa upraviť.
,Project Quantity,Množstvo projektu
apps/erpnext/erpnext/config/settings.py,Standard contract terms for Sales or Purchase.,Štandardné zmluvné podmienky predaja alebo nákupu.
DocType: Sales Invoice,Customer PO Details,Detaily zákazníka
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Patient not found,Pacient sa nenašiel
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Select a Default Priority.,Vyberte predvolenú prioritu.
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Remove item if charges is not applicable to that item,"Odstráňte položku, ak sa na túto položku nevzťahujú poplatky"
apps/erpnext/erpnext/selling/doctype/customer/customer.py,A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Skupina zákazníkov existuje s rovnakým menom, prosím, zmeňte meno zákazníka alebo premenujte skupinu zákazníkov"
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.","Štandardná šablóna dane, ktorú možno použiť na všetky obchodné transakcie. Táto šablóna môže obsahovať zoznam daňových hláv a tiež ďalšie náklady / príjmy hlavy ako &quot;doprava&quot;, &quot;poistenie&quot;, &quot;manipulácia&quot; atď. #### Poznámka Tu definovaná sadzba dane bude štandardná sadzba dane pre všetkých ** položky **. Ak sú ** položky **, ktoré majú rozdielne sadzby, musia byť pridané do ** Položka dane ** tabuľky ** Master ** Master. #### Popis stĺpcov 1. Typ výpočtu: - Toto môže byť na ** Čistý súčet ** (to je súčet základnej čiastky). - ** V predchádzajúcom riadku Spolu / Suma ** (pre kumulatívne dane alebo poplatky). Ak vyberiete túto možnosť, daň sa použije ako percento z predchádzajúceho riadku (v daňovej tabuľke) alebo celkovej sumy. - ** Skutočný ** (ako je uvedené). 2. Vedúci účtu: účtovná kniha, pod ktorou bude táto daň zaúčtovaná. 3. Nákladové stredisko: Ak je daň / poplatok príjmom (napr. Prepravou) alebo nákladom, musí byť zaúčtovaný proti nákladovému stredisku. 4. Popis: Opis dane (ktorá bude vytlačená na faktúrach / kottoch). 5. Sadzba: Sadzba dane. 6. Suma: Výška dane. 7. Spolu: Kumulatívny súčet k tomuto bodu. 8. Zadajte riadok: Ak sa na základe &quot;Predchádzajúca riadka Celkom&quot; môžete zvoliť číslo riadku, ktoré bude brané ako základ pre tento výpočet (predvolené je predchádzajúci riadok). 9. Je táto daň zahrnutá v základnej sadzbe ?: Ak to skontrolujete, znamená to, že táto daň nebude zobrazená pod tabuľkou položiek, ale bude zahrnutá do základnej sadzby v tabuľke hlavnej položky. To je užitočné tam, kde chcete, aby zákazníci dostali paušálnu cenu (vrátane všetkých daní)."
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: Customer Group,Parent Customer Group,Rodičovská skupina zákazníkov
DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,"Ceny nie sú uvedené, ak nie je nastavený Cenník"
apps/erpnext/erpnext/config/settings.py,ERPNext Settings,ERPNext Nastavenia
apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Časový výkaz pre výrobu.
DocType: Student Language,Student Language,Študentský jazyk
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Payment Schedule,Nastavte si časový harmonogram platieb
DocType: Travel Request,Name of Organizer,Meno organizátora
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Nastavte účty týkajúce sa odpisov v kategórii aktív {0} alebo spoločnosti {1}
apps/erpnext/erpnext/config/accounting.py,Setup cheque dimensions for printing,Skontrolujte rozmery kópie pre tlač
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."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Purchase Receipt {0} is not submitted,Potvrdenie o kúpe {0} nie je odoslané
DocType: Task,Total Expense Claim (via Expense Claim),Celkový nárok na výdavky (prostredníctvom nároku na výdavky)
DocType: Quality Goal,Quality Goal,Cieľ kvality
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,{0} bank transaction(s) created,{0} vytvorené bankové transakcie
DocType: Support Settings,Support Portal,Portál podpory
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} is on Leave on {1},Zamestnanec {0} je na dovolenke {1}
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}
DocType: Employee,Held On,Sa konalo v dňoch
DocType: Healthcare Practitioner,Practitioner Schedules,Plány praktických lekárov
DocType: Project Template Task,Begin On (Days),Začať dňa (dni)
DocType: Production Plan,"If enabled, then system will create the material even if the raw materials are available","Ak je táto možnosť povolená, systém vytvorí materiál aj v prípade, že sú k dispozícii suroviny"
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work Order has been {0},Pracovný príkaz bol {0}
DocType: Inpatient Record,Admission Schedule Date,Harmonogram prijímania Dátum
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Value Adjustment,Úprava hodnoty aktív
DocType: Exotel Settings,Account SID,SID účtu
DocType: Shift Type,Mark attendance based on 'Employee Checkin' for Employees assigned to this shift.,Označiť dochádzku na základe &#39;Zamestnanec Checkin&#39; pre Zamestnancov pridelených k tejto zmene.
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
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to Unregistered Persons,Dodávky pre neregistrované osoby
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,All Jobs,Všetky úlohy
DocType: Appointment Type,Appointment Type,Typ stretnutia
DocType: Manufacturing Settings,Allow Overtime,Povoliť nadčasy
DocType: Sales Invoice Item,Available Qty at Warehouse,K dispozícii v sklade
DocType: Sales Invoice Item,Sales Invoice Item,Položka predajnej faktúry
DocType: Additional Salary,HR,HR
DocType: Student Report Generation Tool,Assessment Terms,Podmienky hodnotenia
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: Leave Control Panel,Carry Forward,Presunúť dopredu
DocType: Dependent Task,Dependent Task,Závislá úloha
apps/erpnext/erpnext/support/doctype/issue/issue.py,Priority has been changed to {0}.,Priorita bola zmenená na {0}.
DocType: Allowed To Transact With,Allowed To Transact With,Povolené na transakciu s
apps/erpnext/erpnext/public/js/hub/marketplace.js,Become a Seller,Staňte sa predávajúcim
DocType: Bank Reconciliation,Bank Reconciliation,Bankové vyúčtovanie
apps/erpnext/erpnext/config/projects.py,Types of activities for Time Logs,Typy aktivít pre denníky času
DocType: POS Closing Voucher Invoices,POS Closing Voucher Invoices,Faktúry pre pokladničné poukážky POS
DocType: Inpatient Record,AB Negative,AB Negative
DocType: Company,Budget Detail,Detail rozpočtu
DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normálny referenčný rozsah pre dospelého je 16–20 dychov / minútu (RCP 2012)
DocType: Production Plan,Sales Orders,Zákazky odberateľa
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Create Journal Entry,Vytvoriť položku denníka
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Zabezpečené úvery
DocType: Share Transfer,To Shareholder,Akcionárovi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Maintenance Schedule,Plán údržby
DocType: Chapter,"chapters/chapter_name
leave blank automatically set after saving chapter.",Kapitoly / Chapter_name ponechajú prázdne automaticky nastavené po uložení kapitoly.
DocType: Shopping Cart Settings,Payment Success Url,Adresa URL úspešnosti platby
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Dodaná čiastka
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Min Amt can not be greater than Max Amt,Min Amt nemôže byť väčší ako Max Amt
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Salary Structure not found for employee {0} and date {1},Štruktúra mzdy nebola nájdená pre zamestnanca {0} a dátum {1}
DocType: Healthcare Settings,Invoice Appointments Automatically,Automaticky naplánované termíny faktúr
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js,Please fill in all the details to generate Assessment Result.,"Vyplňte prosím všetky údaje, aby ste vygenerovali Výsledok hodnotenia."
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Variance ({}),Odchýlka ({})
DocType: Healthcare Settings,Patient Name,Meno pacienta
apps/erpnext/erpnext/public/js/setup_wizard.js,Your Organization,Vaša organizácia
DocType: Contract,Fulfilment Details,Podrobnosti o plnení
DocType: Project,Total Billed Amount (via Sales Invoices),Celková fakturovaná suma (prostredníctvom predajných faktúr)
apps/erpnext/erpnext/utilities/user_progress.py,Kg,kilogram
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Appointment cancelled,Menovanie bolo zrušené
DocType: Healthcare Settings,Reminder Message,Pripomienka
DocType: Repayment Schedule,Balance Loan Amount,Suma zostatku úveru
apps/erpnext/erpnext/config/crm.py,Manage Sales Person Tree.,Spravovať strom predajných osôb.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,There are more holidays than working days this month.,V tomto mesiaci je viac dovoleniek ako pracovných dní.
DocType: Item,Default BOM,Predvolený kusovník
DocType: BOM,Operating Cost (Company Currency),Prevádzkové náklady (mena spoločnosti)
DocType: Item Price,Item Price,Položka Cena
DocType: Payment Entry,Party Name,Názov strany
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select a customer,Vyberte zákazníka
DocType: Program Enrollment Tool,New Program,Nový program
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,"Number of new Cost Center, it will be included in the cost center name as a prefix","Číslo nového nákladového strediska, bude zahrnuté do názvu nákladového strediska ako predpona"
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/selling/doctype/quotation/quotation.py,Valid till date cannot be before transaction date,Platnosť do dátumu nemôže byť pred dátumom transakcie
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Cannot deactivate or cancel BOM as it is linked with other BOMs,"Nie je možné deaktivovať alebo zrušiť kusovník, pretože je prepojený s inými kusovníkmi"
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Place Of Supply (State/UT),Miesto dodania (štát / UT)
DocType: Job Opening,Job Title,Názov práce
DocType: Fee Component,Fee Component,Poplatok Komponent
apps/erpnext/erpnext/config/accounting.py,C-Form records,Záznamy C-formulára
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á. Ďalšie podrobnosti nájdete v účte GoCardless
DocType: Crop Cycle,Less than a year,Menej ako rok
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0} must be submitted,Pracovný príkaz {0} musí byť odoslaný
apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js,Filter Total Zero Qty,Filter Total Zero Qty
DocType: Job Applicant,Applicant for a Job,Žiadateľ o zamestnanie
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,No records found in the Invoice table,V tabuľke Faktúry neboli nájdené žiadne záznamy
DocType: Chart of Accounts Importer,Chart of Accounts Importer,Dovozca účtovníctva
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item or Warehouse for row {0} does not match Material Request,Položka alebo sklad pre riadok {0} sa nezhoduje s požiadavkou na materiál
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,IGST Amount,Množstvo IGST
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,Delivery Notes {0} updated,Poznámky o doručení {0} boli aktualizované
DocType: Travel Itinerary,Lodging Required,Požadované ubytovanie
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Total Revenue,Celkové príjmy
DocType: Student Group Student,Student Group Student,Študentská študentská skupina
DocType: Customer,Buyer of Goods and Services.,Kupujúci tovarov a služieb.
DocType: Vehicle,Vehicle,vozidlo
apps/erpnext/erpnext/utilities/transaction_base.py,Quantity ({0}) cannot be a fraction in row {1},Množstvo ({0}) nemôže byť zlomok v riadku {1}
DocType: Retention Bonus,Bonus Amount,Výška bonusu
DocType: Stock Reconciliation Item,Amount Difference,Rozdiel množstva
DocType: Asset Maintenance,Maintenance Tasks,Úlohy údržby
DocType: HR Settings,Stop Birthday Reminders,Zastavte pripomenutie narodenín
DocType: Payment Gateway Account,Payment Account,Platobný účet
DocType: Stock Settings,Stock Frozen Upto,Skladom Mrazené Upto
DocType: Item,Default Material Request Type,Predvolený typ požiadavky na materiál
DocType: Clinical Procedure Item,Clinical Procedure Item,Položka klinického postupu
DocType: Finance Book,Finance Book,Finančná kniha
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py,From Datetime,Od spoločnosti Datetime
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/stock/report/item_variant_details/item_variant_details.py,Open Orders,Otvorené objednávky
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.js,Admit,Pripustiť
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py,Total {0} ({1}),Celkom {0} ({1})
DocType: Certified Consultant,GitHub ID,ID GitHub
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Address 1,Z adresy 1
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Total hours: {0},Celkový počet hodín: {0}
DocType: Employee Transfer,Transfer Date,Dátum prenosu
DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,"Ak je zdrojom dotazu kampaň, zadajte názov kampane"
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,"Táto položka je šablóna a nemôže byť použitá v transakciách. Atribúty položiek sa skopírujú do variantov, pokiaľ nie je nastavená možnosť No No Copy"
DocType: Cheque Print Template,Regular,pravidelný
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: Production Plan,Not Started,Nezačal
DocType: Disease,Treatment Task,Úloha spracovania
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,Row {0}: user has not applied rule <b>{1}</b> on the item <b>{2}</b>,Riadok {0}: používateľ neuplatnil pravidlo <b>{1}</b> na položku <b>{2}</b>
DocType: Landed Cost Voucher,Landed Cost Help,Pomoc s nákladmi na pristátie
DocType: Supplier Scorecard,Scoring Criteria,Kritériá hodnotenia
DocType: Bank Statement Transaction Entry,Matching Invoices,Zodpovedajúce faktúry
DocType: Donor,Donor Name,Meno darcu
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Select Property,Vyberte Vlastnosť
DocType: Homepage,Homepage Section,Domáca sekcia
DocType: Assessment Result,Grade,akosť
DocType: Production Plan Material Request,Production Plan Material Request,Výrobný plán Materiálová požiadavka
DocType: Request for Quotation Supplier,Send Email,Poslať email
DocType: Item,Retain Sample,Zachovať vzorku
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0} (Payment Table): Amount must be negative,Riadok # {0} (Tabuľka platieb): Hodnota musí byť záporná
,Warehouse wise Item Balance Age and Value,Warehouse múdry Položka Balance Age and Value
DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Celková hmotnosť balenia. Zvyčajne čistá hmotnosť + hmotnosť obalového materiálu. (pre tlač)
DocType: Plant Analysis,Laboratory Testing Datetime,Laboratórne testovanie Datetime
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
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Student Group Strength,Sila študentskej skupiny
DocType: Bank Statement Transaction Entry,Bank Statement Transaction Entry,Transakčný záznam výpisu z účtu
DocType: Purchase Order,Get Items from Open Material Requests,Získať položky z otvorených materiálov žiadosti
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é položky a iné významné transakcie sa sledujú oproti ** fiškálnemu roku **.
DocType: Procedure Prescription,Procedure Name,Názov procedúry
apps/erpnext/erpnext/public/js/event.js,Add Sales Partners,Pridať obchodných partnerov
apps/erpnext/erpnext/public/js/pos/pos.html,Qty Total,Celkový počet
DocType: Payment Entry Reference,Outstanding,vynikajúci
DocType: Employee Tax Exemption Proof Submission,Employee Tax Exemption Proof Submission,Predloženie dôkazu o oslobodení zamestnancov od dane
DocType: Contract Fulfilment Checklist,Requirement,požiadavka
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,No active or default Salary Structure found for employee {0} for the given dates,Pre zamestnanca {0} pre dané dátumy nebola nájdená žiadna aktívna alebo predvolená štruktúra miezd
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity should be greater than 0,Množstvo by malo byť väčšie ako 0
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Row #{0}: Payment document is required to complete the transaction,Riadok # {0}: Platobný doklad je potrebný na dokončenie transakcie
DocType: Purchase Order Item,Supplier Quotation Item,Položka ponuky dodávateľa
DocType: Appraisal,Appraisal Template,Šablóna hodnotenia
DocType: Item,Hub Category to Publish,Kategória kategórie na publikovanie
DocType: Staffing Plan Detail,Current Openings,Aktuálne otvorenia
apps/erpnext/erpnext/config/crm.py,Customer Database.,Databáza zákazníkov.
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,As On Date,Dátum zapnutia
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Delivery Note {0} is not submitted,Dodacia poznámka {0} nie je odoslaná
DocType: Appraisal Template Goal,Appraisal Template Goal,Cieľ šablóny hodnotenia
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.js,Unlink external integrations,Odpojenie externých integrácií
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Closing (Cr),Zatváranie (Cr)
DocType: Restaurant Reservation,Restaurant Reservation,Reštaurácia Rezervácia
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Last Order Amount,Suma poslednej objednávky
apps/erpnext/erpnext/config/desktop.py,Learn,učiť sa
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Viacnásobný predvolený spôsob platby nie je povolený
DocType: Crop Cycle,This will be day 1 of the crop cycle,Toto bude deň 1 cyklu plodín
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} is not associated with {2} {3},{0} {1} nie je spojené s {2} {3}
apps/erpnext/erpnext/controllers/stock_controller.py,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,"Účet výdavkov alebo rozdielov je povinný pre položku {0}, pretože ovplyvňuje celkovú hodnotu akcií"
DocType: Purchase Invoice,Price List Exchange Rate,Cenník Výmenný kurz
DocType: Purchase Invoice Item,Amount (Company Currency),Suma (mena spoločnosti)
DocType: Driver,Driver,vodič
DocType: GST Account,CGST Account,Účet CGST
DocType: Loan,Disbursement Date,Dátum vyplatenia
apps/erpnext/erpnext/templates/pages/projects.html,New task,Nová úloha
DocType: Customer Feedback Table,Customer Feedback Table,Tabuľka spätnej väzby od zákazníkov
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Course {2},{0} - {1} nie je prihlásený do kurzu {2}
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Difference Amount,Rozdiel Výška
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Cheques and Deposits incorrectly cleared,Šeky a vklady boli nesprávne zúčtované
DocType: Journal Entry,Cash Entry,Vklad hotovosti
DocType: GST Settings,GST Settings,Nastavenia GST
,Item-wise Sales Register,Položka-múdry predajný register
apps/erpnext/erpnext/stock/doctype/item/item.py,Item has variants.,Položka má varianty.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Difference Amount must be zero,Rozdiel Výška musí byť nulová
DocType: Fee Schedule,Institution,inštitúcie
DocType: Patient,Tobacco Current Use,Súčasné používanie tabaku
apps/erpnext/erpnext/utilities/user_progress.py,Setup your ,Nastavte svoj
DocType: Payment Entry Deduction,Payment Entry Deduction,Odpočet vstupu platby
apps/erpnext/erpnext/stock/doctype/batch/batch.py,"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Riadok # {0}: Dávka {1} má iba {2} počet. Vyberte inú dávku, ktorá má k dispozícii {3} qty, alebo rozdeľte riadok do viacerých riadkov, aby ste doručili / vydali z viacerých dávok"
DocType: Patient Appointment,Procedure,procedúra
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Missed,Zmeňte hovor
,Total Stock Summary,Celkový súhrn zásob
DocType: Purchase Invoice,Additional Discount,Dodatočná zľava
DocType: Healthcare Settings,Patient Name By,Meno pacienta By
DocType: Healthcare Service Unit Type,Rate / UOM,Sadzba / UOM
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Nastavte Pomenovaciu sériu pre {0} cez Setup&gt; Settings&gt; Naming Series
DocType: Job Offer,Job Offer Terms,Podmienky ponuky práce
DocType: GL Entry,Debit Amount in Account Currency,Suma debetu v mene účtu
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,{0} must appear only once,{0} sa musí zobraziť iba raz
apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Účet výdavkov / rozdielov ({0}) musí byť účet „Zisk alebo strata“
DocType: Communication Medium,Communication Medium,Komunikačné médium
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}: Suma nemôže byť väčšia ako nárok na úhradu proti nároku {1}. Čakajúca suma je {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Earnest Money,Vážne peniaze
apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Všetky hodnotiace karty dodávateľa.
DocType: Sales Invoice,Terms and Conditions Details,Podrobnosti Podrobnosti
DocType: Exchange Rate Revaluation,Get Entries,Získať položky
DocType: Vehicle Service,Service Item,Položka služby
DocType: Sales Invoice,Customer's Purchase Order,Objednávka zákazníka
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in formula or condition: {0},Chyba syntaxe vo vzorci alebo podmienke: {0}
DocType: Agriculture Analysis Criteria,Agriculture User,Užívateľ poľnohospodárstva
apps/erpnext/erpnext/controllers/buying_controller.py,Please enter Reqd by Date,Zadajte Reqd podľa dátumu
DocType: Company,Total Monthly Sales,Celkový mesačný predaj
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Percento mesačnej distribúcie
DocType: Stock Reconciliation,Reconciliation JSON,Zosúladenie JSON
apps/erpnext/erpnext/stock/get_item_details.py,No Item with Barcode {0},Žiadna položka s čiarovým kódom {0}
DocType: Asset,Scrapped,zošrotovaný
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Delivery Trip,Prepravná cesta
DocType: Student Admission Program,Application Fee,Poplatok za žiadosť
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Sales orders are not available for production,Zákazky odberateľa nie sú k dispozícii na výrobu
DocType: Website Attribute,Attribute,atribút
DocType: Rename Tool,Rename Log,Premenovať denník
apps/erpnext/erpnext/controllers/trends.py,'Based On' and 'Group By' can not be same,„Založené“ a „Skupina podľa“ nemôžu byť rovnaké
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.js,Show Ageing Warehouse-wise,Zobraziť Aging Warehouse-múdry
DocType: Sales Invoice,Write Off Outstanding Amount,Odpísaná vynikajúca čiastka
DocType: Payroll Entry,Employee Details,Podrobnosti o zamestnancovi
DocType: Pricing Rule,Discount Amount,Výška zľavy
DocType: Healthcare Service Unit Type,Item Details,Podrobnosti o položke
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.py,Duplicate Tax Declaration of {0} for period {1},Duplicitné daňové priznanie {0} za obdobie {1}
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js,From Delivery Note,Z dodacieho listu
DocType: Holiday,Holiday,Dovolenka
DocType: Company,Default Buying Terms,Predvolené podmienky nákupu
DocType: Cheque Print Template,Line spacing for amount in words,Riadkovanie pre množstvo slovami
DocType: Item Group,Item Group Defaults,Predvolené nastavenia skupiny položiek
DocType: Salary Component,Abbr,skr
apps/erpnext/erpnext/config/support.py,Warranty Claim against Serial No.,Reklamácia záruky proti sériovému číslu
apps/erpnext/erpnext/config/desktop.py,Quality,kvalita
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,{0} is not a stock Item,{0} nie je skladom Položka
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Dodané náklady na suroviny
DocType: Employee,Permanent Address,Trvalá adresa
DocType: Asset,Booked Fixed Asset,Rezervovaný investičný majetok
apps/erpnext/erpnext/templates/pages/help.html,Your tickets,Vaše vstupenky
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Create Supplier Quotation,Vytvorenie ponuky dodávateľa
DocType: Item,Inspection Required before Purchase,Kontrola Pred nákupom
DocType: Payment Entry,Payment Ordered,Platba bola objednaná
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 existuje problém s konfiguráciou servera GoCardless. Nebojte sa, v prípade zlyhania bude suma vrátená na váš účet."
apps/erpnext/erpnext/accounts/page/pos/pos.js,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Režim platby nie je nakonfigurovaný. Skontrolujte, či bol účet nastavený na spôsob platby alebo na profil POS."
DocType: Email Digest,Purchase Orders Items Overdue,Položky splatnosti objednávky
DocType: BOM,Inspection Required,Vyžaduje sa inšpekcia
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled so the action cannot be completed,"{0} {1} sa zruší, takže akciu nemožno dokončiť"
DocType: Project Template Task,Project Template Task,Úloha šablóny projektu
apps/erpnext/erpnext/projects/doctype/task/task.py,Circular Reference Error,Kruhová referenčná chyba
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: účet typu Zisk a strata {2} nie je povolený v položke Otvorenie vstupu
DocType: Website Item Group,Cross Listing of Item in multiple groups,Cross Listing of Item vo viacerých skupinách
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction cannot be converted to ledger,Účet s existujúcou transakciou nie je možné previesť na účtovnú knihu
DocType: POS Profile,Display Items In Stock,Zobraziť položky na sklade
DocType: Issue,Service Level,Úroveň služieb
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Other outward supplies(Nil rated,Exempted)","Iné dodávky smerom von (Nil, Exempted)"
,TDS Payable Monthly,Mesačná splatnosť TDS
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select Posting Date before selecting Party,Pred výberom strany vyberte Dátum zaúčtovania
,GST Purchase Register,GST Nákupný register
DocType: Accounts Settings,Automatically Add Taxes and Charges from Item Tax Template,Automaticky pridávať dane a poplatky zo šablóny položky dane
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Stock Options,Možnosti skladu
DocType: Healthcare Schedule Time Slot,Healthcare Schedule Time Slot,Časový harmonogram časového harmonogramu zdravotnej starostlivosti
apps/erpnext/erpnext/public/js/pos/pos.html,Tap items to add them here,"Ak ich chcete pridať, kliknite na položky"
DocType: Payment Schedule,Invoice Portion,Časť faktúry
apps/erpnext/erpnext/config/accounting.py,Tax Category for overriding tax rates.,Kategória dane pre vyššie sadzby dane.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Retained Earnings,Nerozdelený zisk
DocType: Grant Application,Requested Amount,Požadovaná čiastka
DocType: Salary Detail,Additional Amount,Dodatočná čiastka
DocType: Quiz,Quiz Configuration,Konfigurácia kvízu
DocType: Mode of Payment,General,všeobecný
DocType: Email Digest,Annual Expenses,Ročné výdavky
DocType: Global Defaults,Disable In Words,Zakázať v slovách
DocType: Customer,CUST-.YYYY.-,CUST-.YYYY.-
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Net pay cannot be negative,Čistý plat nemôže byť záporný
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,No of Interactions,Počet interakcií
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} sa nedá preniesť viac ako {2} proti objednávke {3}
DocType: Attendance,Shift,smena
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Chart of Accounts and Parties,Spracovanie účtovej osnovy a strán
DocType: Stock Settings,Convert Item Description to Clean HTML,Konvertovať Popis položky na Vyčistiť HTML
apps/erpnext/erpnext/patches/v11_0/rename_supplier_type_to_supplier_group.py,All Supplier Groups,Všetky skupiny dodávateľov
,Final Assessment Grades,Záverečné stupne hodnotenia
apps/erpnext/erpnext/projects/doctype/task/task.py,Cannot close task {0} as its dependant task {1} is not closed.,"Úlohu {0} nemožno zatvoriť, pretože závislá úloha {1} nie je zatvorená."
DocType: Promotional Scheme,Promotional Scheme Price Discount,Zľava na propagačnú schému
DocType: Installation Note,Installation Note,Poznámka k inštalácii
DocType: Student Admission,Application Form Route,Trasa formulára žiadosti
DocType: Work Order,Planned Operating Cost,Plánované prevádzkové náklady
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Colour,farba
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 dovoleniek
DocType: Student Report Generation Tool,Show Marks,Zobraziť značky
DocType: Salary Component,Max Benefit Amount (Yearly),Maximálna výška dávky (ročne)
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Riadok odpisu {0}: Ďalší dátum odpisu nemôže byť pred dátumom nákupu
DocType: Loyalty Program,Customer Group,Zákaznícka skupina
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year Start Date should be one year earlier than Fiscal Year End Date,Dátum začiatku fiškálneho roka by mal byť jeden rok pred dátumom ukončenia fiškálneho roka
,BOM Items and Scraps,Položky kusovníka a zápisky
apps/erpnext/erpnext/healthcare/setup.py,High Sensitivity,Vysoká citlivosť
DocType: Pricing Rule,Apply Discount on Rate,Použiť zľavu na sadzbu
DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.",Automaticky aktualizovať cenu kusovníka prostredníctvom plánovača na základe najnovšej ceny / cenníka / poslednej nákupnej ceny surovín.
DocType: Tally Migration,Tally Company,Spoločnosť Tally
DocType: Quiz Question,Quiz Question,Kvíz Otázka
DocType: Task Depends On,Task Depends On,Úloha závisí od
,Lead Id,Id vedenia
DocType: Subscription Plan Detail,Subscription Plan Detail,Detail predplatného plánu
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Created {0} scorecards for {1} between: ,Vytvorené karty {0} pre {1} medzi:
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,This Week's Summary,Tento týždeň je zhrnutie
DocType: Pricing Rule Item Code,Pricing Rule Item Code,Kód pravidla cien
DocType: Water Analysis,Storage Temperature,Teplota pri skladovaní
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Income,Priamy príjem
apps/erpnext/erpnext/controllers/trends.py,Amt,Amt
,Sales Analytics,Analytika predaja
DocType: Project,Total Billable Amount (via Timesheets),Celková zúčtovateľná suma (prostredníctvom výkazov)
DocType: Setup Progress Action,Domains,domény
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,"Not permitted, configure Lab Test Template as required","Nie je povolené, podľa potreby konfigurujte Lab Test Template"
DocType: Item,Default Unit of Measure,Štandardná merná jednotka
DocType: Serial No,Distinct unit of an Item,Rozlišovacia jednotka položky
DocType: Amazon MWS Settings,Synch Products,Synchronizovať produkty
DocType: Supplier Scorecard Scoring Variable,Path,cesta
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Dr),Otvorenie (Dr)
DocType: Project,% Completed,Dokončené
DocType: Customer,Commission Rate,Sadzba Komisie
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Central Tax,Centrálna daň
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Total Outstanding Amount,Celková suma nesplatených súm
DocType: Employee Tax Exemption Proof Submission Detail,Maximum Exemption Amount,Maximálna čiastka výnimky
DocType: Subscription Plan,Based on price list,Na základe cenníka
DocType: Stock Entry Detail,Additional Cost,Dodatočné náklady
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Closing Account {0} must be of type Liability / Equity,Záverečný účet {0} musí byť typu Liability / Equity
apps/erpnext/erpnext/utilities/user_progress.py,Setup Company,Nastavenie spoločnosti
DocType: Inpatient Occupancy,Check In,Skontrolujte In
apps/erpnext/erpnext/config/help.py,Customer and Supplier,Zákazník a dodávateľ
DocType: Issue,Support Team,Podporný tím
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: You can not assign itself as parent account,Účet {0}: Nemôžete sa priradiť ako nadradený účet
apps/erpnext/erpnext/stock/doctype/item/item.py,Fixed Asset Item must be a non-stock item.,"Položka s fixným aktívom musí byť položka, ktorá nie je skladom."
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch ID (Optional),Nové číslo šarže (voliteľné)
apps/erpnext/erpnext/projects/doctype/project/project.js,Gantt Chart,Ganttov diagram
DocType: Employee Benefit Application Detail,Max Benefit Amount,Max
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Leave on {1},{0} na dovolenke {1}
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Do you really want to restore this scrapped asset?,Naozaj chcete obnoviť tento vyradený majetok?
apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py,Registration fee can not be Zero,Registračný poplatok nemôže byť Zero
DocType: Item Tax Template,Item Tax Template,Šablóna položky dane
DocType: Fiscal Year,Auto Created,Automaticky vytvorené
DocType: Quality Objective,Quality Objective,Cieľ kvality
DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Vedúci účtu v položke Zodpovednosť alebo Vlastné imanie, v ktorom bude Zisk / Strata zaúčtovaný"
DocType: GL Entry,Credit Amount in Account Currency,Výška kreditu v mene účtu
DocType: Employee Onboarding Activity,Employee Onboarding Activity,Aktivita zamestnanca na palube
DocType: Healthcare Service Unit,Parent Service Unit,Jednotka rodičovskej služby
DocType: Sales Invoice,Include Payment (POS),Zahrnúť platbu (POS)
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Private Equity,Súkromný majetok
DocType: Shift Type,First Check-in and Last Check-out,Prvý check-in a posledný check-out
DocType: Landed Cost Item,Receipt Document,Doklad o príjme
DocType: Supplier Scorecard Period,Supplier Scorecard Period,Obdobie hodnotenia dodávateľov
DocType: Employee Grade,Default Salary Structure,Štandardná mzdová štruktúra
DocType: Exchange Rate Revaluation,Total Gain/Loss,Celkový zisk / strata
apps/erpnext/erpnext/education/doctype/course_enrollment/course_enrollment.py,Student is already enrolled.,Študent je už zapísaný.
DocType: Product Bundle,Parent Item,Nadradená položka
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Brokerage,Brokerage
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please create purchase receipt or purchase invoice for the item {0},Vytvorte potvrdenie o kúpe alebo nákupnú faktúru za položku {0}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Please select Patient to get prescribed procedure,"Prosím vyberte pacienta, aby ste dostali predpísaný postup"
,Product Bundle Balance,Zostatok produktu Bundle
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Name cannot be Company,Názov spoločnosti nemôže byť Spoločnosť
DocType: Maintenance Visit,Breakdown,Zlomiť
DocType: Inpatient Record,B Negative,B Negatívny
DocType: Issue,Response By,Odpoveď By
DocType: Purchase Invoice,Credit To,Kredit
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Submit this Work Order for further processing.,Odošlite túto pracovnú objednávku na ďalšie spracovanie.
DocType: Bank Transaction,Reconciled,zmierený
DocType: Bank Guarantee,Bank Guarantee Number,Číslo bankovej záruky
apps/erpnext/erpnext/templates/pages/material_request_info.html,Delivered: {0},Doručené: {0}
DocType: Quality Meeting Table,Under Review,V časti Kontrola
apps/erpnext/erpnext/public/js/setup_wizard.js,Agriculture (beta),Poľnohospodárstvo (beta)
,Average Commission Rate,Priemerná sadzba Komisie
DocType: Sales Invoice,Customer's Purchase Order Date,Dátum objednávky odberateľa
apps/erpnext/erpnext/config/buying.py,All Contacts.,Všetky kontakty.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Použité listy
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field From Shareholder cannot be blank,Pole From Shareholder nemôže byť prázdne
DocType: Brand,Brand Defaults,Predvolené značky
DocType: Task,Depends on Tasks,Závisí od úloh
DocType: Healthcare Settings,Healthcare Settings,Nastavenia zdravotnej starostlivosti
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,{0} Student Groups created.,{0} Študentské skupiny vytvorené.
apps/erpnext/erpnext/public/js/hub/marketplace.js,Register,Registrovať
DocType: Woocommerce Settings,"This warehouse will be used to create Sale Orders. The fallback warehouse is ""Stores"".",Tento sklad sa použije na vytvorenie zákaziek odberateľa. Núdzový sklad je &quot;Obchody&quot;.
DocType: Vehicle Service,Oil Change,Výmena oleja
DocType: Project User,Project User,Užívateľ projektu
DocType: Course,Assessment,posúdenie
DocType: Promotional Scheme,Price Discount Slabs,Cena Zľavy dosky
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,New Customers,noví zákazníci
DocType: Project,Total Expense Claim (via Expense Claims),Celkový nárok na výdavky (prostredníctvom nárokov na výdavky)
DocType: Instructor Log,Other Details,Ostatné detaily
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Po transakcii s transakciami nie je možné zmeniť atribúty. Vytvorte novú položku a preneste ju do novej položky
DocType: Employee Attendance Tool,Employees HTML,Zamestnanci HTML
DocType: Leave Block List,Stop users from making Leave Applications on following days.,Zastavte používateľom v nasledujúcich dňoch ponechať aplikácie ponechané.
DocType: Budget,Ignore,Ignorovať
,Sales Person Target Variance Based On Item Group,Predajná cieľová odchýlka založená na skupine položiek
DocType: Education Settings,Current Academic Year,Aktuálny akademický rok
DocType: Bank Statement Transaction Entry,Submit/Reconcile Payments,Odoslanie / odsúhlasenie platieb
DocType: Purchase Invoice,Set Advances and Allocate (FIFO),Nastaviť predvoľby a prideliť (FIFO)
DocType: BOM,Item to be manufactured or repacked,"Výrobok, ktorý sa má vyrobiť alebo opätovne zabaliť"
apps/erpnext/erpnext/accounts/page/pos/pos.js,New Cart,Nový košík
DocType: Purchase Receipt,MAT-PRE-.YYYY.-,MAT-PRE-.YYYY.-
apps/erpnext/erpnext/stock/doctype/item/item.py,Please select Sample Retention Warehouse in Stock Settings first,Najskôr vyberte položku Vzorový skladový sklad
DocType: Lab Test Template,Result Format,Formát výsledkov
DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,"Vedúci (alebo skupiny), voči ktorým sa účtovné zápisy vyhotovujú, a zostatky sa vedú."
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Materiálová požiadavka použitá na vykonanie tejto skladovej položky
DocType: Request for Quotation,Link to material requests,Prepojenie na materiálne požiadavky
apps/erpnext/erpnext/regional/india/utils.py,Invalid {0}! The check digit validation has failed. ,Neplatné číslo {0}! Overenie kontrolnej číslice zlyhalo.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Unsecured Loans,Nezabezpečené úvery
apps/erpnext/erpnext/public/js/event.js,Add Customers,Pridať zákazníkov
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Default Default Warehouse Warehouse
DocType: Grant Application,Grant Description,Opis grantu
apps/erpnext/erpnext/stock/doctype/item/item.js,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Uvádza sa hmotnosť, nPoznačte tiež &quot;Hmotnosť UOM&quot;"
apps/erpnext/erpnext/accounts/party.py,{0} {1} is disabled,{0} {1} je vypnuté
DocType: Contract,Contract Period,Zmluvné obdobie
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js,Please enter Item Code to get Batch Number,"Zadajte kód položky, aby ste získali číslo šarže"
DocType: Cash Flow Mapping,Is Working Capital,Je pracovný kapitál
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Missing email template for dispatch. Please set one in Delivery Settings.,Chýba e-mailová šablóna na odoslanie. Nastavte ho v časti Nastavenia doručenia.
DocType: Packing Slip,MAT-PAC-.YYYY.-,MAT-PAC-.YYYY.-
DocType: Supplier Scorecard,"Scorecard variables can be used, as well as:
{total_score} (the total score from that period),
{period_number} (the number of periods to present day)
","Môžu byť použité premenné typu scorecard, ako aj: {total_score} (celkové skóre z tohto obdobia), {period_number} (počet období do dnešného dňa)"
apps/erpnext/erpnext/public/js/stock_analytics.js,Value Or Qty,Hodnota alebo množstvo
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,Prosím zaregistrujte SIREN číslo v informačnom súbore spoločnosti
DocType: Amazon MWS Settings,Check this to enable a scheduled Daily synchronization routine via scheduler,"Zaškrtnite toto, ak chcete povoliť naplánovanú dennú synchronizáciu cez plánovač"
DocType: Employee Tax Exemption Declaration,Declarations,vyhlásenie
DocType: Manufacturing Settings,Backflush Raw Materials Based On,Backflush Suroviny založené na
DocType: Cheque Print Template,Distance from top edge,Vzdialenosť od horného okraja
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Job Description,Popis práce
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"Can not filter based on Voucher No, if grouped by Voucher",Nemožno filtrovať podľa Voucher č
DocType: Purchase Receipt Item,Received and Accepted,Prijaté a prijaté
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Negative Valuation Rate is not allowed,Negatívna miera ocenenia nie je povolená
DocType: Woocommerce Settings,"The user that will be used to create Customers, Items and Sales Orders. This user should have the relevant permissions.","Užívateľ, ktorý sa použije na vytvorenie Zákazníkov, Položky a Zákazky odberateľa. Tento používateľ by mal mať príslušné povolenia."
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Purchase Order,Vytvoriť objednávku
apps/erpnext/erpnext/config/accounting.py,Define budget for a financial year.,Definujte rozpočet na rozpočtový rok.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Accounts table cannot be blank.,Tabuľka účtov nemôže byť prázdna.
DocType: Employee Checkin,Entry Grace Period Consequence,Dôsledok obdobia vstupnej milosti
,Payment Period Based On Invoice Date,Platobné obdobie založené na dátume faktúry
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Installation date cannot be before delivery date for Item {0},Dátum inštalácie nemôže byť pred dátumom dodania položky {0}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Link to Material Request,Odkaz na žiadosť o materiál
DocType: Warranty Claim,From Company,Od spoločnosti
DocType: Bank Statement Transaction Settings Item,Mapped Data Type,Typ mapovaných údajov
apps/erpnext/erpnext/stock/doctype/item/item.py,Row {0}: An Reorder entry already exists for this warehouse {1},Riadok {0}: Pre tento sklad už existuje položka Zmena poradia {1}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Date,Dátum dokumentu
DocType: Monthly Distribution,Distribution Name,Názov distribúcie
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Workday {0} has been repeated.,Pracovný deň {0} bol opakovaný.
apps/erpnext/erpnext/accounts/doctype/account/account.js,Group to Non-Group,"Skupina do skupiny, ktorá nie je členom skupiny"
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: 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.","Príklad: ABCD. ##### Ak je séria nastavená a sériové číslo nie je uvedené v transakciách, potom sa na základe tejto série vytvorí automatické sériové číslo. Ak chcete pre túto položku vždy výslovne uviesť sériové čísla. nechajte toto prázdne."
DocType: Stock Entry,Stock Entry (Outward GIT),Položka skladu (GIT smerom von)
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Party Addresses,Spracovanie adresy adresy
DocType: Selling Settings,Delivery Note Required,Vyžaduje sa dodacia poznámka
DocType: Pricing Rule,Sales Partner,Predajný partner
DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Účtovná položka zmrazená až do tohto dátumu, nikto nemôže robiť / upravovať položky okrem úlohy uvedenej nižšie."
DocType: Vehicle Log,Fuel Qty,Množstvo paliva
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Mobile No,Guardian1 Mobile Nie
DocType: Invoice Discounting,Disbursed,vyplatená
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 uvažuje o odchode."
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Accounts Payable,Čistá zmena záväzkov
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Not Available,Nie je k dispozícií
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Part-time,Čiastočný
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Delivery,dodávka
DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Kurz pre vytvorenie študentskej skupiny
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: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,"Distribútor tretej strany / dealer / provízny agent / pobočka / predajca, ktorý predáva produkty spoločnosti za províziu."
DocType: BOM Item,Original Item,Pôvodná položka
apps/erpnext/erpnext/buying/doctype/supplier/supplier.py,Series is mandatory,Séria je povinná
apps/erpnext/erpnext/config/crm.py,Potential opportunities for selling.,Potenciálne možnosti predaja.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show PDC in Print,Zobraziť PDC v Print
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/sync_product.py,Shopify Supplier,Shopify Dodávateľ
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Táto banková transakcia je už úplne zladená
DocType: POS Profile User,POS Profile User,Používateľ profilu POS
DocType: Sales Person,Sales Person Name,Názov predajnej osoby
DocType: Packing Slip,Gross Weight,Celková hmotnosť
DocType: Journal Entry,Bill No,Bill č
apps/erpnext/erpnext/assets/doctype/location/location_tree.js,New Location,Nové umiestnenie
,Project wise Stock Tracking,Project wise Stock Tracking
DocType: Vehicle Log,HR-VLOG-.YYYY.-,HR-Vlog-.YYYY.-
DocType: Student,A+,A +
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.js,Please save your document before adding a new account,Uložte dokument pred pridaním nového účtu
DocType: Issue,Service Level Agreement,Dohoda o úrovni služieb
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Item valuation rate is recalculated considering landed cost voucher amount,Kurzová sadzba sa prepočítava vzhľadom na sumu poukážky na vyložené náklady
DocType: Timesheet,Employee Detail,Detail zamestnanca
DocType: Tally Migration,Vouchers,poukážky
DocType: Student,Guardian Details,Podrobnosti strážcu
DocType: Shopify Settings,eg: frappe.myshopify.com,napr .: frappe.myshopify.com
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}"
apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Porovnajte platby s faktúrami
DocType: Holiday List,Weekly Off,Vypnuté týždenne
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Nie je možné nastaviť alternatívnu položku pre položku {0}
apps/erpnext/erpnext/www/lms/program.py,Program {0} does not exist.,Program {0} neexistuje.
apps/erpnext/erpnext/hr/doctype/department/department.js,You cannot edit root node.,Koreňový uzol nie je možné upraviť.
DocType: Fee Schedule,Student Category,Študentská kategória
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Item {0}: {1} qty produced, ","Položka {0}: {1} vyrobená,"
DocType: Identification Document Type,Identification Document Type,Typ identifikačného dokumentu
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Insufficient Stock,Nedostatočné zásoby
apps/erpnext/erpnext/controllers/selling_controller.py,Row {0}: Conversion Factor is mandatory,Riadok {0}: Faktor konverzie je povinný
DocType: Buying Settings,Purchase Receipt Required,Potvrdenie objednávky
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Cena kusovníka
DocType: HR Settings,Max working hours against Timesheet,Maximálny pracovný čas proti rozvrhu
DocType: HR Settings,Include holidays in Total no. of Working Days,Zahrnúť dovolenku v celkovom počte č. pracovných dní
DocType: Quality Meeting,Quality Meeting,Stretnutie kvality
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consulting,consulting
DocType: Payment Gateway Account,Default Payment Request Message,Predvolená správa o požiadavke na platbu
DocType: GST Settings,GSTIN Email Sent On,GSTIN Email Sent On
DocType: Amazon MWS Settings,Enable Scheduled Synch,Povoliť naplánovanú synchronizáciu
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Please select Employee,Vyberte zamestnanca
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é, bude vytvorený zákazník, ktorý bude namapovaný na pacienta. Proti tomuto zákazníkovi budú vytvorené faktúry pre pacienta. Počas vytvárania Patienta môžete tiež vybrať existujúceho zákazníka."
DocType: Fiscal Year,Stock User,Užívateľ
apps/erpnext/erpnext/config/support.py,Service Level Agreement.,Dohoda o úrovni služieb.
DocType: Additional Salary,Date on which this component is applied,Dátum uplatnenia tejto zložky
apps/erpnext/erpnext/config/accounting.py,List of available Shareholders with folio numbers,Zoznam dostupných akcionárov s číslami folio
apps/erpnext/erpnext/config/accounting.py,Setup Gateway accounts.,Nastavenie účtov brány.
DocType: Service Level Priority,Response Time Period,Doba odozvy
DocType: Purchase Invoice,Purchase Taxes and Charges,Nákupné dane a poplatky
DocType: Course Activity,Activity Date,Dátum aktivity
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select or add new customer,Vyberte alebo pridajte nového zákazníka
DocType: Contract,Unfulfilled,nesplnený
apps/erpnext/erpnext/education/utils.py,You are not allowed to enroll for this course,Nemáte povolenie prihlásiť sa na tento kurz
apps/erpnext/erpnext/templates/pages/home.html,Read blog,Prečítajte si blog
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Value,Hodnota projektu
DocType: Task,Expected Time (in hours),Očakávaný čas (v hodinách)
apps/erpnext/erpnext/stock/doctype/item/item.py,Updating Variants...,Prebieha aktualizácia variantov ...
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Sales Person in Print,Zobraziť predajnú osobu v Print
DocType: Supplier Scorecard,Per Year,Za rok
DocType: Inpatient Record,Admitted Datetime,Prijaté Datetime
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Template is mandatory.,Šablóna dane je povinná.
DocType: Clinical Procedure,Patient,Pacient
DocType: Timesheet Detail,Costing Amount,Výška kalkulácie
apps/erpnext/erpnext/stock/doctype/item/item.js,Add / Edit Prices,Pridať / upraviť ceny
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non-GST outward supplies,Mimo dodávky GST
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0}: From time must be less than to time,Riadok {0}: Čas musí byť kratší ako čas
apps/erpnext/erpnext/hr/doctype/employee/employee.py,User {0} is already assigned to Employee {1},Používateľ {0} je už priradený k zamestnancovi {1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Form View,Zobrazenie formulára
DocType: Supplier Quotation,Auto Repeat Section,Sekcia automatického opakovania
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid public token error,Chyba verejného kľúča
DocType: Sales Person,Select company name first.,Najskôr vyberte názov spoločnosti.
apps/erpnext/erpnext/public/js/setup_wizard.js,Financial Year,Finančný rok
DocType: Sales Invoice Item,Deferred Revenue,Výnosy budúcich období
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Atleast one of the Selling or Buying must be selected,Aspoň jeden z predajných alebo nákupných musí byť vybraný
DocType: Shift Type,Working Hours Threshold for Half Day,Prahová hodnota pracovnej doby pre poldeň
,Item-wise Purchase History,História nákupu
apps/erpnext/erpnext/accounts/deferred_revenue.py,Cannot change Service Stop Date for item in row {0},Dátum zastavenia služby nie je možné zmeniť pre položku v riadku {0}
DocType: Production Plan,Include Subcontracted Items,Zahrnúť subdodávky
DocType: Salary Structure,Max Benefits (Amount),Max. Prínosy (čiastka)
DocType: Homepage,Hero Section,Sekcia Hero
apps/erpnext/erpnext/config/manufacturing.py,Where manufacturing operations are carried.,"Tam, kde sa vykonávajú výrobné operácie."
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Dispatch Notification,Oznámenie o odoslaní
DocType: Projects Settings,Timesheets,Timesheets
DocType: Purchase Receipt,Get current stock,Získať aktuálne zásoby
DocType: Account,Expense,výdavok
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,{0} asset cannot be transferred,{0} aktívum sa nedá preniesť
,Unpaid Expense Claim,Nesplatený nárok na výdavky
DocType: Employee,Family Background,Rodinné zázemie
apps/erpnext/erpnext/config/hr.py,Energy Point Leaderboard,Rebríček Energy Point
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py,Bonus Payment Date cannot be a past date,Dátum platby bonusu nemôže byť dátumom
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,No {0} found for Inter Company Transactions.,Pre transakcie medzi spoločnosťami sa nenašlo číslo {0}.
DocType: Bank Account,Party Type,Typ strany
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Finish,Skončiť
DocType: Sales Invoice,C-Form Applicable,Použiteľné v tvare C
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Zostatok na účte už v debete, nie je povolené nastaviť &#39;Zostatok musí byť&#39; ako &#39;Úver&#39;"
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Qty increased by 1,Riadok # {0}: Počet navýšený o 1
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Stanovte ciele Položka Skupina pre túto predajnú osobu.
DocType: Asset Repair,ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-
DocType: Student,Student Mobile Number,Číslo študentského mobilu
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Academic Year: ,Akademický rok:
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","Podľa nákupných nastavení, ak požadovaná objednávka == &#39;ÁNO&#39;, potom na vytvorenie nákupnej faktúry musí používateľ najprv vytvoriť objednávku pre položku {0}"
DocType: Shipping Rule Condition,To Value,Ohodnotiť
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Please add the account to root level Company - ,Pridajte účet do spoločnosti s koreňovou úrovňou -
DocType: Asset Settings,Number of Days in Fiscal Year,Počet dní vo fiškálnom roku
DocType: Journal Entry,Total Amount Currency,Mena celkovej čiastky
DocType: BOM,Allow Same Item Multiple Times,Allow Same Item Multiple Times
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create BOM,Vytvoriť kusovník
DocType: Healthcare Practitioner,Charges,poplatky
DocType: Employee,Attendance and Leave Details,Podrobnosti o dochádzke a odchode
DocType: Student,Personal Details,Osobné údaje
DocType: Sales Order,Billing and Delivery Status,Stav fakturácie a dodania
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}: Dodávateľ {0} je potrebný na odoslanie e-mailu
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Investing,Peňažné toky z investovania
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Approving Role cannot be same as role the rule is Applicable To,"Schvaľovacia rola nemôže byť rovnaká ako úloha, na ktorej sa pravidlo vzťahuje"
DocType: Crop,Crop Spacing,Medzera orezania
DocType: Selling Settings,How often should project and company be updated based on Sales Transactions.,Ako často by sa mal projekt a spoločnosť aktualizovať na základe predajných transakcií.
DocType: Pricing Rule,Period Settings,Nastavenia obdobia
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Accounts Receivable,Čistá zmena pohľadávok
DocType: Quality Feedback Template,Quality Feedback Template,Šablóna kvality spätnej väzby
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Quantity must be greater than zero,Množstvo musí byť väčšie ako nula
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,"There are inconsistencies between the rate, no of shares and the amount calculated","Existujú nezrovnalosti medzi sadzbou, počtom akcií a vypočítanou sumou"
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Nechajte prázdne, ak robíte študentské skupiny za rok"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Loans (Liabilities),Úvery (pasíva)
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js,Send Grant Review Email,Odoslať e-mail na kontrolu grantu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,GSTR3B-Form,GSTR3B-Form
DocType: Production Plan Item,Produced Qty,Vyrobené Množstvo
DocType: Bank Statement Transaction Invoice Item,Journal Entry,Zápis v denníku
DocType: Stock Entry,Purchase Receipt No,Potvrdenie o kúpe č
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 vstupu zamestnanca Dátum {1}
DocType: Journal Entry,Debit Note,Poznámka k debetu
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Je táto daň zahrnutá do základnej sadzby?
DocType: Share Balance,Purchased,zakúpené
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,"Sadzba, pri ktorej je kurzová mena prepočítaná na základnú menu spoločnosti"
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,View Fees Records,Zobrazenie záznamov o poplatkoch
DocType: Training Event,Theory,teória
DocType: Sales Invoice,Is Discounted,Je zľavnené
apps/erpnext/erpnext/utilities/activation.py,Create Quotation,Vytvorenie ponuky
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}: Položka žurnálu {1} nemá účet {2} alebo už nie je priradená k inému voucheru
apps/erpnext/erpnext/accounts/page/pos/pos.js,Create a new Customer,Vytvorte nového zákazníka
DocType: BOM Website Operation,BOM Website Operation,Prevádzka webovej stránky kusovníka
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Podrobnosti faktúry / denníka
DocType: Share Balance,Share Balance,Zostatok zostatku
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Period Closing Entry,Vstup uzávierky obdobia
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,Purchase Price List,Cenník nákupu
DocType: Contract,Party User,Používateľ strany
DocType: Restaurant Order Entry,Restaurant Order Entry,Vstup do reštaurácie
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serializovanú položku {0} nie je možné aktualizovať pomocou odsúhlasenia zásob, použite položku Vstup do skladu"
DocType: Practitioner Schedule,Time Slots,Časové úseky
apps/erpnext/erpnext/stock/doctype/item/item.js,Select at least one value from each of the attributes.,Vyberte aspoň jednu hodnotu z každého z atribútov.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Bank Draft,Šek
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Last Issue,Posledné vydanie
DocType: Email Digest,Send regular summary reports via Email.,Odosielajte pravidelné súhrnné správy prostredníctvom e-mailu.
DocType: Quality Procedure Table,Step,krok
DocType: Normal Test Items,Result Value,Hodnota výsledku
DocType: Cash Flow Mapping,Is Income Tax Liability,Zodpovednosť za daň z príjmov
DocType: Healthcare Practitioner,Inpatient Visit Charge Item,Poplatok za návštevu v nemocnici
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,{0} {1} does not exist.,{0} {1} neexistuje.
apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Aktualizovať odpoveď
DocType: Bank Guarantee,Supplier,dodávateľ
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Enter value betweeen {0} and {1},Zadajte hodnotu betweeen {0} a {1}
DocType: Purchase Order,Order Confirmation Date,Dátum potvrdenia objednávky
DocType: Delivery Trip,Calculate Estimated Arrival Times,Vypočítajte odhadované časy príchodu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Jedlé
DocType: Instructor,EDU-INS-.YYYY.-,EDU-INS-.YYYY.-
DocType: Subscription,Subscription Start Date,Dátum začiatku odberu
DocType: Woocommerce Settings,Woocommerce Server URL,Adresa URL servera Woocommerce
DocType: Payroll Entry,Number Of Employees,Počet zamestnancov
apps/erpnext/erpnext/regional/india/bank_remittance.py,{0} field is limited to size {1},Pole {0} je obmedzené na veľkosť {1}
apps/erpnext/erpnext/education/utils.py,This {0} conflicts with {1} for {2} {3},Tento {0} je v rozpore s {1} pre {2} {3}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Value Proposition,Hodnota Proposition
DocType: Purchase Invoice,Contact Email,kontaktný email
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Cannot set authorization on basis of Discount for {0},Nie je možné nastaviť autorizáciu na základe Zľavy pre {0}
DocType: Attendance Request,Work From Home,Práca z domu
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: From Time and To Time is mandatory.,Riadok {0}: Čas a čas je povinný.
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Supplier Id,Id dodávateľa
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Invoice can't be made for zero billing hour,Faktúru nemožno vykonať za nulovú hodinu fakturácie
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 zostatok dovolenky už bol prenesený v budúcom zázname o pridelení dovolenky {1}"
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Last Order Date,Dátum poslednej objednávky
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Course: ,Predmet:
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Dispatch,odoslanie
DocType: Installation Note Item,Installation Note Item,Inštalácia Poznámka Položka
DocType: Journal Entry Account,Journal Entry Account,Účet pre zápis do denníka
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant,Varianta
apps/erpnext/erpnext/templates/pages/help.html,Forum Activity,Činnosť fóra
DocType: Service Level Priority,Resolution Time Period,Časové rozlíšenie rozlíšenia
DocType: Request for Quotation,Supplier Detail,Detail dodávateľa
apps/erpnext/erpnext/accounts/doctype/bank_transaction/bank_transaction.js,Document {0} successfully uncleared,Dokument {0} úspešne zrušený
DocType: Serial No,Purchase / Manufacture Details,Podrobnosti o nákupe / výrobe
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Položka Automaticky účtovať odpisy majetku
DocType: Work Order Operation,Operation completed for how many finished goods?,Operácia dokončená pre koľko hotových výrobkov?
DocType: Healthcare Settings,Employee name and designation in print,Meno a označenie zamestnanca v tlači
DocType: Tally Migration,Is Day Book Data Processed,Spracúvajú sa údaje zo dňa
DocType: Program,Courses,predmety
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Update stock must be enable for the purchase invoice {0},Pre nákupnú faktúru {0} musí byť povolená aktualizácia zásob.
DocType: Employee Boarding Activity,Employee Boarding Activity,Činnosť zamestnancov pri nástupe do zamestnania
apps/erpnext/erpnext/stock/utils.py,Warehouse {0} does not belong to company {1},Sklad {0} nepatrí spoločnosti {1}
DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Ak je táto možnosť zakázaná, pole „In Words“ nebude v žiadnej transakcii viditeľné"
DocType: Payment Entry Reference,Allocated,pridelené
DocType: Project,Time to send,Čas na odoslanie
DocType: Vital Signs,Bloated,nafúknutý
DocType: Blanket Order,Order Type,Typ objednávky
DocType: POS Closing Voucher,Period Start Date,Dátum začiatku obdobia
DocType: Maintenance Schedule,Generate Schedule,Generovať plán
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Opening Value,Otváracia hodnota
DocType: Additional Salary,Additional Salary,Dodatočný plat
DocType: Loan,Repayment Method,Spôsob splácania
apps/erpnext/erpnext/config/projects.py,Cost of various activities,Náklady na rôzne činnosti
DocType: Opportunity,Mins to First Response,Mins to First Response
DocType: Patient Appointment,Patient Age,Vek pacienta
DocType: Patient Encounter,Investigations,vyšetrovania
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Equipments,Kancelárske vybavenie
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full , did not save","LocalStorage je plná, neuložila"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Items for Raw Material Request,Položky pre požiadavku na suroviny
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Select Item (optional),Vyberte položku (voliteľné)
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py,Parent Item {0} must not be a Stock Item,Nadradená položka {0} nesmie byť skladom
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,All bank transactions have been created,Všetky bankové transakcie boli vytvorené
DocType: Stock Entry Detail,Against Stock Entry,Proti vstupu na burzu
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Fetch exploded BOM (including sub-assemblies),Načítať rozloženú kusovník (vrátane podzostáv)
DocType: Sales Invoice,ACC-SINV-.YYYY.-,ACC-Sinv-.YYYY.-
DocType: Loan,Loan Application,Žiadosť o úver
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Job Card,Pre pracovnú kartu
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Master Data,Spracovať kmeňové dáta
DocType: Cheque Print Template,Is Account Payable,Je splatný účet
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Total Order Value,Celková hodnota objednávky
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,Supplier {0} not found in {1},Dodávateľ {0} sa nenašiel v {1}
apps/erpnext/erpnext/config/settings.py,Setup SMS gateway settings,Nastavenie SMS brány
DocType: Salary Component,Round to the Nearest Integer,Zaokrúhlite na najbližšie celé číslo
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Root cannot have a parent cost center,Koreň nemôže mať nadradené nákladové stredisko
DocType: Healthcare Service Unit,Allow Appointments,Povoliť schôdzky
DocType: BOM,Show Operations,Zobraziť operácie
DocType: Practitioner Schedule,Practitioner Schedule,Plán praktických lekárov
DocType: Asset Maintenance Task,Calibration,Kalibrácia
DocType: Pricing Rule,Apply On,Použiť na
apps/erpnext/erpnext/config/accounting.py,Close Balance Sheet and book Profit or Loss.,Zatvoriť súvahu a účtovať zisk alebo stratu.
DocType: Employee,Provide Email Address registered in company,Poskytnite e-mailovú adresu zaregistrovanú v spoločnosti
DocType: Item Alternative,Alternative Item Name,Alternatívny názov položky
DocType: Assessment Plan,Course,kurz
DocType: Patient,Patient Details,Podrobnosti o pacientovi
DocType: Employee Separation,Employee Separation,Oddelenie zamestnancov
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Debtors,dlžníci
DocType: Bank Statement Settings,Mapped Items,Mapované položky
DocType: Leave Control Panel,Department (optional),Oddelenie (nepovinné)
DocType: Task Type,Task Type,Typ úlohy
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Debit A/C Number,Debetné A / C číslo
DocType: Timesheet,Total Billed Amount,Celková fakturovaná suma
apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Dátum splatnosti / referencie nemôže byť po {0}
DocType: Leave Allocation,Add unused leaves from previous allocations,Pridajte nepoužité listy z predchádzajúcich pridelení
DocType: Employee Transfer,New Company,Nová spoločnosť
DocType: Sales Invoice,Commission Rate (%),Sadzba Komisie (%)
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Sklad je možné zmeniť iba prostredníctvom položky Vstup / dodanie / Potvrdenie o kúpe
DocType: Support Settings,Close Issue After Days,Zatvorte problém po dňoch
DocType: Payment Schedule,Payment Schedule,Rozvrh platieb
DocType: Shift Type,Enable Entry Grace Period,Povoliť obdobie vstupu vstupov
DocType: Patient Relation,Spouse,manželka
DocType: Purchase Invoice,Reason For Putting On Hold,Dôvod pre pozastavenie
DocType: Item Attribute,Increment,prírastok
DocType: Vital Signs,Cuts,rezy
DocType: Student Applicant,LMS Only,Len LMS
DocType: Shopping Cart Settings,Show Contact Us Button,Zobraziť Kontaktujte nás Tlačidlo
apps/erpnext/erpnext/public/js/event.js,Add Employees,Pridať zamestnancov
DocType: Holiday List,Holidays,Prázdniny
DocType: Chapter,Chapter Head,Kapitola Vedúci
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: Restaurant Reservation,No Show,Žiadna show
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,The selected payment entry should be linked with a creditor bank transaction,Vybraná položka platby by mala byť spojená s transakciou veriteľskej banky
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Selling Amount,Predajná čiastka
DocType: Amazon MWS Settings,AWS Access Key ID,ID prístupového kľúča AWS
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py,{0} {1} is not present in the parent company,{0} {1} sa nenachádza v materskej spoločnosti
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,To Date cannot be before From Date,Dátum nemôže byť pred dátumom
apps/erpnext/erpnext/public/js/event.js,Add Suppliers,Pridať dodávateľov
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Summary for this month and pending activities,Zhrnutie za tento mesiac a prebiehajúce aktivity
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Mode of Transport,Druh transportu
apps/erpnext/erpnext/config/hr.py,Recruitment,nábor
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Hrubá mzda - celkový odpočet - splatenie úveru
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Dátum účtovania nemôže byť budúcim dátumom
apps/erpnext/erpnext/regional/india/utils.py,{} is required to generate e-Way Bill JSON,{} je potrebné na vytvorenie e-Way Bill JSON
,Work Order Stock Report,Správa o stave objednávky
apps/erpnext/erpnext/config/accounting.py,Enable / disable currencies.,Zapnutie / vypnutie mien.
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,View in Cart,Zobraziť v košíku
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Fetch based on FIFO,Načítať na základe FIFO
DocType: Timesheet,Total Billable Amount,Celková zúčtovateľná čiastka
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},Pre položku {1} proti objednávke odberateľa {2} je možné podať žiadosť o materiál v hodnote maximálne {0}
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js,Production Item,Výrobná položka
DocType: Share Transfer,Equity/Liability Account,Účet vlastného imania / pasív
apps/erpnext/erpnext/www/all-products/index.html,No values,Žiadne hodnoty
apps/erpnext/erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py,Cancel the journal entry {0} first,Najprv zrušte položku žurnálu {0}
DocType: GL Entry,Remarks,Poznámky
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Supplier must be debit,Riadok {0}: Záloha voči dodávateľovi musí byť debetná
DocType: Student Report Generation Tool,Attended by Parents,Zúčastnili sa ho rodičia
DocType: POS Profile,Update Stock,Aktualizovať zásoby
DocType: Account,Old Parent,Starý rodič
DocType: Production Plan,Download Materials Required,Download Požadované materiály
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Another Period Closing Entry {0} has been made after {1},Ďalší záznam uzávierky obdobia {0} bol vykonaný po {1}
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,Item Template,Šablóna položky
DocType: Purchase Invoice Item,Discount on Price List Rate (%),Zľava na sadzbu cenníka (%)
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Skratka je povinná
DocType: Travel Request,Domestic,domáci
apps/erpnext/erpnext/selling/report/pending_so_items_for_purchase_request/pending_so_items_for_purchase_request.py,SO Qty,SO Množstvo
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: Program Enrollment,Pick/Drop by Guardian,Pick / Drop by Guardian
DocType: Exchange Rate Revaluation Account,Balance In Base Currency,Zostatok v základnej mene
DocType: Payment Entry,Get Outstanding Invoice,Získajte vynikajúcu faktúru
apps/erpnext/erpnext/config/buying.py,All Products or Services.,Všetky produkty alebo služby.
DocType: Vehicle Service,Brake Pad,Brzdová doštička
DocType: Pricing Rule,Max Amt,Max Amt
DocType: Shopping Cart Settings,Show Stock Availability,Zobraziť dostupnosť skladu
DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,Cenová ponuka hotelových izieb
DocType: Task,Pending Review,Čaká na posúdenie
DocType: Employee,Date of Joining,Dátum vstupu
DocType: Patient,Patient Relation,Vzťah pacienta
DocType: Currency Exchange,For Selling,Pre predaj
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Financing,Peňažné toky z financovania
DocType: Blanket Order,Manufacturing,výrobné
apps/erpnext/erpnext/templates/pages/home.html,By {0},Od {0}
DocType: Restaurant Menu,Restaurant Manager,Manažér reštaurácie
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Out Value,Hodnota Out
DocType: Volunteer,Availability and Skills,Dostupnosť a zručnosti
DocType: Employee Advance,Advance Account,Predbežný účet
DocType: GSTR 3B Report,Invoices with no Place Of Supply,Faktúry bez miesta dodania
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Ref,Ref
DocType: Invoice Discounting,Loan End Date,Dátum ukončenia úveru
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Množstvo v riadku {0} ({1}) musí byť rovnaké ako vyrobené množstvo {2}
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Creating bank entries...,Vytvárajú sa položky banky ...
apps/erpnext/erpnext/utilities/user_progress_utils.py,Commercial,komerčný
DocType: Salary Slip,Bank Account No.,Číslo bankového účtu
apps/erpnext/erpnext/controllers/taxes_and_totals.py,Advance amount cannot be greater than {0} {1},Výška preddavku nemôže byť vyššia ako {0} {1}
DocType: Cheque Print Template,Width of amount in word,Šírka množstva slov
DocType: Delivery Note,MAT-DN-.YYYY.-,MAT-DN-.YYYY.-
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign Salary Structure,Priradiť mzdovú štruktúru
DocType: Stock Entry,Stock Entry Type,Typ položky skladu
DocType: Quality Action Table,Responsible,zodpovedný
DocType: Room,Room Number,Číslo izby
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Fiscal Year...,Vyberte fiškálny rok ...
,Trial Balance,Skúšobný zostatok
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Employee Transfer cannot be submitted before Transfer Date ,Prevod zamestnancov nie je možné predložiť pred dátumom prevodu
DocType: Grading Scale,Grading Scale Name,Názov mierky
DocType: Location,Area UOM,Oblasť UOM
DocType: Timesheet,Total Costing Amount,Celková čiastka nákladov
DocType: Material Request Plan Item,Material Issue,Problém materiálu
DocType: BOM,Item Image (if not slideshow),Obrázok položky (ak nie je prezentácia)
DocType: Share Balance,Is Company,Je spoločnosť
DocType: BOM Update Tool,Update latest price in all BOMs,Aktualizujte najnovšiu cenu vo všetkých kusovníkoch
DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Správy väčšie ako 160 znakov budú rozdelené do viacerých správ
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Salary Slip submitted for period from {0} to {1},Platový lístok predložený na obdobie od {0} do {1}
apps/erpnext/erpnext/controllers/trends.py,Project-wise data is not available for Quotation,Údaje o projekte nie sú k dispozícii pre ponuku
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py,Total Outstanding Amt,Celkový nesplatený Amt
DocType: Purchase Invoice Item,Item Tax Rate,Položka Daňová sadzba
DocType: Sales Order Item,Planned Quantity,Plánované množstvo
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Retention Stock Entry,Zadržanie zásob
DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,V aplikácii Words (Export) sa zobrazí po uložení poznámky o doručení.
DocType: Selling Settings,Each Transaction,Každá transakcia
DocType: Program Enrollment,Institute's Bus,Autobus Inštitútu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select the Company first,Najskôr vyberte spoločnosť
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Attendance for employee {0} is already marked for this day,Účasť pre zamestnanca {0} je už označená pre tento deň
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,Opening,otváracia
DocType: Crop Cycle,Detected Disease,Zistená choroba
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) nemôže byť väčšie ako plánované množstvo ({2}) vo výrobnej zákazke {3}
DocType: Stock Ledger Entry,Stock Queue (FIFO),Fronta akcií (FIFO)
apps/erpnext/erpnext/controllers/buying_controller.py,Please enter 'Is Subcontracted' as Yes or No,Zadajte „Je subdodávaný“ ako Áno alebo Nie
DocType: Company,Default Holiday List,Zoznam predvolených dovoleniek
DocType: Naming Series,Current Value,Súčasná hodnota
apps/erpnext/erpnext/config/accounting.py,"Seasonality for setting budgets, targets etc.","Sezónnosť pre stanovenie rozpočtov, cieľov atď."
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Upozornenie: Objednávka odberateľa {0} už existuje proti objednávke odberateľa {1}
apps/erpnext/erpnext/utilities/user_progress.py,Monthly Sales Target (,Mesačný predajný cieľ (
DocType: Guardian,Guardian Interests,Záujmy opatrovníka
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Batch ID is mandatory,ID dávky je povinné
DocType: Payment Entry,Paid Amount (Company Currency),Platená čiastka (mena spoločnosti)
DocType: Shipping Rule Condition,Shipping Rule Condition,Pravidlo dodania
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Maximum attempts for this quiz reached!,Maximálny počet pokusov o tento test dosiahol!
DocType: Employee Boarding Activity,Required for Employee Creation,Požadované pre vytváranie zamestnancov
DocType: Loyalty Point Entry Redemption,Loyalty Point Entry Redemption,Odkúpenie vernostného bodu
DocType: Job Applicant,Cover Letter,Sprievodný list
DocType: Chart of Accounts Importer,Chart Preview,Graf Náhľad
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Parameter kontroly kvality položky
DocType: Support Settings,Get Started Sections,Začíname Sekcie
DocType: Delivery Note,% of materials delivered against this Delivery Note,% dodaných materiálov proti tomuto dodaciemu listu
DocType: Warranty Claim,Warranty / AMC Status,Záruka / stav AMC
apps/erpnext/erpnext/utilities/user_progress.py,Gram,gram
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be negative,Pridelené množstvo nemôže byť záporné
DocType: POS Profile,Item Groups,Skupiny položiek
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Customer LPO No.,Zákaznícke číslo LPO
,Company Name,meno spoločnosti
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 1,Na adresu 1
,Purchase Receipt Trends,Trendy nákupu
DocType: Leave Block List,Leave Block List Dates,Ponechajte dátumy zoznamu blokov
apps/erpnext/erpnext/education/doctype/student/student.py,Student {0} exist against student applicant {1},Študent {0} existuje proti študentovi {1}
DocType: Education Settings,LMS Settings,Nastavenia LMS
apps/erpnext/erpnext/config/settings.py,Titles for print templates e.g. Proforma Invoice.,"Názvy tlačových šablón, napr. Proforma Faktúra."
DocType: Serial No,Delivery Time,Dodacia lehota
DocType: Loan,Repayment Period in Months,Doba splácania v mesiacoch
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Transporter ID,ID prepravcu
apps/erpnext/erpnext/config/buying.py,Price List master.,Cenník master.
DocType: Department,The first Expense Approver in the list will be set as the default Expense Approver.,Prvý schvaľovateľ výdavkov v zozname bude nastavený ako predvolený schvaľovateľ výdavkov.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Advertising,reklama
DocType: Authorization Rule,Customer or Item,Zákazník alebo položka
DocType: Vehicle Log,Invoice Ref,Faktúra Ref
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,C-form is not applicable for Invoice: {0},Formulár C sa na Faktúru nevzťahuje: {0}
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Invoice Created,Faktúra bola vytvorená
DocType: Shift Type,Early Exit Grace Period,Predčasné ukončenie Grace Obdobie
DocType: Patient Encounter,Review Details,Podrobnosti kontroly
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: Hours value must be greater than zero.,Riadok {0}: Hodnota hodín musí byť väčšia ako nula.
DocType: Account,Account Number,Číslo účtu
DocType: Assessment Result Detail,Assessment Result Detail,Detail hodnotenia výsledku
DocType: Support Settings,Auto close Issue after 7 days,Automatické zatvorenie Problém po 7 dňoch
DocType: Supplier,Is Frozen,Je zmrazený
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Total weightage assigned should be 100%. It is {0},Celkové priradené váženie by malo byť 100%. Je to {0}
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"
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Overlapping conditions found between:,Prekrývajúce sa podmienky nájdené medzi:
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Paid and Not Delivered,Platené a nedoručené
DocType: GST HSN Code,HSN Code,Kód HSN
DocType: GSTR 3B Report,September,septembra
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Administrative Expenses,Administratívne výdavky
DocType: C-Form,C-Form No,C-formulár č
DocType: Purchase Invoice,End date of current invoice's period,Dátum ukončenia obdobia faktúry
DocType: Item,Manufacturers,výrobcovia
DocType: Crop Cycle,Crop Cycle,Cyklus orezania
DocType: Serial No,Creation Time,Čas vytvorenia
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Zadajte Schvaľovaciu úlohu alebo Schvaľujúceho používateľa
DocType: Plaid Settings,Link a new bank account,Prepojiť nový bankový účet
DocType: Inpatient Record,Discharged,Vybitý
DocType: BOM,Raw Material Cost(Company Currency),Náklady na suroviny (mena spoločnosti)
apps/erpnext/erpnext/accounts/party.py,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Poznámka: Dátum splatnosti / referenčný dátum prekročí povolené úverové dni zákazníka do {0} dní (dní)
DocType: Email Digest,New Sales Orders,Nové zákazky odberateľa
apps/erpnext/erpnext/buying/report/purchase_analytics/purchase_analytics.js,based_on,založené na
DocType: Employee,Owned,vlastnila
DocType: Item Default,Item Default,Položka Predvolená hodnota
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Party can only be one of ,Strana môže byť iba jedna
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Entertainment Expenses,Náklady na zábavu
DocType: Item,Inspection Required before Delivery,Kontrola potrebná pred dodaním
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py,Opening Entry Journal,Otvorenie vstupného denníka
DocType: Purchase Taxes and Charges,Add or Deduct,Pridať alebo odpočítať
DocType: POS Closing Voucher Details,Collected Amount,Vybraná suma
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Commission on Sales,Komisia pre predaj
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Start entering data from here : ,Tu začnite zadávať údaje:
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Rest Of The World,Zvyšok sveta
apps/erpnext/erpnext/templates/pages/home.html,Publications,Publikácie
DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,"Predvolený bankový / hotovostný účet sa automaticky aktualizuje v položke Platový denník, keď je tento režim vybratý."
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Celkový rozpočet
DocType: Upload Attendance,Upload HTML,Odovzdajte kód HTML
DocType: Bank Reconciliation Detail,Payment Document,Platobný doklad
DocType: Opportunity Item,Opportunity Item,Položka Príležitosti
DocType: Travel Itinerary,Travel From,Cestovanie z
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,CWIP Account,CWIP účet
DocType: SMS Log,Sender Name,Meno odosielateľa
DocType: Pricing Rule,Supplier Group,Skupina dodávateľov
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,"Set Start Time and End Time for  \
					Support Day {0} at index {1}.",Nastavte čas začiatku a čas ukončenia {0} na index {1}.
DocType: Employee,Date of Issue,Dátum vydania
,Requested Items To Be Transferred,"Požadované položky, ktoré sa majú preniesť"
DocType: Employee,Contract End Date,Dátum ukončenia zmluvy
DocType: Purchase Order Item,Returned Qty,Vrátené množstvo
DocType: Sales Order,SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-
DocType: Delivery Note,Required only for sample item.,Vyžaduje sa iba pre vzorovú položku.
DocType: Healthcare Service Unit,Vacant,prázdny
DocType: Opportunity,Sales Stage,Predajné štádium
DocType: Sales Order,In Words will be visible once you save the Sales Order.,V programe Words budú viditeľné po uložení zákazky odberateľa.
DocType: Item Reorder,Re-order Level,Re-order Level
DocType: Shift Type,Enable Auto Attendance,Povoliť automatickú účasť
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Preference,prednosť
,Department Analytics,Oddelenie Analytics
DocType: Crop,Scientific Name,Vedecké meno
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Discount amount cannot be greater than 100%,Výška zľavy nesmie byť vyššia ako 100%
DocType: Student Guardian,Relation,vzťah
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py,Name or Email is mandatory,Meno alebo e-mail je povinný
DocType: Tax Rule,Billing Zipcode,Fakturačný PSČ
apps/erpnext/erpnext/public/js/hub/marketplace.js,Marketplace,Marketplace
apps/erpnext/erpnext/buying/utils.py,{0} {1} status is {2},{0} {1} status je {2}
DocType: Quiz Activity,Quiz Activity,Aktivita kvízu
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,{0} is not in a valid Payroll Period,{0} nie je v platnom období mzdy
DocType: Timesheet,Billed,účtované
apps/erpnext/erpnext/config/support.py,Issue Type.,Typ problému.
DocType: Restaurant Order Entry,Last Sales Invoice,Posledná predajná faktúra
DocType: Payment Terms Template,Payment Terms,Platobné podmienky
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Reserved Qty: Quantity ordered for sale, but not delivered.","Vyhradené množstvo: Množstvo objednané na predaj, ale nedodané."
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 nie je vytvorený záznam o výmene meny pre {1} až {2}
DocType: Task,Actual End Date (via Time Sheet),Aktuálny dátum ukončenia (prostredníctvom časového výkazu)
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js,Score must be less than or equal to 5,Skóre musí byť menšie alebo rovné 5
apps/erpnext/erpnext/controllers/buying_controller.py,Please select BOM in BOM field for Item {0},Vyberte položku BOM v poli kusovníka pre položku {0}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} is under warranty upto {1},Sériové číslo {0} je v záruke až {1}
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split,rozdeliť
DocType: Bank Account,Bank Account No,Bankový účet č
DocType: Payroll Entry,Salary Slip Based on Timesheet,Platový sklz založený na časovom rozvrhu
DocType: Program Enrollment,Mode of Transportation,Spôsob dopravy
DocType: Budget,Control Action,Kontrolná akcia
DocType: Employee Tax Exemption Declaration,Total Exemption Amount,Celková suma oslobodenia
DocType: Medical Code,Medical Code Standard,Štandard lekárskeho predpisu
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Reqd by Date cannot be before Transaction Date,Riadok # {0}: Reqd podľa dátumu nemôže byť pred dátumom transakcie
DocType: Education Settings,Current Academic Term,Aktuálny akademický termín
DocType: Employee,Short biography for website and other publications.,Krátka biografia pre webové stránky a ďalšie publikácie.
DocType: Purchase Invoice Item,Received Qty,Prijaté množstvo
DocType: Purchase Invoice Item,Rate (Company Currency),Sadzba (mena spoločnosti)
DocType: Item Reorder,Request for,Žiadosť
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Installing presets,Inštalácia predvolieb
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter Repayment Periods,Zadajte Doby splácania
DocType: Pricing Rule,Advanced Settings,Pokročilé nastavenia
DocType: Payment Entry,Paid Amount,Zaplatená suma
DocType: Setup Progress Action,Setup Progress Action,Nastavenie Postup Akcie
DocType: Subscription Plan,Billing Interval Count,Počet intervalov fakturácie
apps/erpnext/erpnext/public/js/financial_statements.js,Financial Statements,Finančné výkazy
DocType: Project,Message will sent to users to get their status on the project,"Správa bude odoslaná používateľom, aby získali status v projekte"
DocType: Employee Tax Exemption Proof Submission Detail,Employee Tax Exemption Proof Submission Detail,Detail podania dôkazu o oslobodení zamestnancov od dane
DocType: Purchase Order,Delivered,dodaný
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Delivered,{0}% Dodané
DocType: Lead,Request for Information,Žiadosť o informáciu
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,End Year,Koniec roka
DocType: Vehicle,Diesel,motorová nafta
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Výška sankcie nemôže byť vyššia ako suma nároku v riadku {0}.
apps/erpnext/erpnext/controllers/buying_controller.py,From {0} | {1} {2},Od {0} | {1} {2}
apps/erpnext/erpnext/education/api.py,Result already Submitted,Výsledok už bol odoslaný
DocType: Pricing Rule Detail,Rule Applied,Platí pravidlo
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Actual Qty is mandatory,Skutočné množstvo je povinné
DocType: Purchase Order Item,Expected Delivery Date,Očakávaný dátum dodania
DocType: Issue,Resolution Date,Dátum rozlíšenia
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave of type {0} cannot be longer than {1},Dovolenka typu {0} nemôže byť dlhšia ako {1}
DocType: Shopping Cart Settings,Enable Shopping Cart,Povoliť nákupný košík
DocType: Pricing Rule,Apply Rule On Other,Použiť pravidlo On Other
DocType: Vehicle,Last Carbon Check,Posledná kontrola uhlíka
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Make,Urobiť
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Sales Invoice {0} created as paid,Predajná faktúra {0} bola vytvorená ako zaplatená
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Na vytvorenie žiadosti o platbu sa vyžaduje referenčný dokument
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Income Tax,Daň z príjmu
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Computer,počítačový
DocType: Material Request,% Ordered,Objednané
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 {1} položka. Môžete ich povoliť ako položku {1} z jej hlavného riadku položky
DocType: Quiz,Passing Score,Predchádzajúce skóre
apps/erpnext/erpnext/config/website.py,Settings for website homepage,Nastavenia domovskej stránky webovej stránky
DocType: Work Order,Qty To Manufacture,Množstvo na výrobu
apps/erpnext/erpnext/public/js/setup_wizard.js,Non Profit (beta),Neziskové (beta)
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Outstanding Amt,Vynikajúci Amt
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Pin Code,PIN kód
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Povoliť nasledujúcim používateľom schváliť žiadosti o ponechanie pre dni blokovania.
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: Production Plan,Get Items For Work Order,Získať položky pre pracovný príkaz
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Project and all Tasks to status {0}?,Nastaviť Project a všetky úlohy na stav {0}?
DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Zobraziť &quot;Skladom&quot; alebo &quot;Nie je skladom&quot; na základe skladom dostupného v tomto sklade.
apps/erpnext/erpnext/accounts/page/pos/pos.js,Delete permanently?,Odstrániť natrvalo?
DocType: Blanket Order,MFG-BLR-.YYYY.-,MFG-BLR-.YYYY.-
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 príslušných modulov
DocType: Leave Type,Is Leave Without Pay,Je ponechaný bez platenia
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} must be submitted,Riadok # {0}: Musí byť odoslaná položka {1}
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Dodatočná čiastka zľavy (mena spoločnosti)
DocType: Patient,Tobacco Past Use,Tabak Minulé použitie
DocType: Crop,Materials Required,Požadované materiály
DocType: POS Profile,POS Profile,Profil POS
DocType: Journal Entry,Write Off Entry,Zápis vypnutý
apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,"Musíte byť používateľom iným ako administrátor s úlohami System Manager a Item Manager, aby ste sa mohli zaregistrovať na Marketplace."
DocType: Asset,Insured value,Poistená hodnota
DocType: Quotation Item,Against Docname,Proti Docname
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,"As raw materials projected quantity is more than required quantity, there is no need to create material request.
			Still if you want to make material request, kindly enable <b>Ignore Existing Projected Quantity</b> checkbox","Vzhľadom na to, ž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 však chcete vykonať požiadavku na materiál, začiarknite políčko <b>Ignorovať existujúce projektované množstvo</b>"
DocType: Packed Item,Prevdoc DocType,Prevdoc DocType
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,{0} payment entries can not be filtered by {1},{0} položky platby nie je možné filtrovať podľa {1}
DocType: Variant Field,Variant Field,Variantné pole
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py,Access token or Shopify URL missing,Chýba prístupový token alebo adresa URL Shopify
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Bank account cannot be named as {0},Bankový účet nemožno pomenovať ako {0}
DocType: Terms and Conditions,Terms and Conditions Help,Pomocník Podmienky
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,From and To dates required,Požadované dátumy a dátumy
DocType: Production Plan Item,Product Bundle Item,Položka produktu
DocType: Student Group,Group Based On,Na základe skupiny
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Mobile No,Guardian2 Mobile Nie
DocType: Manufacturing Settings,Allow Multiple Material Consumption,Povoliť viacnásobnú spotrebu materiálu
DocType: Item Quality Inspection Parameter,Acceptance Criteria,Kritériá prijateľnosti
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Prepravné pravidlo platí len pre predaj
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Selling Rate,Predajná sadzba
DocType: Account,Asset,aktívum
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 lekárov pre zdravotnú starostlivosť. Pridajte ho do programu Master Healthcare Practitioner
DocType: Vehicle,Chassis No,Podvozok č
DocType: Employee,Default Shift,Predvolený posun
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation,Skratka spoločnosti
apps/erpnext/erpnext/config/manufacturing.py,Tree of Bill of Materials,Strom kusovníka
DocType: Article,LMS User,Používateľ LMS
DocType: BOM,Allow Alternative Item,Povoliť alternatívnu položku
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Aktivita Náklady na zamestnanca
DocType: Email Digest,Open Quotations,Otvoriť ponuky
DocType: Cash Flow Mapper,Section Footer,Päta sekcie
DocType: Lead,Next Contact By,Ďalší kontakt By
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Pending Quantity,Čakajúce množstvo
DocType: Quotation,SAL-QTN-.YYYY.-,SAL-QTN-.YYYY.-
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select to add Serial Number.,"Vyberte, ak chcete pridať sériové číslo."
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html,modified,modifikovaný
DocType: Pricing Rule,Qty,množstvo
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Net ITC Available (A) - (B)
,Material Requests for which Supplier Quotations are not created,"Materiálové požiadavky, pre ktoré nie sú vytvorené ponuky dodávateľov"
apps/erpnext/erpnext/public/js/education/lms/quiz.js,Something went wrong while evaluating the quiz.,Pri hodnotení kvízu sa niečo pokazilo.
DocType: GST Account,GST Account,Účet GST
DocType: Pricing Rule,For Price List,Pre cenník
DocType: GoCardless Mandate,GoCardless Mandate,Mandát GoCardless
DocType: Work Order,Skip Material Transfer to WIP Warehouse,Preskočiť presun materiálu do skladu WIP
DocType: Training Event Employee,Feedback Submitted,Odozva bola odoslaná
DocType: Cheque Print Template,Primary Settings,Primárne nastavenia
DocType: Amazon MWS Settings,Customer Type,Typ zákazníka
DocType: Supplier Scorecard Period,PU-SSP-.YYYY.-,PU-SSP-.YYYY.-
DocType: POS Settings,Use POS in Offline Mode,Použite POS v režime offline
DocType: Territory,Parent Territory,Rodičovské územie
DocType: Vehicle Log,Odometer Reading,Počítadlo kilometrov
DocType: Additional Salary,Salary Slip,Výplatná páska
DocType: Payroll Entry,Payroll Frequency,Mzdová frekvencia
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} počet hotových výrobkov v pracovnom príkaze {3}. Aktualizujte stav prevádzky prostredníctvom karty Job {4}.
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 konca nie sú v platnom období miezd, nie je možné vypočítať hodnotu {0}"
DocType: Products Settings,Home Page is Products,Domovská stránka je Produkty
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Calls,volá
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference #{0} dated {1},Odkaz # {0} zo dňa {1}
DocType: Guardian Interest,Guardian Interest,Záujemca o opatrovníctvo
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 zákazky odberateľa
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Subscription,predplatné
DocType: Stock Entry Detail,Stock Entry Detail,Detail položky skladu
DocType: Email Digest,Sales Orders to Bill,Zákazky odberateľa spoločnosti Bill
DocType: Company,For reference only.,Iba pre referencie.
DocType: GL Entry,GL Entry,Vstup GL
DocType: Employee Tax Exemption Category,Employee Tax Exemption Category,Kategória oslobodenia zamestnancov
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Row {0}: asset is required for item {1},Riadok {0}: položka je potrebná pre položku {1}
DocType: Expense Claim Detail,Sanctioned Amount,Sankovaná suma
apps/erpnext/erpnext/accounts/doctype/subscription_plan/subscription_plan.py,Billing Interval Count cannot be less than 1,Počet intervalov účtovania nesmie byť menší ako 1
DocType: Taxable Salary Slab,Taxable Salary Slab,Zdaniteľná platová doska
DocType: Grant Application,Grant Application,Žiadosť o grant
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Nepodarilo sa nájsť skóre začínajúce na {0}. Musíte mať trvalé skóre 0 až 100
DocType: Fee Structure,EDU-FST-.YYYY.-,EDU-FST-.YYYY.-
DocType: Sales Person,Parent Sales Person,Rodičovská predajná osoba
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,View all issues from {0},Zobraziť všetky problémy od používateľa {0}
DocType: Student Group Creation Tool,Get Courses,Získajte kurzy
apps/erpnext/erpnext/controllers/accounts_controller.py,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Riadok # {0}: Počet musí byť 1, pretože položka je fixným aktívom. Použite samostatný riadok pre viacnásobný počet."
DocType: Shift Type,Working hours below which Absent is marked. (Zero to disable),"Pracovná doba, pod ktorou je Absent označená. (Zero na vypnutie)"
DocType: Customer Group,Only leaf nodes are allowed in transaction,V transakcii sú povolené iba uzly listov
DocType: Grant Application,Organization,organizácie
DocType: Fee Category,Fee Category,Kategória poplatku
DocType: Batch,Batch ID,ID dávky
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot be a fixed asset item as Stock Ledger is created.,"Nemôže byť fixnou položkou aktív, ak je vytvorená akciová kniha."
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,This Month's Summary,Súhrn tohto mesiaca
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: {1} {2} does not match with {3},Riadok {0}: {1} {2} sa nezhoduje s hodnotou {3}
apps/erpnext/erpnext/utilities/user_progress.py,Go to Suppliers,Prejsť na dodávateľov
DocType: Payment Order,PMO-,PMO-
apps/erpnext/erpnext/templates/emails/training_event.html,Please update your status for this training event,Aktualizujte svoj stav pre túto školiacu udalosť
DocType: Volunteer,Morning,dopoludnia
DocType: Quotation Item,Quotation Item,Položka ponuky
apps/erpnext/erpnext/config/support.py,Issue Priority.,Priorita vydania.
DocType: Journal Entry,Credit Card Entry,Vstup kreditnej karty
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Vynechaný časový priestor, slot {0} až {1} sa prekrýva s exisiting slotom {2} až {3}"
DocType: Journal Entry Account,If Income or Expense,Ak sú príjmy alebo výdavky
DocType: Work Order Operation,Work Order Operation,Prevádzka pracovného príkazu
DocType: Accounts Settings,Address used to determine Tax Category in transactions.,Adresa použitá na určenie kategórie dane v transakciách.
apps/erpnext/erpnext/utilities/user_progress.py,Go to Customers,Prejsť na Zákazníci
DocType: Student Group,Set 0 for no limit,Nastavte 0 pre žiadny limit
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} is inactive,{0} {1}: Účet {2} je neaktívny
DocType: Repayment Schedule,Payment Date,Dátum platby
DocType: Asset Maintenance Task,Assign To Name,Priradiť názov
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Warning: Material Requested Qty is less than Minimum Order Qty,Upozornenie: Požadovaný počet materiálu je menší ako minimálny počet objednávok
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Current BOM and New BOM can not be same,Aktuálny kusovník a nový kusovník nemôžu byť rovnaké
apps/erpnext/erpnext/config/agriculture.py,Crops & Lands,Plodiny a pozemky
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbr can not be blank or space,Abbr nemôže byť prázdny alebo medzera
DocType: Material Request,MAT-MR-.YYYY.-,MAT-MR-.YYYY.-
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot deliver Serial No {0} of item {1} as it is reserved to \
												fullfill Sales Order {2}","Sériové číslo {0} položky {1} nie je možné doručiť, pretože je vyhradené na vyplnenie objednávky odberateľa {2}"
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Fetching records......,Prebieha načítavanie záznamov ......
DocType: Delivery Stop,Contact Information,Kontaktné informácie
DocType: Sales Order Item,For Production,Pre výrobu
DocType: Serial No,Asset Details,Podrobnosti o aktívach
DocType: Restaurant Reservation,Reservation Time,Čas rezervácie
DocType: Selling Settings,Default Territory,Predvolené územie
DocType: Employee Benefit Application,Dispensed Amount (Pro-rated),Dispensed Amount (Pro-Rated)
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Max discount allowed for item: {0} is {1}%,Maximálna povolená zľava pre položku: {0} je {1}%
DocType: Product Bundle,List items that form the package.,"Zoznam položiek, ktoré tvoria balík."
DocType: Payment Request,Amount in customer's currency,Suma v mene zákazníka
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Získať položky z nákupných dokladov
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0} (Payment Table): Amount must be positive,Riadok # {0} (Tabuľka platieb): Hodnota musí byť kladná
DocType: Employee Tax Exemption Declaration,Employee Tax Exemption Declaration,Vyhlásenie o oslobodení zamestnancov od dane
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Finding linked payments,Hľadanie prepojených platieb
DocType: Project,Expected End Date,Očakávaný dátum ukončenia
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Conversion rate cannot be 0 or 1,Miera konverzie nemôže byť 0 alebo 1
DocType: Opportunity,CRM-OPP-.YYYY.-,CRM-OPP-.YYYY.-
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Name,Názov inštitútu
DocType: Serial No,Asset Status,Stav majetku
DocType: Salary Slip,Earnings,zárobok
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Total Paid Amount,Celková zaplatená čiastka
apps/erpnext/erpnext/stock/doctype/batch/batch.js,To Warehouse,Do skladu
DocType: Appraisal,Total Score (Out of 5),Celkové skóre (z 5)
DocType: Journal Entry,Accounts Receivable,Pohľadávky
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Setting defaults,Nastavenie predvolených hodnôt
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ť dodanie sériovým číslom, pretože {0} je pridané a bez zaistenia dodania"
,Invoiced Amount (Exclusive Tax),Fakturovaná čiastka (Exkluzívna daň)
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Cannot change status as student {0} is linked with student application {1},"Stav nie je možné zmeniť, ak je študent {0} prepojený so študentskou aplikáciou {1}"
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total leaves allocated is mandatory for Leave Type {0},Celkový počet pridelených listov je povinný pre typ dovolenky {0}
apps/erpnext/erpnext/config/getting_started.py,Data Import and Settings,Import a nastavenie dát
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 Automatický výber, zákazníci budú automaticky prepojení s príslušným vernostným programom (pri uložení)"
DocType: Account,Expense Account,Výdavkový účet
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 zvažuje vstup do zamestnania."
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian1,Vzťah s Guardian1
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.js,Create Invoice,Vytvoriť faktúru
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Request already exists {0},Žiadosť o platbu už existuje {0}
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 &quot;Ľavý&quot;
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py,Pay {0} {1},Platiť {0} {1}
DocType: Company,Sales Settings,Nastavenia predaja
DocType: Sales Order Item,Produced Quantity,Vyrobené množstvo
apps/erpnext/erpnext/templates/emails/request_for_quotation.html,The request for quotation can be accessed by clicking on the following link,K žiadosti o cenovú ponuku sa dostanete kliknutím na nasledujúci odkaz
DocType: Monthly Distribution,Name of the Monthly Distribution,Názov mesačnej distribúcie
DocType: Production Plan,Get Raw Materials For Production,Získajte suroviny pre výrobu
DocType: Employee,New Workplace,Nové pracovisko
DocType: Support Search Source,API,API
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py,"Missing value for Password, API Key or Shopify URL","Chýba hodnota hesla, kľúča API alebo adresy URL Shopify"
DocType: Supplier Scorecard Scoring Variable,Parameter Name,Názov parametra
DocType: Request for Quotation,PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py,Account {0} does not match with Company {1},Účet {0} sa nezhoduje so spoločnosťou {1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select an item in the cart,Vyberte položku v košíku
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Create Payment Entries,Vytvoriť položky platby
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Select Company,Vyberte spoločnosť
DocType: Material Request Plan Item,Material Request Type,Typ požiadavky na materiál
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Member ID,ID člena
DocType: Issue,Raised By (Email),Zvýšený o (e-mail)
DocType: Employee Health Insurance,Employee Health Insurance,Zdravotné poistenie zamestnancov
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ť mimo obdobia vyhradenia dovolenky
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 predajnej faktúre, ale môže sa použiť pri vytváraní skupinového testu."
DocType: Healthcare Settings,Registration Fee,Registračný poplatok
,Produced,produkoval
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,White,biely
DocType: Clinical Procedure,Procedure Template,Postup šablóny
DocType: Account,Frozen,zmrazený
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}
DocType: Student Admission,Publish on website,Publikovať na webovej stránke
apps/erpnext/erpnext/portal/doctype/homepage/homepage.py,This is an example website auto-generated from ERPNext,Toto je vzorová webová stránka generovaná automaticky z ERPNext
DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Zrušenie platby pri zrušení faktúry
apps/erpnext/erpnext/templates/pages/projects.html,No tasks,Žiadne úlohy
DocType: Delivery Note,Print Without Amount,Tlač bez množstva
apps/erpnext/erpnext/config/buying.py,Purchase Orders given to Suppliers.,Objednávky zadané dodávateľom.
,Reserved,rezervovaný
DocType: Employee,Notice (days),Oznámenie (dni)
apps/erpnext/erpnext/config/help.py,Setting up Email Account,Nastavenie e-mailového účtu
DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
DocType: Contract,Unsigned,nepodpísaný
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.,"Deň (dni), kedy sa uchádzate o dovolenku, sú prázdniny. Nemusíte žiadať o dovolenku."
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Could not submit some Salary Slips,Nepodarilo sa odoslať nejaké platové lístky
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},"Sklad {0} sa nedá odstrániť, pretože existuje množstvo pre položku {1}"
DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Potvrdenie o nákupe nákladov na pristátie
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Approve,schvaľovať
apps/erpnext/erpnext/hr/page/team_updates/team_updates.js,No more updates,Žiadne ďalšie aktualizácie
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,Leaves Allocated Successfully for {0},Listy úspešne pridelené pre {0}
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Report,Hodnotiaca správa
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.","Aby sa pravidlo o cenách v konkrétnej transakcii neuplatňovalo, mali by byť zakázané všetky platné pravidlá o cenách."
DocType: Company,Default Deferred Revenue Account,Predvolený účet odložených príjmov
apps/erpnext/erpnext/config/non_profit.py,Donor information.,Informácie o darcovi.
DocType: Authorization Rule,Customerwise Discount,Zákaznícka zľava
DocType: Stock Ledger Entry,Outgoing Rate,Odchádzajúca rýchlosť
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Vyberte aspoň pridelené množstvo, typ faktúry a číslo faktúry aspoň v jednom riadku"
DocType: Asset Category,Asset Category Name,Názov kategórie zariadenia
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Receipt document must be submitted,Doklad o prijatí musí byť predložený
,Employee Advance Summary,Zhrnutie zamestnancov
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
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Detailed Reason,Podrobný dôvod
apps/erpnext/erpnext/healthcare/setup.py,Low Sensitivity,Nízka citlivosť
apps/erpnext/erpnext/accounts/doctype/bank_transaction/bank_transaction.py,The total allocated amount ({0}) is greated than the paid amount ({1}).,Celková pridelená suma ({0}) je vyššia ako zaplatená suma ({1}).
DocType: Authorization Rule,Applicable To (Designation),Platné pre (označenie)
DocType: Tax Rule,Billing City,Fakturačné mesto
DocType: Item,Is Customer Provided Item,Položka poskytovaná zákazníkom
DocType: Purchase Invoice,Purchase Taxes and Charges Template,Šablóna nákupných daní a poplatkov
DocType: Sales Invoice Item,Brand Name,Názov značky
DocType: Fee Schedule,Total Amount per Student,Celková suma na študenta
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Apparel & Accessories,Oblečenie a doplnky
DocType: Compensatory Leave Request,Work From Date,Práca od dátumu
apps/erpnext/erpnext/projects/doctype/project/project.py,Project Collaboration Invitation,Pozvánka na projektovú spoluprácu
DocType: Student Attendance Tool,Student Attendance Tool,Nástroj Študentská dochádzka
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Prescribed Procedures,Predpísané postupy
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py,Unable to find variable: ,Nepodarilo sa nájsť premennú:
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,PDC/LC Amount,Množstvo PDC / LC
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Set Details,Nastavte Detaily
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total claimed amount,Celková suma záloh nesmie byť vyššia ako celková požadovaná suma
DocType: POS Item Group,Item Group,Skupina položiek
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Momentálne nie sú v sklade žiadne zásoby
apps/erpnext/erpnext/utilities/user_progress.py,Upload your letter head (Keep it web friendly as 900px by 100px),Odovzdajte svoju hlavičku listu (udržiavajte ju v priateľskom prostredí ako 900 pixlov na 100 pixlov)
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} nie je nastavená pre sériové čísla. Stĺpec musí byť prázdny
DocType: Company,Default Values,Základné hodnoty
apps/erpnext/erpnext/setup/doctype/company/company.js,Default tax templates for sales and purchase are created.,Vytvoria sa štandardné šablóny pre predaj a nákup.
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leave Type {0} cannot be carry-forwarded,Typ ponechania {0} nie je možné prenášať ďalej
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To account must be a Receivable account,Debet Na účet musí byť účet s pohľadávkami
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 zmluvy nemôže byť menší ako dnes.
apps/erpnext/erpnext/stock/__init__.py,Please set Account in Warehouse {0} or Default Inventory Account in Company {1},Nastavte účet v sklade {0} alebo predvolený účet zásob v spoločnosti {1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Set as Default,Nastaviť ako predvolenú
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Čistá hmotnosť tohto balíka. (vypočíta sa automaticky ako súčet čistej hmotnosti položiek)
apps/erpnext/erpnext/stock/doctype/item_variant_settings/item_variant_settings.py,Cannot set the field <b>{0}</b> for copying in variants,Nie je možné nastaviť pole <b>{0}</b> pre kopírovanie vo variantoch
DocType: Payment Term,Month(s) after the end of the invoice month,Mesiac (-y) po skončení fakturačného mesiaca
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Get Employees,Získajte zamestnancov
DocType: Student,Leaving Certificate Number,Číslo výstupného certifikátu
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js,Not Expired,Nezanikla
DocType: Company,Unrealized Exchange Gain/Loss Account,Nerealizovaný výmenný zisk / stratový účet
DocType: Employee,Relieving Date,Dátum uvoľnenia
DocType: Plant Analysis,Plant Analysis Criterias,Kritériá analýzy rastlín
DocType: Leave Block List Date,Leave Block List Date,Zanechať dátum zoznamu blokov
DocType: Payment Entry,Receive,obdržať
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Relieving Date must be greater than Date of Joining,Uvoľnenie Dátum musí byť väčší ako Dátum pripojenia
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Error: Not a valid id?,Chyba: Nie je platné ID?
DocType: BOM Update Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.
It also updates latest price in all the BOMs.","Nahraďte konkrétny kusovník vo všetkých ostatných kusovníkov, kde sa používa. To nahradí starý odkaz kusovníka, aktualizovať náklady a regenerovať &quot;BOM Explosion Item&quot; tabuľku podľa nového kusovníka. Aktualizuje aj najnovšiu cenu vo všetkých kusovníkov."
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 sú povinné"
DocType: Sales Invoice Payment,Base Amount (Company Currency),Základná čiastka (mena spoločnosti)
DocType: Sales Invoice Advance,Sales Invoice Advance,Záloha predajnej faktúry
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Notify Customers via Email,Upozorniť zákazníkov prostredníctvom e-mailu
DocType: Production Plan Item,Make Work Order for Sub Assembly Items,Urobte objednávku pre položky podzostavy
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Manager,manažér
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Expired Batches,Platnosti po uplynutí platnosti
DocType: Shipping Rule,Shipping Rule Type,Typ pravidla odoslania
DocType: Job Offer,Accepted,Prijatý
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,You have already assessed for the assessment criteria {}.,Posudzovali ste už hodnotiace kritériá {}.
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch Numbers,Vyberte čísla šarží
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Age (Days),Vek (dni)
DocType: Student Batch Name,Batch Name,Názov dávky
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Large,Veľký
apps/erpnext/erpnext/controllers/accounts_controller.py,Accounting Entry for {0}: {1} can only be made in currency: {2},Účtovná položka pre {0}: {1} môže byť vykonaná iba v mene: {2}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for hold: ,Dôvod pozastavenia:
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Failed,Zlyhanie vytvorenia poplatku
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Reorder Level,Úroveň poradia
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} '{1}' is disabled,{0} &#39;{1}&#39; je vypnuté
DocType: Stock Ledger Entry,Actual Qty After Transaction,Skutočné množstvo po transakcii
DocType: Subscription,Cancel At End Of Period,Zrušiť na konci obdobia
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js,Healthcare Service Unit Tree,Strom služieb zdravotnej starostlivosti
apps/erpnext/erpnext/config/buying.py,Bundle items at time of sale.,Balík položiek v čase predaja.
DocType: Payment Reconciliation Payment,Allocated Amount,Pridelená suma
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,Please select Company and Designation,Vyberte spoločnosť a označenie
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,Vyžaduje sa „Dátum“
DocType: Email Digest,Bank Credit Balance,Bankový zostatok na účte
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Zobraziť kumulatívnu čiastku
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 uplatnenie
DocType: Purchase Invoice,Additional DIscount Percentage,Ďalšie percento DIscount
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 požičiavajúcej inštitúcie.
apps/erpnext/erpnext/controllers/accounts_controller.py,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,"Upozornenie: Systém nekontroluje overbilling, pretože suma pre položku {0} v {1} je nulová"
apps/erpnext/erpnext/public/js/setup_wizard.js,Select your Domains,Vyberte svoje domény
DocType: Agriculture Task,Task Name,Názov úlohy
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Stock Entries already created for Work Order ,Skladové položky už vytvorené pre pracovný príkaz
,Amount to Deliver,Suma na dodanie
apps/erpnext/erpnext/accounts/doctype/account/account.py,Company {0} does not exist,Spoločnosť {0} neexistuje
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,No pending Material Requests found to link for the given items.,"Neboli nájdené žiadne čakajúce žiadosti o materiál, ktoré by odkazovali na dané položky."
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šetkých svojich študentov"
DocType: Company,Company Logo,Logo spoločnosti
DocType: Content Question,Question Link,Otázka Link
DocType: HR Settings,Leave Approver Mandatory In Leave Application,Nechajte schvaľovateľa povinného v žiadosti o dovolenku
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Add notes,Pridať poznámky
apps/erpnext/erpnext/templates/generators/item/item_configure.js,{0} items found.,Počet nájdených položiek: {0}.
DocType: Patient,Personal and Social History,Osobné a sociálne dejiny
DocType: Maintenance Visit Purpose,Work Done,Práca dokončená
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í na hodnotu {0}, pretože zamestnanec pripojený k nižšie uvedeným predajcom nemá ID používateľa {1}"
DocType: Student Guardian,Father,otec
,Purchase Order Items To Be Received,Položky objednávky budú prijaté
apps/erpnext/erpnext/accounts/general_ledger.py,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debetné a kreditné nie sú rovnaké pre {0} # {1}. Rozdiel je {2}.
DocType: Marketplace Settings,Custom Data,Vlastné údaje
DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,V programe Words budú viditeľné po uložení objednávky.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Actual type tax cannot be included in Item rate in row {0},Skutočná daň typu nemôže byť zahrnutá do položky Položka v riadku {0}
DocType: Lab Test Template,Compound,zlúčenina
DocType: Quotation,Rate at which customer's currency is converted to company's base currency,"Sadzba, ktorou sa mena zákazníka prevádza na základnú menu spoločnosti"
DocType: Lead,Converted,prevedený
DocType: Email Digest,New Income,Nový príjem
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Retention Stock Entry already created or Sample Quantity not provided,Zadaná skladová položka už bola vytvorená alebo nie je dodané množstvo vzorky
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Vouchers,Spracovanie poukážok
DocType: Support Settings,Allow Resetting Service Level Agreement,Povoliť zmluvu o vynulovaní úrovne služby
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please enter Item Code to get batch no,"Zadajte kód položky, aby ste získali dávku č"
apps/erpnext/erpnext/public/js/controllers/transaction.js,Service Stop Date cannot be before Service Start Date,Dátum zastavenia služby nemôže byť pred dátumom začiatku služby
DocType: Employee Property History,Employee Property History,História majetku zamestnanca
,Requested Items To Be Ordered,"Požadované položky, ktoré majú byť objednané"
DocType: Vital Signs,Blood Pressure (systolic),Tlak krvi (systolický)
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Leave Without Pay does not match with approved Leave Application records,Leave Without Pay nezodpovedá schváleným záznamom Leave Application
DocType: Purchase Invoice Item,Expense Head,Výdavková hlava
DocType: Employee,Reason for Resignation,Dôvod odstúpenia
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Fetch Subscription Updates,Načítať aktualizácie predplatného
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Platená čiastka + Odpísaná čiastka nemôže byť väčšia ako Grand Total
DocType: Asset Repair,Error Description,Popis chyby
DocType: Healthcare Practitioner,Out Patient Consulting Charge Item,Položka Poplatok za poradenstvo pre pacienta
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Invoice,Nová faktúra
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,No replies from,Žiadne odpovede od používateľa
DocType: Shopify Settings,Sales Order Series,Séria zákaziek odberateľa
DocType: Accounts Settings,Automatically Fetch Payment Terms,Automaticky načítať platobné podmienky
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,"Číslo riadku, ktoré je väčšie alebo rovné aktuálnemu číslu riadku pre tento typ nabíjania, sa nedá zobraziť"
apps/erpnext/erpnext/public/js/hub/components/reviews.js,Anonymous,anonymný
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please select the Company,Vyberte spoločnosť
apps/erpnext/erpnext/accounts/page/pos/pos.js,"Master data syncing, it might take some time",Synchronizácia kmeňových dát môže chvíľu trvať
DocType: Leave Application,HR-LAP-.YYYY.-,HR-LAP-.YYYY.-
DocType: Item,Customer Items,Položky zákazníka
DocType: Program Enrollment,Enrolled courses,Zapísané kurzy
DocType: Lab Prescription,Test Code,Skúšobný poriadok
DocType: Purchase Taxes and Charges,On Previous Row Total,Na predchádzajúcom riadku Celkom
DocType: Student,Student Email Address,E-mailová adresa študenta
,Delayed Item Report,Správa o oneskorenej položke
DocType: Academic Term,Education,vzdelanie
DocType: Supplier Quotation,Supplier Address,Adresa dodávateľa
DocType: Salary Detail,Do not include in total,Neuvádzajte spolu
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot set multiple Item Defaults for a company.,Nie je možné nastaviť viacero predvolených položiek pre spoločnosť.
apps/erpnext/erpnext/accounts/party.py,{0}: {1} does not exists,{0}: {1} neexistuje
DocType: Purchase Receipt Item,Rejected Quantity,Zamietnuté množstvo
DocType: Cashier Closing,To TIme,Ak chcete
DocType: Daily Work Summary Group User,Daily Work Summary Group User,Užívateľ skupiny denného pracovného prehľadu
DocType: Fiscal Year Company,Fiscal Year Company,Spoločnosť fiškálneho roka
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
DocType: Payment Schedule,Payment Term,Lehota splatnosti
DocType: Quality Action,Quality Review,Kontrola kvality
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,In Stock Qty,Na sklade Počet
DocType: Material Request Plan Item,Customer Provided,Poskytnutý zákazník
apps/erpnext/erpnext/projects/doctype/task/task.py,Child Task exists for this Task. You can not delete this Task.,Pre túto úlohu existuje Child Task. Túto úlohu nemôžete odstrániť.
DocType: Item,Inventory,inventár
apps/erpnext/erpnext/regional/india/utils.py,Either GST Transporter ID or Vehicle No is required if Mode of Transport is Road,"V prípade, že Spôsob dopravy je Cestná, vyžaduje sa buď GST Transporter ID alebo Vehicle No"
DocType: Supplier Scorecard Criteria,Criteria Name,Názov kritéria
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Total Allocated Leaves,Celkový počet pridelených listov
DocType: Chapter,Members,členovia
DocType: Fees,Student Details,Podrobnosti študenta
DocType: Account,Fixed Asset,Fixný majetok
DocType: Cheque Print Template,Has Print Format,Má formát tlače
DocType: Training Result Employee,Training Result Employee,Školenia Výsledok Zamestnanec
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with child nodes cannot be set as ledger,Účet s podriadenými uzlami nemožno nastaviť ako hlavnú knihu
apps/erpnext/erpnext/config/help.py,Purchase Order to Payment,Objednávka na platbu
apps/erpnext/erpnext/agriculture/doctype/disease/disease.py,Start day is greater than end day in task '{0}',Deň začiatku je väčší ako koncový deň v úlohe „{0}“
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Financing,Čisté peňažné prostriedky z financovania
DocType: Quiz,Enter 0 to waive limit,"Zadajte 0, ak chcete zrušiť obmedzenie"
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,Newspaper Publishers,Vydavatelia novín
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Dodávateľ je povinný voči platobnému účtu {2}
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Outstanding Cheques and Deposits to clear,Nevyhnutné kontroly a vklady na odstránenie
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 fakturačným cyklom
DocType: Vehicle,Natural Gas,Zemný plyn
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} not found,Sériové číslo {0} sa nenašlo
DocType: Hub User,Hub Password,Heslo rozbočovača
,Bank Reconciliation Statement,Vyhlásenie o zmierení
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Fixed Asset,Čistá zmena dlhodobého majetku
DocType: Payment Request,Paid,zaplatil
DocType: Maintenance Visit,Completion Status,Stav dokončenia
DocType: Job Card,Transferred Qty,Prevedené množstvo
DocType: Healthcare Service Unit,Occupied,obsadený
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Opening {0} Invoice created,Otvorenie {0} Vytvorená faktúra
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to create website,Nepodarilo sa vytvoriť webovú stránku
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Opportunities by lead source,Príležitosti podľa zdroja olova
DocType: Grading Scale Interval,Grading Scale Interval,Interval mierky
DocType: Education Settings,Instructor Records to be created by,"Instruktor Záznamy, ktoré má vytvoriť"
DocType: Student Report Generation Tool,Student Report Generation Tool,Študent generácie nástroj
apps/erpnext/erpnext/stock/doctype/batch/batch.js,View Ledger,Zobraziť Ledger
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Akékoľvek ďalšie poznámky, pozoruhodné úsilie, ktoré by malo ísť do záznamov."
DocType: Travel Request,"Details of Sponsor (Name, Location)","Podrobnosti o sponzorovi (meno, poloha)"
DocType: Task,Weight,závažia
DocType: Staffing Plan Detail,Current Count,Aktuálny počet
DocType: Sales Team,Incentives,stimuly
DocType: Program Fee,Program Fee,Poplatok za program
DocType: Delivery Settings,Delay between Delivery Stops,Oneskorenie medzi zastaveniami doručenia
DocType: Stock Settings,Freeze Stocks Older Than [Days],Staršie zmrazenie zásob ako [dni]
DocType: Promotional Scheme,Promotional Scheme Product Discount,Zľava na propagačnú schému
apps/erpnext/erpnext/support/doctype/issue_priority/issue_priority.py,Issue Priority Already Exists,Priorita vydania už existuje
DocType: Account,Asset Received But Not Billed,"Aktíva prijaté, ale neboli účtované"
DocType: POS Closing Voucher,Total Collected Amount,Celková suma
DocType: Course,Default Grading Scale,Predvolená stupnica stupňovania
DocType: POS Profile,Allow user to edit Discount,Povoliť používateľovi upraviť zľavu
DocType: POS Closing Voucher,Linked Invoices,Prepojené faktúry
DocType: Volunteer,Weekends,víkendy
DocType: Employee,Health Details,Podrobnosti o zdravotnom stave
DocType: Employee Education,Graduate,Absolvent
DocType: Asset Maintenance Task,Asset Maintenance Task,Úloha údržby majetku
DocType: Restaurant Order Entry,Restaurant Table,Reštaurácia tabuľky
DocType: Amazon MWS Settings,CN,CN
apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js,Order Entry,Vstupna objednavka
DocType: Request for Quotation Supplier,Download PDF,Prevziať PDF
DocType: Bank Transaction,Unallocated Amount,Nepriradená čiastka
DocType: Travel Itinerary,Rented Car,Prenajaté auto
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Zapnuté
DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Časový rozvrh predajnej faktúry
DocType: Subscription,Plans,plány
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Čiastka nákladového listu pristátia
DocType: Student Log,Medical,lekársky
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Account {0} is frozen,Účet {0} je zmrazený
DocType: Project,First Email,Prvý e-mail
DocType: Supplier Scorecard,Criteria Setup,Nastavenie kritérií
DocType: Crop,Yield UOM,Výnos UOM
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Lab Test Prescriptions,Lab Test Prescription
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,Service Expense,Náklady na služby
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference No & Reference Date is required for {0},Pre číslo {0} sa vyžaduje referenčné číslo a referenčný dátum
DocType: Salary Structure,Leave Encashment Amount Per Day,Zanechajte čiastku inkasa za deň
DocType: Student Admission Program,Naming Series (for Student Applicant),Pomenovacia séria (pre študentského prihlasovateľa)
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per section 17(5),Podľa oddielu 17 ods.
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ých v {2} na {3} {4} na {5} na dokončenie tejto transakcie.
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/buying/doctype/request_for_quotation/request_for_quotation.py,Same supplier has been entered multiple times,Rovnaký dodávateľ bol zadaný viackrát
DocType: Customs Tariff Number,Tariff Number,Číslo colného sadzobníka
DocType: Plant Analysis Criteria,Maximum Permissible Value,Maximálna povolená hodnota
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Received Stock Entries,Prijaté položky skladu
DocType: Opportunity,Opportunity Amount,Množstvo príležitostí
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount,Množstvo objednávky
DocType: C-Form,III,III
DocType: Contract,Fulfilment Terms,Podmienky plnenia
apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,"Skupina, ktorá nie je členom skupiny"
DocType: Student Guardian,Mother,matka
DocType: Issue,Service Level Agreement Fulfilled,Dohoda o úrovni služieb splnená
DocType: Payroll Entry,Deduct Tax For Unclaimed Employee Benefits,Odpočítanie dane pre nenárokované zamestnanecké výhody
DocType: Travel Request,Travel Funding,Cestovné financovanie
DocType: Shipping Rule,Fixed,fixné
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äčšie ako plánované množstvo ({2}) v pracovnom príkaze {3}
DocType: Quality Review,Additional Information,Ďalšie informácie
DocType: Course Scheduling Tool,Reschedule,presunúť
apps/erpnext/erpnext/setup/doctype/company/company.py,Please select Existing Company for creating Chart of Accounts,Vyberte možnosť Existujúca spoločnosť pre vytvorenie účtovej osnovy
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Active Leads / Customers,Aktívni zákazníci / zákazníci
apps/erpnext/erpnext/templates/generators/item/item_configure.js,1 exact match.,1 presná zhoda.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Sports,športové
DocType: Employee Advance,Claimed Amount,Nárokovaná suma
DocType: Plant Analysis Criteria,Plant Analysis Criteria,Kritériá analýzy rastlín
DocType: Fee Schedule,Send Payment Request Email,Odoslať e-mail s požiadavkou na platbu
DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,V programe Words budú viditeľné po uložení predajnej faktúry.
DocType: Sales Invoice,Sales Team1,Predajný tím1
DocType: Work Order,Required Items,Požadované položky
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Read the ERPNext Manual,Prečítajte si príručku ERPNext
DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Skontrolujte číslo faktúry dodávateľa
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Search Sub Assemblies,Hľadať podzostavy
DocType: Rename Tool,Type of document to rename.,Typ dokumentu na premenovanie.
apps/erpnext/erpnext/utilities/activation.py,"Leads help you get business, add all your contacts and more as your leads","Vedie vám pomôže získať obchod, pridajte všetky svoje kontakty a viac ako vaše vedenie"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Indirect Expenses,Nepriame náklady
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Internet Publishing,Internetové publikovanie
DocType: Customer,Account Manager,Správca účtov
DocType: Amazon MWS Settings,BR,BR
DocType: Item,Warranty Period (in days),Záručná doba (v dňoch)
apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js,No items found.,Nenašli sa žiadne položky.
DocType: Item Attribute,From Range,Z rozsahu
DocType: Clinical Procedure,Consumables,Spotrebný
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,'employee_field_value' and 'timestamp' are required.,Vyžadujú sa &#39;employee_field_value&#39; a &#39;timestamp&#39;.
DocType: Purchase Taxes and Charges,Reference Row #,Referenčný riadok #
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set 'Asset Depreciation Cost Center' in Company {0},Nastavte hodnotu „Centrum nákladov na odpisy majetku“ v spoločnosti {0}
DocType: Amazon MWS Settings,Click this button to pull your Sales Order data from Amazon MWS.,"Kliknite na toto tlačidlo, ak chcete údaje o odbernej objednávke vytiahnuť z Amazon MWS."
DocType: Shift Type,Working hours below which Half Day is marked. (Zero to disable),"Pracovné hodiny, pod ktorými je označený poldeň. (Zero na vypnutie)"
,Assessment Plan Status,Stav plánu hodnotenia
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select {0} first,Najprv vyberte možnosť {0}
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,Submit this to create the Employee record,Odošlite túto správu na vytvorenie záznamu Zamestnanec
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""","Toto bude pripojené k kódu položky variantu. Ak je napríklad vaša skratka &quot;SM&quot; a kód položky je &quot;T-SHIRT&quot;, kód položky variantu bude &quot;T-SHIRT-SM&quot;"
DocType: Support Settings,Track Service Level Agreement,Dohoda o úrovni služieb sledovania
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please enter Delivery Date,Zadajte dátum doručenia
DocType: Purchase Invoice Item,Quality Inspection,Kontrola kvality
DocType: Account,Root Type,Typ koreňa
DocType: Journal Entry,Write Off Based On,Zapnuté zapnuté
DocType: Lab Test,Report Preference,Preferencia správy
DocType: Products Settings,Products Settings,Nastavenie produktov
DocType: Amazon MWS Settings,Synch Taxes and Charges,Synchrónne dane a poplatky
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Total cannot be zero,Spolu nemôže byť nula
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Cr),Otvorenie (Cr)
DocType: Employee,Company Email,Email spoločnosti
DocType: Shopping Cart Settings,Show Stock Quantity,Zobraziť množstvo tovaru
DocType: Student,A-,A-
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0} is added in the child company {1},Účet {0} je pridaný v dcérskej spoločnosti {1}
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date Of Retirement must be greater than Date of Joining,Dátum odchodu do dôchodku musí byť väčší ako dátum vstupu
DocType: Restaurant Order Entry,Add Item,Pridať položku
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Sick Leave,Chorá dovolenka
DocType: Lab Test,Lab Test,Laboratórny test
DocType: Account,Accumulated Depreciation,Akumulované odpisy
DocType: Support Search Source,Source Type,typ zdroja
DocType: Department Approver,Department Approver,Schvaľovateľ oddelenia
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Qty per BOM Line,Počet za riadok kusovníka
apps/erpnext/erpnext/controllers/buying_controller.py,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Akceptované + odmietnuté Počet sa musí rovnať prijatému množstvu pre položku {0}
apps/erpnext/erpnext/projects/doctype/task/task.js,Expense Claims,Náklady nároky
DocType: Bank Account,Address HTML,Adresa HTML
,Stock Projected Qty,Sklad
DocType: Employee Onboarding,Job Offer,Ponuka práce
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,No Remarks,Žiadne poznámky
DocType: Sales Invoice,Change Amount,Zmeniť čiastku
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Write Off Amount,Množstvo odpisu
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,No Items available for transfer,Nie sú k dispozícii žiadne položky na prenos
DocType: Work Order,Actual End Date,Aktuálny dátum ukončenia
DocType: Loyalty Point Entry,Loyalty Point Entry,Vstup vernostného bodu
DocType: Travel Itinerary,Train,Vlak
DocType: BOM Explosion Item,BOM Explosion Item,Položka výbuchu kusovníka
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward Supplies(liable to reverse charge,Inward Supplies (Invertné dodávky) (podliehajú spätnému poplatku
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,{0}: {1} not found in Invoice Details table,{0}: {1} sa nenašlo v tabuľke Podrobnosti faktúry
DocType: Stock Entry,Total Incoming Value,Celková vstupná hodnota
DocType: Bank Transaction Payments,Bank Transaction Payments,Platby bankových transakcií
apps/erpnext/erpnext/public/js/stock_analytics.js,Select Warehouse...,Vybrať sklad ...
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Type of Business,Typ podnikania
apps/erpnext/erpnext/config/buying.py,All Addresses.,Všetky adresy.
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Povolenie „Použiť pre nákupný košík“, pretože nákupný košík je povolený a malo by existovať aspoň jedno daňové pravidlo pre nákupný košík"
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Course,Vyberte kurz
DocType: Taxable Salary Slab,Percent Deduction,Percentuálny odpočet
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 nemôže byť menšie ako nula
DocType: Share Balance,To No,Na Nie
DocType: Leave Control Panel,Allocate Leaves,Prideľte listy
DocType: Assessment Result,Student Name,Meno študenta
apps/erpnext/erpnext/config/crm.py,Plan for maintenance visits.,Plánujte návštevy údržby.
apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Nasledujúce požiadavky na materiál boli automaticky vyvolané na základe úrovne opätovného objednania položky
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on PO,Akcia v prípade kumulovaného mesačného rozpočtu prekročená o PO
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Full-time,Na plný úväzok
DocType: Program Enrollment,Vehicle/Bus Number,Číslo vozidla / autobusu
DocType: Tax Rule,Purchase Tax Template,Šablóna nákupnej dane
DocType: Production Plan,Material Request Planning,Plánovanie materiálovej požiadavky
DocType: UOM,Check this to disallow fractions. (for Nos),"Skontrolujte toto, ak chcete zakázať frakcie. (pre čísla č.)"
DocType: Retention Bonus,Bonus Payment Date,Dátum platby bonusu
DocType: BOM,Operating Cost,Prevádzkové náklady
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select Items based on Delivery Date,Vyberte položky podľa dátumu doručenia
DocType: Homepage,Tag Line,Tag Line
DocType: Customer,From Lead,Z elektródy
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Unclosed Fiscal Years Profit / Loss (Credit),Zisk / strata za neuzavreté fiškálne roky
DocType: Agriculture Analysis Criteria,Agriculture,poľnohospodárstvo
DocType: Quality Procedure,Parent Procedure,Postup rodičov
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Set Open,Nastavte položku Otvoriť
apps/erpnext/erpnext/www/all-products/index.html,Toggle Filters,Prepnúť filtre
DocType: Production Plan,Material Request Detail,Detail požiadavky na materiál
DocType: Shift Type,Process Attendance After,Proces Dochádzka Po
DocType: Material Request Item,Quantity and Warehouse,Množstvo a sklad
apps/erpnext/erpnext/utilities/user_progress.py,Go to Programs,Prejdite na položku Programy
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Duplicate entry in References {1} {2},Riadok # {0}: Duplicitná položka v odkazoch {1} {2}
DocType: Loyalty Point Entry,Loyalty Program,Vernostný program
DocType: Lost Reason Detail,Opportunity Lost Reason,Príležitosť Lost Reason
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is a limited liability company,"Platí, ak je spoločnosť spoločnosťou s ručením obmedzeným"
DocType: Patient,"Allergies, Medical and Surgical History","Alergia, lekárska a chirurgická história"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Capital Stock,Základný kapitál
DocType: Share Transfer,From Folio No,Z Folio č
apps/erpnext/erpnext/templates/pages/order.js,Pay Remaining,Platba zostáva
apps/erpnext/erpnext/accounts/page/pos/pos.js,Search Item,Položka vyhľadávania
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Leaves,Celkový počet listov
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update rate as per last purchase,Rýchlosť aktualizácie za posledný nákup
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please select a table,Vyberte tabuľku
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} is blocked so this transaction cannot proceed,"{0} je zablokované, takže táto transakcia nemôže pokračovať"
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get Items From,Získať položky z
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",Vernostné body sa vypočítajú z vynaložených výdavkov (prostredníctvom predajnej faktúry) na základe uvedeného faktora zberu.
DocType: Setup Progress Action,Min Doc Count,Min Doc Count
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} must be a non-stock item,Položka {0} musí byť non-stock položka
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge Account,Zlúčiť účet
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to Group,Previesť na skupinu
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,"Already set default in pos profile {0} for user {1}, kindly disabled default","Už nastavené predvolené nastavenie v profile pos {0} pre používateľa {1}, predvolene deaktivované"
DocType: Fiscal Year,Companies,firmy
,Minutes to First Response for Opportunity,Zápisnica k prvej reakcii na príležitosť
DocType: Hotel Room Amenity,Hotel Room Amenity,Vybavenie izieb hotela
apps/erpnext/erpnext/config/selling.py,Invoices for Costumers.,Faktúry pre zákazníkov.
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.js,No Staffing Plans found for this Designation,Pre toto označenie neboli nájdené žiadne personálne plány
DocType: BOM Update Tool,Current BOM,Aktuálny kusovník
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Príležitostná dovolenka
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Cost Updated,Aktualizované náklady
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,One customer can be part of only single Loyalty Program.,Jeden zákazník môže byť súčasťou jediného vernostného programu.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Cannot cancel transaction for Completed Work Order.,Pre dokončený pracovný príkaz nie je možné zrušiť transakciu.
DocType: Grant Application,Grant Application Details ,Uveďte podrobnosti žiadosti
DocType: Purchase Invoice,Apply Additional Discount On,Použiť dodatočnú zľavu
,Sales Partner Commission Summary,Zhrnutie Sales Sales Commission Commission
apps/erpnext/erpnext/controllers/selling_controller.py,Order Type must be one of {0},Typ objednávky musí byť: {0}
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry already exists,Položka platby už existuje
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No Work Orders created,Neboli vytvorené žiadne pracovné príkazy
DocType: Assessment Plan,Grading Scale,Stupnica stupňovania
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Marketing Expenses,Marketingové náklady
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Next Contact Date cannot be in the past,Ďalší kontaktný dátum nemôže byť v minulosti
DocType: Shopify Settings,Webhooks Details,Podrobnosti Webhooks
DocType: Authorization Rule,Authorization Rule,Pravidlo autorizácie
apps/erpnext/erpnext/config/non_profit.py,Volunteer Type information.,Informácie o type dobrovoľníka.
DocType: Naming Series,This is the number of the last created transaction with this prefix,Toto je číslo poslednej vytvorenej transakcie s touto predponou
DocType: Supplier Scorecard,Indicator Color,Indikátor Farba
DocType: Item Variant Settings,Copy Fields to Variant,Kopírovať polia do variantu
DocType: Soil Texture,Sandy Loam,Sandy Loam
DocType: Question,Single Correct Answer,Single Correct Answer
apps/erpnext/erpnext/hr/utils.py,From date can not be less than employee's joining date,Od dátumu nemôže byť kratší ako dátum vstupu zamestnanca
DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Povoliť viacero zákaziek odberateľa voči objednávke odberateľa
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,PDC/LC,PDC / LC
DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Ak je táto možnosť začiarknutá, suma dane sa bude považovať za už zahrnutú v čiastke Print Rate / Print Amount"
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Dátum sa opakuje
DocType: Pricing Rule,Party Information,Informácie o strane
apps/erpnext/erpnext/shopping_cart/cart.py,Debtors ({0}),Dlžníci ({0})
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äčšia ako zamestnanec uľavenie dátum
DocType: Shift Type,Enable Exit Grace Period,Povoliť obdobie ukončenia Grace
DocType: Expense Claim,Employees Email Id,Id zamestnaneckého e-mailu
DocType: Shopify Settings,Update Price from Shopify To ERPNext Price List,Aktualizovať cenu z Shopify do ERPNext Cenník
DocType: Healthcare Settings,Default Medical Code Standard,Štandard Štandardu lekárskeho predpisu
DocType: Woocommerce Settings,Tax Account,Daňový účet
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py,Total Paid Amt,Celkom Platené Amt
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: BOM,Website Specifications,Špecifikácie webových stránok
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 zložení schéma, oslobodené a Nil hodnotené"
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ť návštevnosť? <br> Súčasnosť: {0} <br> Chýbajúce: {1}
DocType: Leave Control Panel,Employee (optional),Zamestnanec (voliteľné)
DocType: Purchase Invoice,Supplier Invoice Details,Podrobnosti o faktúre dodávateľa
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Zákazník {0} je vytvorený.
DocType: Company,Default Cost of Goods Sold Account,Štandardné náklady na predaný účet tovaru
apps/erpnext/erpnext/accounts/utils.py,{0} Number {1} already used in account {2},{0} Číslo {1} sa už použilo v účte {2}
DocType: Mode of Payment Account,Default Account,Predvolený účet
DocType: Purchase Invoice,Disable Rounded Total,Zakázať zaokrúhlené celkom
DocType: Contract,Signee,Signee
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/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to group.,Sklady s existujúcou transakciou nie je možné previesť na skupinu.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Both Warehouse must belong to same Company,Oba sklady musia patriť do tej istej spoločnosti
DocType: Maintenance Visit Purpose,Against Document Detail No,Proti dokumentu Detail č
apps/erpnext/erpnext/public/js/queries.js,Please set {0},Nastavte hodnotu {0}
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Najprv vyberte predponu
apps/erpnext/erpnext/config/help.py,Managing Subcontracting,Riadenie subdodávok
DocType: Activity Cost,Projects User,Projekty Užívateľ
DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Variabilná tabuľka výsledkov dodávateľov
DocType: Item Group,Item Group Name,Názov skupiny položiek
DocType: Budget,Applicable on Material Request,Platí pre materiálovú požiadavku
DocType: Support Settings,Search APIs,Vyhľadávacie rozhrania API
DocType: Manufacturing Settings,Overproduction Percentage For Sales Order,Percento nadvýroby Pre zákazku odberateľa
DocType: Purchase Invoice,Supplied Items,Dodávané položky
DocType: Leave Control Panel,Select Employees,Vyberte Zamestnancov
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.js,Create Loan,Vytvoriť úver
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Select interest income account in loan {0},Výber úrokového účtu v úvere {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 pre tento pracovný príkaz prenesené.
DocType: Certification Application,Payment Details,Platobné údaje
apps/erpnext/erpnext/config/settings.py,Printing and Branding,Tlač a branding
DocType: Item Group,HTML / Banner that will show on the top of product list.,"HTML / Banner, ktorý sa zobrazí na vrchole zoznamu produktov."
,Sales Payment Summary,Súhrnné informácie o predajnej platbe
DocType: Salary Component,Is Flexible Benefit,Je flexibilný prínos
DocType: GST Account,IGST Account,Účet IGST
DocType: Shopping Cart Settings,Checkout Settings,Nastavenia služby Checkout
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the customer '%s',Prosím nastavte fiškálny kód pre zákazníka &#39;% s&#39;
DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"** Mesačná distribúcia ** vám pomáha distribuovať rozpočet / cieľ v priebehu mesiacov, ak máte sezónnosť vo vašom podnikaní."
DocType: Guardian,Students,študentov
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Expense Claim {0} already exists for the Vehicle Log,Požiadavka na výdavky {0} už existuje pre záznam vozidla
DocType: Salary Component,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Ak je vybraná, hodnota určená alebo vypočítaná v tomto komponente neprispieva k zisku alebo zrážkam. Jeho hodnota však môže byť označená inými komponentmi, ktoré môžu byť pridané alebo odpočítané."
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter repayment Amount,Zadajte sumu splátok
DocType: Sales Invoice,Is Opening Entry,Otvorenie vstupu
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Set New Release Date,Nastavte nový dátum vydania
DocType: Account,Expenses Included In Valuation,Náklady zahrnuté do ocenenia
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Serial Numbers,Sériové čísla
DocType: Salary Slip,Deductions,odpočty
,Supplier-Wise Sales Analytics,Analytika predaja od dodávateľov
DocType: GSTR 3B Report,February,február
DocType: Appraisal,For Employee,Pre zamestnanca
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Actual Delivery Date,Skutočný dátum dodania
DocType: Sales Partner,Sales Partner Name,Názov obchodného partnera
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Depreciation Start Date is entered as past date,Odpisový riadok {0}: Dátum odpisovania je uvedený ako dátum
DocType: GST HSN Code,Regional,regionálne
DocType: Lead,Lead is an Organization,Vedenie je organizácia
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select Charge Type first,Najskôr vyberte Typ platby
DocType: Purchase Receipt Item,Accepted Quantity,Prijaté množstvo
DocType: Amazon MWS Settings,DE,DE
apps/erpnext/erpnext/templates/pages/product_search.html,Search Results,Výsledky vyhľadávania
DocType: Item Default,Default Buying Cost Center,Stredisko štandardných nákupných nákladov
DocType: Production Plan,Include Non Stock Items,"Zahrnúť položky, ktoré nie sú skladom"
DocType: Student,AB+,AB +
DocType: Upload Attendance,Upload Attendance,Nahrať návštevnosť
DocType: Drug Prescription,Drug Code,Drogového kódexu
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Booking Actual Expenses,"Povoľte, prosím, platné pre skutočné výdavky"
apps/erpnext/erpnext/accounts/report/account_balance/account_balance.js,Chargeble,Chargeble
DocType: Purchase Order,Supply Raw Materials,Dodávky surovín
,Item-wise Price List Rate,Cenová sadzba podľa jednotlivých položiek
DocType: Purchase Invoice Item,BOM,BOM
DocType: Quality Inspection,Readings,čítanie
apps/erpnext/erpnext/accounts/deferred_revenue.py,Error while processing deferred accounting for {0},Chyba pri spracovaní odloženého účtovníctva pre {0}
apps/erpnext/erpnext/regional/italy/utils.py,Please set either the Tax ID or Fiscal Code on Company '%s',Prosím nastavte ID dane alebo fiškálny kód spoločnosti &#39;% s&#39;
apps/erpnext/erpnext/public/js/utils.js,Add Serial No,Pridať sériové číslo
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Avg. Selling Rate,Avg. Predajná sadzba
DocType: Payment Request,payment_url,payment_url
DocType: Delivery Note,Excise Page Number,Číslo stránky spotrebnej dane
,Sales Partner Target Variance based on Item Group,Cieľová odchýlka predajného partnera založená na skupine položiek
DocType: Stock Settings,Naming Series Prefix,Pomenovanie predpony série
DocType: BOM Operation,Workstation,workstation
DocType: Plaid Settings,Synchronize all accounts every hour,Každú hodinu synchronizovať všetky účty
DocType: Employee Boarding Activity,Task Weight,Úloha Hmotnosť
apps/erpnext/erpnext/public/js/utils.js,Annual Billing: {0},Ročná fakturácia: {0}
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Fiskálny rok {0} nie je možné odstrániť. Fiškálny rok {0} je nastavený ako predvolený v globálnych nastaveniach
apps/erpnext/erpnext/public/js/pos/pos.html,No Customers yet!,Zatiaľ nie sú žiadni zákazníci!
DocType: Company,Enable Perpetual Inventory,Povoliť trvalú inventúru
DocType: Opportunity,Potential Sales Deal,Potenciálny predaj
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Excise Invoice,Faktúra spotrebnej dane
DocType: Supplier Scorecard,Supplier Scorecard,Dodávateľ Scorecard
DocType: Travel Itinerary,Travel To,Cestovať do
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Mark Attendance,Označiť účasť
DocType: Shift Type,Determine Check-in and Check-out,Určenie registrácie a odhlásenia
DocType: POS Closing Voucher,Difference,Rozdiel
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Small,malý
DocType: Work Order Item,Work Order Item,Položka objednávky objednávky
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py,Sales and Returns,Predaj a výnosy
DocType: Budget,Monthly Distribution,Mesačná distribúcia
DocType: Quality Action,Quality Action,Akcia kvality
DocType: Work Order,Work-in-Progress Warehouse,Work-in-Progress Warehouse
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Dividends Paid,Platené dividendy
DocType: Program Enrollment Tool,New Academic Year,Nový akademický rok
DocType: Sales Person,Name and Employee ID,Meno a ID zamestnanca
DocType: Subscription,Generate Invoice At Beginning Of Period,Generovanie faktúry na začiatku obdobia
DocType: Item,Minimum Order Qty,Minimálny počet objednávok
DocType: Leave Block List,Block Holidays on important days.,Blokovanie sviatkov v dôležitých dňoch.
apps/erpnext/erpnext/public/js/conf.js,Documentation,dokumentácia
DocType: Item Alternative,Alternative Item Code,Alternatívny kód položky
DocType: Sales Partner,Partner website,Webová stránka partnera
DocType: Loan,Applicant,žiadateľ
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.","Jednotný pre výsledky, ktoré vyžadujú len jeden vstup, výsledok UOM a normálnu hodnotu <br> Zmes pre výsledky, ktoré vyžadujú viac vstupných polí s príslušnými názvami udalostí, výsledok UOM a normálne hodnoty <br> Opisné pre testy, ktoré majú viac výsledných komponentov a zodpovedajúce polia pre zadávanie výsledkov. <br> Zoskupené pre testovacie šablóny, ktoré sú skupinou iných testovacích šablón. <br> Nie Výsledok pre testy bez výsledkov. Taktiež nie je vytvorený žiadny Lab Test. eg. Sub Tests for Grouped results."
apps/erpnext/erpnext/accounts/general_ledger.py,Please mention Round Off Cost Center in Company,Prosím spomeňte Round Off Cost Center v spoločnosti
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Poznámky o doručení {0} musia byť zrušené pred zrušením tejto objednávky odberateľa
DocType: Grant Application,Show on Website,Zobraziť na webových stránkach
DocType: Sales Invoice,Shipping Address Name,Názov dodacej adresy
apps/erpnext/erpnext/healthcare/setup.py,Drug,liek
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is closed,{0} {1} je zatvorené
DocType: Patient,Medical History,História medicíny
DocType: Expense Claim,Expense Taxes and Charges,Dane a poplatky za výdavky
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 fakturácie pred zrušením predplatného alebo predplatného ako nezaplateného
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Installation Note {0} has already been submitted,Poznámka k inštalácii {0} už bola odoslaná
DocType: Patient Relation,Family,rodina
DocType: Work Order Operation,Updated via 'Time Log',Aktualizované prostredníctvom „denníka času“
DocType: Quality Inspection,Sample Size,Veľkosť vzorky
DocType: Bank Transaction,Reference Number,Referenčné číslo
DocType: UOM Conversion Detail,UOM Conversion Detail,Detail konverzie UOM
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Opening Accumulated Depreciation must be less than equal to {0},Otvorené akumulované odpisy musia byť menšie ako {0}
DocType: Antibiotic,Antibiotic Name,Názov antibiotika
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js,"Only the Student Applicant with the status ""Approved"" will be selected in the table below.","V nižšie uvedenej tabuľke bude vybratý len študent, ktorý má status &quot;Schválený&quot;."
DocType: Task,% Progress,Pokrok
DocType: UOM Category,UOM Category,Kategória UOM
apps/erpnext/erpnext/config/help.py,Publish Items on Website,Publikovanie položiek na webovej stránke
DocType: Chapter,Meetup Embed HTML,Zoznámenie Vloženie kódu HTML
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.js,Please select Party Type first,Najprv vyberte Typ strany
DocType: Loan,Repayment Start Date,Dátum začiatku splácania
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Not authroized since {0} exceeds limits,"Nie je autorizovaný, pretože {0} prekračuje limity"
DocType: Procedure Prescription,Procedure Created,Postup bol vytvorený
,Serial No Warranty Expiry,Platnosť sériovej záruky nie je platná
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Against Supplier Invoice {0} dated {1},Proti faktúre dodávateľa {0} zo dňa {1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Change POS Profile,Zmena profilu POS
apps/erpnext/erpnext/utilities/activation.py,Create Lead,Vytvoriť olovo
DocType: Shopify Settings,Default Customer,Predvolený zákazník
DocType: Payment Entry Reference,Supplier Invoice No,Faktúra dodávateľa č
DocType: Pricing Rule,Mixed Conditions,Zmiešané podmienky
DocType: Woocommerce Settings,"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".",Toto je predvolené UOM používané pre položky a zákazky odberateľa. Núdzový UOM je &quot;Nos&quot;.
DocType: Payment Request,Mute Email,Vypnúť e-mail
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 2,Položka 2
apps/erpnext/erpnext/config/accounting.py,Tax Withholding rates to be applied on transactions.,"Sadzby zrážkovej dane, ktoré sa majú uplatňovať pri transakciách."
DocType: Dosage Strength,Strength,pevnosť
apps/erpnext/erpnext/stock/stock_ledger.py,{0} units of {1} needed in {2} to complete this transaction.,{0} jednotiek {1} potrebných na {2} na dokončenie tejto transakcie.
DocType: Buying Settings,Backflush Raw Materials of Subcontract Based On,Backflush Surové materiály Subcontract založené na
DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Ak je táto možnosť povolená, pole Nástroj akademického termínu bude povinný v nástroji Zapisovanie do programu."
DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",Pre skupinu študentov založenú na dávke bude študentská šarža overená pre každého študenta zo zápisu do programu.
DocType: Course,Topics,témy
apps/erpnext/erpnext/stock/doctype/item/item.py,Row #{0}: Please set reorder quantity,Riadok # {0}: Nastavte počet objednávok
DocType: Crop Cycle,Linked Location,Prepojené umiestnenie
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Batch number is mandatory for Item {0},Číslo šarže je povinné pre položku {0}
apps/erpnext/erpnext/accounts/party.py,Not permitted for {0},Nie je povolené pre {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is fully billed,{0} {1} je úplne vyfakturované
DocType: Payment Request,Inward,dovnútra
apps/erpnext/erpnext/templates/pages/help.html,See All Articles,Pozri Všetky články
DocType: Bank Reconciliation Detail,Payment Entry,Zadanie platby
DocType: Payment Request,Recipient Message And Payment Details,Správa príjemcu a podrobnosti platby
DocType: Payment Terms Template Detail,Payment Terms Template Detail,Detail šablóny platobných podmienok
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Select Quantity,Vyberte položku Množstvo
DocType: Student Attendance,Student Attendance,Účasť študentov
DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Automaticky nastaviť sériové čísla na základe FIFO
,Available Qty,K dispozícii Množstvo
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invoices based on Filters,Získajte faktúry na základe filtrov
DocType: Operation,Default Workstation,Predvolená pracovná stanica
DocType: Salary Slip,Salary Structure,Mzdová štruktúra
DocType: Products Settings,Enable Attribute Filters,Povoliť filtre atribútov
DocType: Member,Non Profit Member,Neziskový člen
DocType: Material Request Plan Item,Material Request Plan Item,Položka plánu materiálovej požiadavky
DocType: Holiday List,Add to Holidays,Pridať do sviatkov
apps/erpnext/erpnext/controllers/status_updater.py,Limit Crossed,Limit prešiel
DocType: Company,Transactions Annual History,Transakcie Ročná história
DocType: Company,Delete Company Transactions,Odstránenie transakcií spoločnosti
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To State,Do štátu
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Department Stores,Obchodné domy
DocType: Healthcare Service Unit,Inpatient Occupancy,Obsadenosť pacientov
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 účtovania
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please set default customer in Restaurant Settings,Nastavte predvoleného zákazníka v nastaveniach reštaurácie
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py, Group Roll No,Skupinový kotúč č
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please specify a valid Row ID for row {0} in table {1},Zadajte platné ID riadka pre riadok {0} v tabuľke {1}
DocType: Asset Movement,To Employee,Zamestnancovi
DocType: Item,End of Life,Koniec života
DocType: Lab Test Template,Sensitivity,citlivosť
DocType: Territory,Territory Targets,Územné ciele
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ť Opustiť Pridelenie pre nasledovných zamestnancov, pretože záznamy o ich ponechaní už existujú proti nim. {0}"
DocType: Quality Action Resolution,Quality Action Resolution,Rozlíšenie akcie kvality
DocType: Sales Invoice Item,Delivered By Supplier,Dodané Dodávateľom
DocType: Agriculture Analysis Criteria,Plant Analysis,Analýza rastlín
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Expense account is mandatory for item {0},Účet výdavkov je povinný pre položku {0}
,Subcontracted Raw Materials To Be Transferred,"Subdodávky surovín, ktoré sa majú previesť"
DocType: Cashier Closing,Cashier Closing,Zatvorenie pokladníka
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Item {0} has already been returned,Položka {0} už bola vrátená
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 poskytovateľov služieb OIDAR
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Child warehouse exists for this warehouse. You can not delete this warehouse.,Pre tento sklad existuje detský sklad. Tento sklad nie je možné odstrániť.
DocType: Diagnosis,Diagnosis,diagnóza
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,There is no leave period in between {0} and {1},Medzi {0} a {1} nie je žiadna dovolenka.
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}. Bude prekročená o {5}
DocType: Purchase Invoice Item,Asset Location,Umiestnenie majetku
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Please enter Difference Account,Zadajte prosím rozdielny účet
DocType: Journal Entry,Total Credit,Celkový kredit
DocType: Certified Consultant,Name of Consultant,Meno konzultanta
DocType: Driver,License Number,Číslo licencie
DocType: Program Enrollment Tool,Program Enrollment Tool,Program Enrollment Tool
DocType: Amazon MWS Settings,US,US
DocType: Sales Order,Track this Sales Order against any Project,Sledujte túto zákazku odberateľa voči akémukoľvek projektu
DocType: QuickBooks Migrator,Authorization Settings,Nastavenia autorizácie
DocType: Homepage,Products,Produkty
,Profit and Loss Statement,Výkaz ziskov a strát
apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py,Rooms Booked,Izby rezervované
apps/erpnext/erpnext/stock/doctype/item_manufacturer/item_manufacturer.py,Duplicate entry against the item code {0} and manufacturer {1},Duplicitné zadanie kódu položky {0} a výrobcu {1}
DocType: Item Barcode,EAN,EAN
DocType: Purchase Invoice Item,Total Weight,Celková váha
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Travel,Cestovanie
,Stock Ledger,Kniha akcií
DocType: Volunteer,Volunteer Name,Meno dobrovoľníka
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! First 2 digits of GSTIN should match with State number {0}.,Neplatný GSTIN! Prvé 2 číslice GSTIN by sa mali zhodovať so stavovým číslom {0}.
DocType: Quality Inspection,Report Date,Dátum správy
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Create Inter Company Journal Entry,Vytvorte vstup do vnútropodnikového denníka
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Enough Parts to Build,Dostatok dielov na stavbu
DocType: Member,NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Issued Items,Náklady na vydané položky
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Treshold {0}% appears more than once,Prahová hodnota {0}% sa zobrazí viac ako raz
DocType: Chapter,Chapter Members,Poslancov
DocType: Warranty Claim,Service Address,Adresa služby
DocType: Journal Entry,Remark,Poznámka
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 odoslania záznamu ({2} {3})
DocType: Patient Encounter,Encounter Time,Čas stretnutia
DocType: Serial No,Invoice Details,Podrobnosti faktúry
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ť vykonané v rámci skupín, ale položky môžu byť vykonané proti ne-skupinám"
apps/erpnext/erpnext/public/js/pos/pos.html,Stock Items,Skladové položky
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Riadok {0} # Pridelená suma {1} nemôže byť vyššia ako nevyžiadaná suma {2}
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Reqd Qty,Reqd Množstvo
DocType: Vital Signs,Body Temperature,Teplota tela
DocType: Customer Group,Customer Group Name,Názov skupiny zákazníkov
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 dni v období
DocType: Homepage Section,Section Cards,Karty sekcií
apps/erpnext/erpnext/config/selling.py,Rules for adding shipping costs.,Pravidlá pre pridanie prepravných nákladov.
DocType: Item Price,Valid From,Platnosť od
DocType: Travel Itinerary,Preferred Area for Lodging,Preferovaná oblasť pre ubytovanie
DocType: Student Attendance,Absent,neprítomný
DocType: Global Defaults,Hide Currency Symbol,Skryť symbol meny
DocType: Additional Salary,Overwrite Salary Structure Amount,Prepísať výšku mzdy
DocType: Supplier Quotation,Is Subcontracted,Subdodávky
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 výšku úveru {0}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,BOM does not contain any stock item,BOM neobsahuje žiadnu skladovú položku
DocType: Employee Skill Map,Employee Skill Map,Zamestnanecká mapa zručností
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Marketing,marketing
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,"Riadok # {0}: Nie je povolené meniť dodávateľa, pretože objednávka už existuje"
DocType: Item,Maximum sample quantity that can be retained,"Maximálne množstvo vzorky, ktoré možno ponechať"
DocType: Staffing Plan,Total Estimated Budget,Celkový odhadovaný rozpočet
DocType: Supplier Scorecard Scoring Standing,Standing Name,Stály názov
DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Overiť prihlásený kurz pre študentov v študentskej skupine
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 dátume uvoľnenia zamestnanca {1}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,"The total Issue / Transfer quantity {0} in Material Request {1}  \
							cannot be greater than requested quantity {2} for Item {3}",Celkové množstvo / množstvo prevodu {0} v Material Request {1} nemôže byť vyššie ako požadované množstvo {2} pre položku {3}
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js,Please select {0},Vyberte {0}
DocType: Selling Settings,Default Customer Group,Predvolená skupina zákazníkov
DocType: Journal Entry Account,Debit in Company Currency,Debet v mene spoločnosti
DocType: Woocommerce Settings,"The fallback series is ""SO-WOO-"".",Záložná séria je &quot;SO-WOO-&quot;.
DocType: Quality Meeting Agenda,Quality Meeting Agenda,Agenda stretnutia kvality
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
DocType: Cash Flow Mapper,Section Header,Hlavička oddielu
apps/erpnext/erpnext/utilities/user_progress.py,Your Products or Services,Vaše produkty alebo služby
DocType: Crop,Perennial,trvalka
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Freight and Forwarding Charges,Poplatky za prepravu a zasielateľstvo
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Last Purchase Price,Posledná nákupná cena
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Tax Assets,Daňové aktíva
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 je zvolené pravidlo oceňovania pre „sadzbu“, prepíše cenník. Cenová sadzba je konečná sadzba, takže by sa nemala uplatňovať žiadna ďalšia zľava. Preto sa v transakciách, ako je zákazka odberateľa, objednávka atď., Zobrazí v poli „sadzba“ namiesto poľa „cenníka“."
DocType: Share Balance,Share Type,Typ zdieľania
DocType: Agriculture Analysis Criteria,Soil Analysis,Pôdna analýza
DocType: Water Analysis,Water Analysis Criteria,Kritériá analýzy vody
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,Poznámka: Celkový počet pridelených listov {0} by nemal byť menší ako počet schválených listov {1} za dané obdobie
DocType: Salary Component,Deduction,dedukcie
DocType: Accounts Settings,Over Billing Allowance (%),Príspevok nad fakturáciu (%)
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,You cannot restart a Subscription that is not cancelled.,"Nie je možné reštartovať predplatné, ktoré nie je zrušené."
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Employee Advances,Pokroky zamestnancov
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Provisional Profit / Loss (Credit),Dočasný zisk / strata (kredit)
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Public token is missing for this bank,Pre túto banku chýba verejný token
DocType: Employee Tax Exemption Category,Max Exemption Amount,Maximálna čiastka výnimky
DocType: Timesheet,TS-.YYYY.-,TS-.YYYY.-
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,"Rôzne UOM pre položky povedie k nesprávnej hodnote (Total) Net Weight. Uistite sa, že čistá hmotnosť každej položky je v rovnakom UOM."
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Supplier Quotation,Ponuka pre dodávateľa
DocType: Item,Auto re-order,Automatické opätovné objednanie
DocType: Expense Claim,Total Advance Amount,Celková čiastka preddavku
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 zrušenia {1} nemôže byť pred dátumom kontroly {2}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Can only make payment against unbilled {0},Platby je možné vykonať len za nevyfakturované {0}
DocType: BOM,Thumbnail,náhľady
DocType: Production Plan Item,Planned Qty,Plánované množstvo
DocType: Tax Withholding Category,Rates,sadzby
DocType: Asset,Journal Entry for Scrap,Položka žurnálu pre šrot
DocType: GL Entry,Voucher Detail No,Detail poukážky č
apps/erpnext/erpnext/stock/doctype/item/item.py,Variant Based On cannot be changed,Variant Based On nie je možné zmeniť
DocType: Task,Review Date,Dátum kontroly
DocType: Crop,Biennial,dvojročný
DocType: Woocommerce Settings,Endpoints,Endpoints
DocType: Subscription Plan Detail,Plan,plán
DocType: Employee Education,Year of Passing,Rok odovzdania
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Total Tax,Celková daň
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please enter default currency in Company Master,Zadajte predvolenú menu v Master spoločnosti
DocType: Tally Migration,Processed Files,Spracované súbory
DocType: Leave Type,Is Earned Leave,Je zarobená dovolenka
DocType: Support Search Source,Search Term Param Name,Hľadaný výraz Param Názov
DocType: Sales Invoice,Time Sheets,Časové listy
DocType: Installation Note,Installation Time,Čas inštalácie
apps/erpnext/erpnext/config/buying.py,Templates of supplier scorecard variables.,Šablóny premenných dodávateľských kariet.
DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Produkt alebo služba, ktorá sa kupuje, predáva alebo uchováva na sklade."
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Closing (Opening + Total),Zatvorenie (otvorenie + celkom)
DocType: Supplier Scorecard Criteria,Criteria Formula,Kritérium vzorca
apps/erpnext/erpnext/config/support.py,Support Analytics,Podpora Analytics
DocType: Employee,Attendance Device ID (Biometric/RF tag ID),ID dochádzkového zariadenia (ID biometrickej / RF značky)
apps/erpnext/erpnext/config/quality_management.py,Review and Action,Preskúmanie a akcia
DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Ak je účet zmrazený, položky sú povolené pre používateľov s obmedzeným prístupom."
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py,Amount After Depreciation,Suma po odpise
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Master Data,Importovať kmeňové dáta
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} must be active,Musí byť aktívna položka BOM {0}
,GST Sales Register,GST Predajný register
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice Date cannot be greater than Posting Date,Dátum faktúry dodávateľa nemôže byť väčší ako Dátum účtovania
apps/erpnext/erpnext/utilities/activation.py,Manage your orders,Spravujte svoje objednávky
DocType: Supplier Scorecard,Notify Supplier,Informujte dodávateľa
,GSTR-2,GSTR-2
DocType: Sales Invoice,Credit Note Issued,Vydaná kreditná poznámka
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py,This covers all scorecards tied to this Setup,To sa vzťahuje na všetky scorecards viazané na túto inštaláciu
DocType: Payment Order,Payment Order Type,Typ platobného príkazu
DocType: Account,Parent Account,Materský účet
DocType: Maintenance Visit,Unscheduled,neplánované
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Issue Material,Materiál vydania
DocType: Work Order,Use Multi-Level BOM,Použite viacúrovňový kusovník
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Qty for {0},Počet pre {0}
DocType: Salary Slip,Loan Repayment,Splácanie úveru
DocType: Employee Education,Major/Optional Subjects,Hlavné / voliteľné predmety
DocType: Soil Texture,Silt,kal
apps/erpnext/erpnext/config/buying.py,Supplier Addresses And Contacts,Adresy dodávateľov a kontakty
DocType: Bank Guarantee,Bank Guarantee Type,Typ bankovej záruky
DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Ak je táto možnosť zakázaná, pole „Zaokrúhlené celkom“ nebude v žiadnej transakcii viditeľné"
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.py,Please setup a default bank account for company {0},Nastavte predvolený bankový účet pre spoločnosť {0}
DocType: Pricing Rule,Min Amt,Min Amt
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js,This is a root healthcare service unit and cannot be edited.,Toto je základná služba zdravotnej starostlivosti a nemôže byť upravovaná.
apps/erpnext/erpnext/regional/italy/setup.py,Set this if the customer is a Public Administration company.,"Nastavte, ak je zákazník verejnoprávnou spoločnosťou."
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Max benefits should be greater than zero to dispense benefits,"Max dávky by mali byť väčšie ako nula, aby sa dávky vyplácali"
DocType: Production Plan Item,Planned Start Date,Dátum plánovaného začiatku
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Maintenance,Údržba majetku
DocType: Lead,Interested,záujem
DocType: Purchase Invoice,Net Total (Company Currency),Čistý súčet (mena spoločnosti)
DocType: Salary Component,Depends on Payment Days,Závisí od Platobných dní
DocType: Subscription,Taxes,dane
DocType: Bank Account,Bank Account,Bankový účet
DocType: Homepage Section,Section HTML,Časť HTML
DocType: Sales Invoice,Packed Items,Balené položky
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,New {0} pricing rules are created,Vytvorili sa nové pravidlá tvorby cien {0}
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Achieved ({}),Dosiahnuté ({})
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Investment Banking,Investičné bankovníctvo
DocType: Contract Template,Contract Terms and Conditions,Zmluvné podmienky
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Fetch Data,Načítať údaje
DocType: Stock Settings,Default Item Group,Predvolená skupina položiek
DocType: Sales Invoice Timesheet,Billing Hours,Fakturačné hodiny
apps/erpnext/erpnext/education/doctype/student_leave_application/student_leave_application.py,Leave application {0} already exists against the student {1},Proti študentovi {0} už existuje aplikácia {0}
DocType: Pricing Rule,Margin Type,Typ okraja
DocType: Purchase Invoice Item,Rejected Serial No,Odmietnuté sériové číslo
DocType: Stock Reconciliation Item,Current Amount,Aktuálna suma
apps/erpnext/erpnext/config/retail.py,Setup default values for POS Invoices,Nastavenie predvolených hodnôt pre POS faktúry
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost as on,Náklady na
apps/erpnext/erpnext/config/projects.py,Project Update.,Aktualizácia projektu.
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root Type is mandatory,Typ koreňa je povinný
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Authentication Failed,Overenie zlyhalo
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ť výmenný kurz pre {0} až {1} pre kľúčový dátum {2}. Vytvorte záznam meny Exchange manuálne
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Billed,{0}% Fakturované
DocType: Purchase Invoice,Overdue,oneskorený
DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Množstvo položky získanej po výrobe / opätovnom zabalení z daného množstva surovín
DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Otvorenie položky Nástroj na vytvorenie faktúry
DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
DocType: Bank Reconciliation,Include POS Transactions,Zahrnúť transakcie POS
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,No Employee found for the given employee field value. '{}': {},Žiadny zamestnanec zistený pre danú hodnotu zamestnaneckého poľa. &#39;{}&#39;: {}
DocType: Payment Entry,Received Amount (Company Currency),Prijatá čiastka (mena spoločnosti)
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full, did not save","LocalStorage je plná, neuložila"
DocType: Chapter Member,Chapter Member,Člen kapitoly
DocType: Certified Consultant,Certification Validity,Platnosť certifikácie
DocType: Share Transfer,Asset Account,Účet aktív
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Suplier,suplier
DocType: POS Closing Voucher Details,POS Closing Voucher Details,Podrobnosti o záverečnom poukaze POS
DocType: Patient Medical Record,HLC-PMR-.YYYY.-,HLC-PMR-.YYYY.-
DocType: Delivery Settings,Delivery Settings,Nastavenia doručenia
DocType: Email Digest,Receivables,pohľadávky
DocType: Crop,Annual,Výročný
DocType: Item Tax Template Detail,Tax Rate,Sadzba dane
DocType: Patient Encounter,Medical Coding,Lekárske kódovanie
DocType: Purchase Invoice,Total Quantity,Celkové množstvo
DocType: Asset,Comprehensive Insurance,Komplexné poistenie
DocType: Purchase Invoice Item,Quantity and Rate,Množstvo a rýchlosť
DocType: Employee Benefit Claim,Max Amount Eligible,Max
DocType: Salary Slip,Employee Loan,Zamestnanecký úver
DocType: Payment Entry,Account Paid To,Platba na účet
DocType: Lab Test Template,Single,jednoposteľová
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Customer required for 'Customerwise Discount',Zákazník vyžadovaný pre službu „Customerwise Discount“
DocType: Purchase Invoice,Advance Payments,Zálohové platby
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
				Item {0} is added with and without Ensure Delivery by \
				Serial No.","Nie je možné zabezpečiť dodanie sériovým číslom, pretože {0} je pridané a bez zaistenia dodania"
DocType: Inpatient Record,Discharge Date,Dátum vybitia
,Open Work Orders,Otvorte pracovné príkazy
DocType: Crop Cycle,List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,"Zoznam chorôb zistených na poli. Po výbere sa automaticky pridá zoznam úloh, ktoré sa majú s chorobou zaoberať"
DocType: SMS Center,All Lead (Open),Všetky elektródy (otvorené)
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,No Student Groups created.,Neboli vytvorené žiadne študentské skupiny.
apps/erpnext/erpnext/utilities/transaction_base.py,Duplicate row {0} with same {1},Duplikovať riadok {0} s rovnakým {1}
DocType: Employee,Salary Details,Podrobnosti o plate
DocType: Employee Checkin,Exit Grace Period Consequence,Ukončenie následku Grace Period
DocType: Bank Statement Transaction Invoice Item,Invoice,faktúra
DocType: Special Test Items,Particulars,podrobnosti
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Please set filter based on Item or Warehouse,Nastavte filter na základe položky alebo skladu
DocType: Bank Statement Transaction Invoice Item,Outstanding Amount,Nesplatená suma
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py,Transactions can only be deleted by the creator of the Company,Transakcie môže vymazať iba tvorca spoločnosti
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Pre položky „Produktový balík“ sa bude skladovať z skladu, sériového čísla a šarže č. Z tabuľky „Zoznam obalov“. Ak sú skladové a šaržové číslo rovnaké pre všetky položky balenia pre akúkoľvek položku „Produktový balík“, tieto hodnoty sa môžu zadať do hlavnej tabuľky položiek, hodnoty sa skopírujú do tabuľky „Zoznam obalov“."
DocType: Lab Test,Submitted Date,Dátum predloženia
DocType: Delivery Settings,Send with Attachment,Odoslať s prílohou
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ť vygenerovaný len z predloženého dokumentu
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Account {0} does not exists,Účet {0} neexistuje
DocType: BOM Item,BOM No,Číslo kusovníka č
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Avg Daily Outgoing,Priem. Den
DocType: Patient,Allergies,alergie
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order/Quot %,Objednávka / cena%
DocType: Delivery Note,Transporter Info,Transporter Info
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 „Všetky hodnotiace skupiny“
DocType: Leave Encashment,Payroll,Mzda
DocType: POS Closing Voucher,Expense Amount,Suma výdavkov
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Received On,Prijaté Zapnuté
DocType: Travel Itinerary,Flight,Let
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Dane a poplatky za pristátie
apps/erpnext/erpnext/hr/utils.py,More than one selection for {0} not allowed,Viac ako jeden výber pre {0} nie je povolený
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Equity,Čistá zmena vlastného imania
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Leaves has been granted sucessfully,Listy boli udelené úspešne
DocType: Loyalty Point Entry,Expiry Date,Dátum spotreby
DocType: Task,Working,pracovné
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}.
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. Podrobnosti nájdete v časovej osi nižšie
DocType: Material Request,Requested For,Požadované pre
DocType: SMS Center,All Sales Person,Všetka predajná osoba
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set default account in Salary Component {0},Nastavte predvolený účet v zložke Plat {0}
apps/erpnext/erpnext/www/all-products/not_found.html,No products found,Nenašli sa žiadne produkty
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Vyhradené množstvo na výrobu: Množstvo surovín na výrobu výrobných položiek.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Optional. This setting will be used to filter in various transactions.,Voliteľné. Toto nastavenie sa použije na filtrovanie v rôznych transakciách.
DocType: Stock Entry,Target Warehouse Address,Adresa cieľového skladu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Outward taxable supplies(zero rated),Zdaniteľné dodávky (nulový rating)
DocType: Sales Invoice,Customer Address,Adresa zákazníka
DocType: Leave Allocation,HR-LAL-.YYYY.-,HR-LAL-.YYYY.-
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Asset {0} does not belong to company {1},Asset {0} nepatrí spoločnosti {1}
apps/erpnext/erpnext/utilities/user_progress.py,Room Capacity,Kapacita izby
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select a batch,Vyberte dávku
apps/erpnext/erpnext/stock/doctype/item/item.js,Select Attribute Values,Vyberte hodnoty atribútu
DocType: Cheque Print Template,Signatory Position,Pozícia signatára
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}: Pre účet pohľadávok / záväzkov {1} sa vyžaduje typ strany a strana
apps/erpnext/erpnext/config/manufacturing.py,Production,výroba
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup post company fixtures,Nepodarilo sa nastaviť príslušenstvo spoločnosti Post
DocType: Purchase Invoice Item,Enable Deferred Expense,Povoliť odložené výdavky
DocType: Purchase Order,Customer Contact Email,Kontaktný e-mail zákazníka
DocType: Clinical Procedure Template,Collection Details,Podrobnosti o zbierke
DocType: Stock Entry Detail,Stock Entry Child,Sklad Vstupné dieťa
DocType: Request for Quotation Supplier,No Quote,Žiadna cenová ponuka
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Sorry, Serial Nos cannot be merged","Ľutujeme, sériové čísla nie je možné zlúčiť"
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_dashboard.py,This is based on transactions against this Sales Person. See timeline below for details,To je založené na transakciách voči tejto osobe. Podrobnosti nájdete v časovej osi nižšie
DocType: Course Content,Quiz,kvíz
DocType: Sales Invoice Item,Delivered Qty,Dodané množstvo
DocType: Material Request Plan Item,Minimum Order Quantity,Minimálna objednávka
DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Upozorniť objednávky
DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,"Úloha, ktorá umožňuje predkladať transakcie, ktoré presahujú stanovený limit."
DocType: Employee Boarding Activity,Activity Name,Názov aktivity
DocType: Item Barcode,UPC-A,UPC-A
DocType: Shopify Webhook Detail,Shopify Webhook Detail,Shopify Webhook Detail
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Reconcile this account,Zosúladiť tento účet
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Variant Of,Variant Of
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Target warehouse is mandatory for row {0},Cieľový sklad je povinný pre riadok {0}
apps/erpnext/erpnext/config/support.py,Warranty,záruka
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ID Guardian2
DocType: Expense Claim Detail,Expense Claim Type,Typ nároku na výdavky
DocType: Email Digest,Bank Balance,Bankový zostatok
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.",Cenové pravidlo sa používa na prepísanie Cenníka / definovanie percentuálneho podielu na základe niektorých kritérií.
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Customer Group is Required in POS Profile,Zákaznícka skupina je vyžadovaná v POS profile
DocType: Authorization Rule,Applicable To (Employee),Platné pre (zamestnanec)
DocType: Tally Migration,Day Book Data,Údaje o dennej knihe
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py,Gross Profit / Loss,Hrubý zisk / strata
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Credit Note Amount,Suma kreditnej sumy
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Payment,platba
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Capacity Planning Error,Chyba plánovania kapacity
DocType: Supplier,Prevent POs,Zabrániť organizáciám výrobcov
DocType: QuickBooks Migrator,Authorization Endpoint,Koncový bod autorizácie
DocType: Payment Gateway Account,Payment Gateway Account,Účet platobnej brány
,BOM Variance Report,Správa o rozpise kusovníka
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 zvyšok svojej organizácie ako svojich používateľov. Môžete tiež pridať pozývajúcich zákazníkov do vášho portálu ich pridaním z kontaktov
DocType: Training Event,Employee Emails,Zamestnanecké e-maily
DocType: Travel Request,Any other details,Ďalšie podrobnosti
DocType: Patient,Inpatient Status,Stav pacienta
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Repayment Entry,Založenie vstupu
apps/erpnext/erpnext/hr/utils.py,A {0} exists between {1} and {2} (,{0} existuje medzi {1} a {2} (
DocType: BOM,Scrap,šrot
DocType: Clinical Procedure,Clinical Procedure,Klinický postup
DocType: Supplier,Hold Type,Typ podržania
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Day Book Data,Spracujte údaje dennej knihy
DocType: Fee Validity,Fee Validity,Platnosť poplatku
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Vytvoriť poplatky
DocType: Cheque Print Template,Date Settings,Nastavenia dátumu
DocType: BOM Operation,Operation Time,Prevádzkový čas
DocType: Asset,Value After Depreciation,Hodnota po odpise
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Remaining,zostávajúce
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Lead Count,Počet tipov
apps/erpnext/erpnext/public/js/setup_wizard.js,The name of your company for which you are setting up this system.,"Názov vašej spoločnosti, pre ktorú tento systém nastavujete."
DocType: Serial No,Out of AMC,Z AMC
DocType: Job Opening,"Job profile, qualifications required etc.","Profil práce, požadované kvalifikácie atď."
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Ship To State,Loď do štátu
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: Opportunity Item,Basic Rate,Základná sadzba
DocType: Compensatory Leave Request,Work End Date,Dátum ukončenia práce
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Request for Raw Materials,Žiadosť o suroviny
apps/erpnext/erpnext/config/quality_management.py,Quality Goal.,Cieľ kvality.
apps/erpnext/erpnext/templates/pages/projects.js,Show Open,Zobraziť otvorené
DocType: Item Attribute,Attribute Name,Názov atribútu
apps/erpnext/erpnext/config/non_profit.py,Donor Type information.,Informácie o type darcu.
DocType: Supplier,Is Transporter,Je Transporter
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: Loan Type,Maximum Loan Amount,Maximálna výška úveru
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Email not found in default contact,E-mail sa nenašiel v predvolenom kontakte
DocType: Hotel Room Reservation,Booked,rezervovaný
DocType: Maintenance Visit,Partially Completed,Čiastočne dokončené
DocType: Quality Procedure Process,Process Description,Popis procesu
DocType: Company,Default Employee Advance Account,Predvolený účet zamestnanca
DocType: Leave Type,Allow Negative Balance,Povoliť záporný zostatok
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Assessment Plan Name,Názov plánu hodnotenia
DocType: Supplier,Default Payment Terms Template,Predvolená šablóna platobných podmienok
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Add more items or open full form,Pridajte viac položiek alebo otvorte celý formulár
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,Work Summary for {0},Zhrnutie práce pre {0}
DocType: Academic Term,Academic Term,Akademický termín
DocType: Pricing Rule,Quantity and Amount,Množstvo a množstvo
DocType: Stock Entry,Target Warehouse Name,Názov cieľového skladu
DocType: Employee Tax Exemption Declaration Category,Maximum Exempted Amount,Maximálna povolená čiastka
DocType: Stock Settings,Sample Retention Warehouse,Vzorový skladový sklad
DocType: Pricing Rule,Discount Percentage,Percento zľavy
DocType: Company,Company Description,Popis firmy
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 pre žiadne položky.
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Item {1},Sériové číslo {0} nepatrí do položky {1}
DocType: Work Order,Scrap Warehouse,Skladový sklad
apps/erpnext/erpnext/config/non_profit.py,Chapter information.,Informácie o kapitole.
apps/erpnext/erpnext/hr/utils.py,) for {0},) pre {0}
DocType: Sales Invoice Item,References,Referencie
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Reserved Qty,Vyhradené množstvo
DocType: Shift Assignment,Shift Type,Typ posunu
DocType: Delivery Stop,Delivery Stop,Stop doručenia
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,No Result to submit,Žiadny výsledok na odoslanie
DocType: Loyalty Program,Redemption,vykúpenie
DocType: Material Request,Transferred,prevedená
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} has fee validity till {1},{0} má platnosť do {1}
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,All Student Admissions,Všetky študentské vstupné
DocType: Travel Request,Address of Organizer,Adresa organizátora
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Values of exempt, nil rated and non-GST inward supplies","Hodnoty vnútorných dodávok oslobodených, nulových a iných ako GST"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Údržba Návšteva {0} musí byť zrušená pred zrušením tejto zákazky odberateľa
DocType: Quotation Item,Stock Balance,Stav zásob
DocType: Delivery Note Item,Available Qty at From Warehouse,K dispozícii na sklade v sklade
DocType: Stock Entry,Repack,prebaliť
DocType: UOM,Must be Whole Number,Musí to byť celé číslo
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Credit limit has been crossed for customer {0} ({1}/{2}),Kreditný limit bol prekročený pre zákazníka {0} ({1} / {2})
apps/erpnext/erpnext/accounts/page/pos/pos.js,Submitted orders can not be deleted,Odoslané objednávky nie je možné vymazať
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html,Hello,Ahoj
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,Activity Cost exists for Employee {0} against Activity Type - {1},Náklady na aktivitu existujú pre zamestnanca {0} proti typu aktivity - {1}
DocType: Request for Quotation Item,Request for Quotation Item,Žiadosť o položku ponuky
apps/erpnext/erpnext/accounts/doctype/item_tax_template/item_tax_template.py,{0} entered twice in Item Tax,{0} zadané dvakrát v položke Daň za položku
DocType: Additional Salary,Deduct Full Tax on Selected Payroll Date,Odpočítanie úplnej dane z vybraného mzdového dátumu
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Last carbon check date cannot be a future date,Posledný dátum kontroly uhlia nemôže byť budúcim dátumom
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Select change amount account,Vyberte účet čiastky zmeny
DocType: Support Settings,Forum Posts,Fórum Príspevky
DocType: Timesheet Detail,Expected Hrs,Predpokladané hodiny
DocType: Subscription Plan,Payment Plan,Platobný plán
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Earliest,najstaršie
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Bank account '{0}' has been synchronized,Bankový účet „{0}“ bol synchronizovaný
DocType: Program Enrollment Tool,Enroll Students,Zapísať študentov
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customer Revenue,Opakujte príjmy zákazníka
DocType: Company,Date of Commencement,Dátum začatia
DocType: Bank,Bank Name,Meno banky
DocType: GSTR 3B Report,December,December
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ť menší ako platný dátum
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,This is based on the attendance of this Employee,To je založené na účasti tohto zamestnanca
DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Ak je táto možnosť začiarknutá, domovská stránka bude predvolenou skupinou položiek pre webovú stránku"
DocType: Crop,Row Spacing UOM,Rozstup riadkov UOM
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Môžu byť odoslané iba aplikácie Leave Applications so stavom „Schválené“ a „Zamietnuté“
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Importovať hromadne
DocType: Material Request,Terms and Conditions Content,Obchodné podmienky Obsah
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount(Company Currency),Výška objednávky (mena spoločnosti)
DocType: Healthcare Practitioner,Hospital,Nemocnica
,Stock Analytics,Stock Analytics
apps/erpnext/erpnext/controllers/selling_controller.py,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Predajná sadzba pre položku {0} je nižšia ako {1}. Sadzba za predaj by mala byť aspoň {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Application of Funds (Assets),Aplikácia fondov (aktív)
apps/erpnext/erpnext/config/buying.py,Templates of supplier standings.,Šablóny hodnotenia dodávateľov.
DocType: Patient,HLC-PAT-.YYYY.-,HLC-PAT-.YYYY.-
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js,Grant,grant
apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Cenník Nezvolená mena
DocType: Salary Slip,Total in words,Celkový počet slov
DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Ak je táto možnosť povolená, systém automaticky zaúčtuje účtovné položky pre zásoby."
DocType: BOM Item,BOM Item,Položka kusovníka
DocType: Maintenance Schedule Detail,Scheduled Date,Plánovaný dátum
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please enter Maintaince Details first,Najskôr zadajte podrobnosti o údržbe
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Projected Quantity Formula,Predpokladaný vzorec množstva
DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Dodávateľ Scorecard bodovanie Stály
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 spôsobu platby {1}
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of previous claimed\
			amount",Maximálna dávka zamestnanca {0} presahuje {1} sumou {2} z predchádzajúcej nárokovanej sumy
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 možnosť „Vľavo“, pretože tento zamestnanec v súčasnosti podáva správy tomuto zamestnancovi:"
DocType: BOM Explosion Item,Source Warehouse,Zdrojový sklad
apps/erpnext/erpnext/utilities/user_progress.py,Add Users,Pridať používateľov
DocType: Exotel Settings,Exotel Settings,Nastavenia Exotelu
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Payment Tems,Platobné Tems
DocType: SMS Center,All Sales Partner Contact,Kontakt pre všetkých obchodných partnerov
apps/erpnext/erpnext/controllers/trends.py,Total(Amt),Total (Amt)
DocType: Bank Statement Transaction Invoice Item,Payment Description,Popis platby
apps/erpnext/erpnext/accounts/page/pos/pos.js,ZIP Code,PSČ
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js,Accumulated Values,Akumulované hodnoty
DocType: Grading Scale,Intervals,intervaly
apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py,Training Events,Tréningové podujatia
apps/erpnext/erpnext/config/accounting.py,Opening and Closing,Otvorenie a zatvorenie
DocType: Production Plan Item,Quantity and Description,Množstvo a opis
DocType: Payment Entry,Payment Type,Typ platby
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The folio numbers are not matching,Čísla folia sa nezhodujú
DocType: C-Form,ACC-CF-.YYYY.-,ACC-CF-.YYYY.-
apps/erpnext/erpnext/controllers/stock_controller.py,Quality Inspection: {0} is not submitted for the item: {1} in row {2},Kontrola kvality: {0} nie je predložená pre položku: {1} v riadku {2}
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.js,Show {0},Zobraziť {0}
apps/erpnext/erpnext/support/doctype/issue/issue.js,Service Level Agreement Reset.,Reset servisnej zmluvy.
apps/erpnext/erpnext/templates/generators/item/item_configure.js,{0} item found.,{0} nájdená položka.
,Stock Ageing,Starnutie na sklade
DocType: Customer Group,Mention if non-standard receivable account applicable,"Uveďte, či sa uplatňuje neštandardný účet pohľadávok"
,Subcontracted Item To Be Received,Prijatá subdodávaná položka
DocType: Item,Synced With Hub,Synced With Hub
apps/erpnext/erpnext/hr/utils.py,To date can not be less than from date,K dnešnému dňu nemôže byť nižšia ako od dátumu
DocType: Guardian,Work Address,Pracovná adresa
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Total completed qty can not be greater than for quantity,Celkové dokončené množstvo nemôže byť väčšie ako pre množstvo
DocType: POS Item Group,POS Item Group,Skupina POS položiek
DocType: Homepage,Company Description for website homepage,Spoločnosť Popis stránky domovskej stránky
,Delivery Note Trends,Trendy dodacieho listu
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,"Stopped Production Order cannot be cancelled, Unstop it first to cancel",Zastavená výrobná zákazka nemôže byť zrušená
DocType: Share Balance,Current State,Aktuálny stav
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open Item {0},Otvoriť položku {0}
,Batch-Wise Balance History,História dávkových miezd
DocType: Monthly Distribution Percentage,Percentage Allocation,Percento pridelenia
DocType: Vital Signs,One Sided,Jednostranne
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian2,Vzťah s Guardian2
DocType: Asset,Disposal Date,Dátum likvidácie
DocType: Opportunity,Opportunity Type,Typ príležitosti
DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Šablóna mapovania peňažných tokov
DocType: Asset Settings,Depreciation Options,Možnosti odpisov
DocType: Student Admission,Admission Start Date,Dátum začiatku prijatia
DocType: Manufacturing Settings,Update BOM Cost Automatically,Automaticky aktualizovať cenu kusovníka
DocType: Subscription Settings,Subscription Settings,Nastavenia predplatného
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CGST Amount,CGST Suma
DocType: Amazon MWS Settings,Seller ID,ID predávajúceho
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,'To Case No.' cannot be less than 'From Case No.',„K prípadu č.“ nemôže byť nižšia ako „Od prípadu č.“
DocType: Fee Schedule,EDU-FSH-.YYYY.-,EDU-FSH-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Zlúčenie je možné len vtedy, ak sú v oboch záznamoch rovnaké vlastnosti. Je skupina, typ koreňa, spoločnosť"
DocType: SMS Log,SMS Log,SMS Log
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please specify either Quantity or Valuation Rate or both,Uveďte buď Množstvo alebo Miera ocenenia alebo oboje
DocType: Salary Component,Amount based on formula,Množstvo na základe vzorca
apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Povoliť automatické opätovné objednanie
DocType: Clinical Procedure Item,Transfer Qty,Transfer Qty
apps/erpnext/erpnext/setup/doctype/company/company.js,Cost Centers,Nákladové strediská
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/hr/doctype/salary_slip/salary_slip.py,Error in formula or condition: {0},Chyba vo vzorci alebo podmienke: {0}
apps/erpnext/erpnext/controllers/accounts_controller.py,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Ak chcete zahrnúť daň v riadku {0} do položky Item rate, musia byť zahrnuté aj dane v riadkoch {1}"
,Trial Balance (Simple),Skúšobný zostatok (jednoduchý)
DocType: Purchase Order,Customer Contact,Kontakt so zákazníkom
DocType: Marketplace Settings,Registered,registrovaný
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Gross Purchase Amount is mandatory,Hrubá suma nákupu je povinná
DocType: Fee Structure,Components,súčasti
DocType: Pricing Rule,Promotional Scheme,Propagačná schéma
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}
DocType: Quotation Item,Against Doctype,Proti Doctype
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Total flexible benefit component amount {0} should not be less than max benefits {1},Celková suma flexibilnej dávky {0} by nemala byť nižšia ako maximálna hodnota {1}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From GSTIN,Od spoločnosti GSTIN
DocType: Sales Invoice,Return Against Sales Invoice,Návrat proti predajnej faktúre
DocType: Item Variant Settings,Rename Attribute Value in Item Attribute.,Premenovať hodnotu atribútu v atribúte položky.
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,V poradí na aktualizáciu najnovšej ceny vo všetkých kusovníkoch. Môže to trvať niekoľko minút.
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select a warehouse,Vyberte sklad
DocType: Purchase Invoice Item,Weight UOM,Hmotnosť UOM
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Accounts Payable Summary,Zhrnutie splatných účtov
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Order {1},{0} proti zákazke odberateľa {1}
DocType: Payroll Employee Detail,Payroll Employee Detail,Detail mzdového zamestnanca
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Admission and Enrollment,Prijatie a zápis
DocType: Budget Account,Budget Amount,Výška rozpočtu
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py,Account {0} does not match with Company {1} in Mode of Account: {2},Účet {0} sa nezhoduje so spoločnosťou {1} v režime účtu: {2}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Please enter Receipt Document,Zadajte doklad o prijatí
DocType: Naming Series,Change the starting / current sequence number of an existing series.,Zmeňte počiatočné / aktuálne poradové číslo existujúcej série.
apps/erpnext/erpnext/config/hr.py,Employee Lifecycle,Životný cyklus zamestnancov
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Quantity must be less than quantity {0},Pre množstvo musí byť menšie ako množstvo {0}
DocType: Assessment Plan,Assessment Plan,Plán hodnotenia
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js,Warranty Claim,Žiadosť o reklamáciu
DocType: Company,Date of Incorporation,Dátum začlenenia
DocType: Asset,Double Declining Balance,Dvojitý klesajúci zostatok
apps/erpnext/erpnext/erpnext_integrations/connectors/shopify_connection.py,Tax Account not specified for Shopify Tax {0},Pre službu Shopify Tax {0} nie je uvedený daňový účet
DocType: Payroll Entry,Validate Attendance,Overiť účasť
DocType: Lab Test,LP-,LP-
DocType: POS Customer Group,POS Customer Group,POS Customer Group
,Qty to Deliver,Množstvo na dodanie
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} is required,Vyžaduje sa fiškálny rok {0}
DocType: HR Settings,Employee Records to be created by,"Záznamy o zamestnancoch, ktoré má vytvoriť"
DocType: Depreciation Schedule,Depreciation Amount,Výška odpisu
DocType: Sales Order Item,Gross Profit,Hrubý zisk
DocType: Quality Inspection,Item Serial No,Položka Sériové číslo
DocType: Asset,Insurer,poisťovateľ
DocType: Employee Checkin,OUT,VON
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Buying Amount,Nákupná suma
DocType: Asset Maintenance Task,Certificate Required,Požadovaný certifikát
DocType: Retention Bonus,Retention Bonus,Retenčný bonus
DocType: Item,Asset Naming Series,Rad pomenovania aktív
DocType: Healthcare Settings,Laboratory Settings,Laboratórne nastavenia
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Amount of Integrated Tax,Výška integrovanej dane
DocType: Branch,Branch,vetva
DocType: Request for Quotation Item,Required Date,Požadovaný dátum
DocType: Cashier Closing,Returns,výnos
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Negotiation/Review,Vyjednávanie / Review
,Stock Summary,Zhrnutie zásob
DocType: Bank Reconciliation,From Date,Od dátumu
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"You can claim only an amount of {0}, the rest amount {1} should be in the application \
				as pro-rata component","Môžete požiadať iba o sumu {0}, zvyšok {1} by mal byť v aplikácii ako pro-rata komponent"
DocType: Warehouse,A logical Warehouse against which stock entries are made.,"Logický sklad, proti ktorému sa uskutočňujú záznamy o zásobách."
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Difference Account,Rozdielový účet
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Tým sa predložia platové lístky a vytvorí sa akruálny zápis do denníka. Chcete pokračovať?
DocType: Manufacturer,Manufacturers used in Items,Výrobcovia používajú v položkách
apps/erpnext/erpnext/education/__init__.py,Student {0} does not belong to group {1},Študent {0} nepatrí do skupiny {1}
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Udržujte rovnakú rýchlosť počas celého nákupného cyklu
apps/erpnext/erpnext/setup/doctype/company/company.py,Set default inventory account for perpetual inventory,Nastaviť predvolený účet inventára pre trvalú inventúru
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Pending,Čaká na vytvorenie poplatku
DocType: Accounts Settings,Unlink Advance Payment on Cancelation of Order,Zrušenie preddavku na zrušenie objednávky
apps/erpnext/erpnext/config/crm.py,Visit report for maintenance call.,Navštívte správu o údržbe.
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 čo najlepšie využiť službu ERPNext, odporúčame vám, aby ste nejaký čas strávili a sledovali tieto videá pomoci."
DocType: Fertilizer Content,Fertilizer Content,Obsah hnojív
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot delete Serial No {0}, as it is used in stock transactions","Nie je možné odstrániť sériové číslo {0}, pretože sa používa v transakciách s akciami"
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Charges are updated in Purchase Receipt against each item,Poplatky sa aktualizujú v Potvrdení o kúpe proti každej položke
DocType: Account,Credit,úver
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Download JSON,Stiahnuť JSON
DocType: Sales Invoice,Loyalty Amount,Výška vernosti
DocType: Account,Accounts,účty
DocType: Loyalty Program,Expiry Duration (in days),Trvanie vypršania platnosti (v dňoch)
DocType: Pricing Rule,Product Discount Scheme,Program Zľavy výrobkov
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Creating Company and Importing Chart of Accounts,Vytvorenie spoločnosti a import účtovej osnovy
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Stock Available,Na sklade
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign to Employees,Prideliť zamestnancom
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/accounts/page/pos/pos.js,Not items found,Nenašli sa žiadne položky
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Job card {0} created,Vytvorila sa karta úlohy {0}
DocType: Delivery Note,Is Return,Je návrat
DocType: Soil Analysis Criteria,Soil Analysis Criteria,Kritériá analýzy pôdy
DocType: Quiz Result,Selected Option,Vybratá možnosť
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
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Preview Salary Slip,Preview Plat Slip
DocType: Asset,Assets,Aktíva
DocType: Pricing Rule,Rate or Discount,Sadzba alebo zľava
DocType: Travel Itinerary,Non-Vegetarian,Non-vegetariánska
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Outstanding: {0},Neuhradené celkom: {0}
DocType: Appraisal,For Employee Name,Pre meno zamestnanca
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js,Unknown,nevedno
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Offline Invoices,Synchronizovať offline faktúry
DocType: Practitioner Schedule,Schedule Name,Názov plánu
DocType: Shopify Settings,Shopify Settings,Upraviť nastavenia
DocType: Company,Sales Monthly History,História predaja
apps/erpnext/erpnext/stock/doctype/item/item.py,'Has Serial No' can not be 'Yes' for non-stock item,"„Nemá sériové číslo“ nemôže byť pre položku, ktorá nie je skladom, „áno“"
DocType: Bank Account,GL Account,Účet GL
apps/erpnext/erpnext/regional/report/hsn_wise_summary_of_outward_supplies/hsn_wise_summary_of_outward_supplies.py,Total Taxable Amount,Celková zdaniteľná čiastka
apps/erpnext/erpnext/controllers/item_variant.py,Invalid attribute {0} {1},Neplatný atribút {0} {1}
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: Maintenance Schedule,MAT-MSH-.YYYY.-,MAT-MSH-.YYYY.-
DocType: Student Group Student,Group Roll Number,Číslo skupinového kotúča
DocType: QuickBooks Migrator,Default Shipping Account,Predvolený prepravný účet
DocType: Work Order,MFG-WO-.YYYY.-,MFG-WO-.YYYY.-
DocType: Subscription,Trialling,skúšanie
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid transactions sync error,Chyba synchronizácie s platnými transakciami
DocType: Loyalty Program,Single Tier Program,Program jednotnej úrovne
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Against Loan: {0},Proti úveru: {0}
DocType: Tax Withholding Category,Tax Withholding Rates,Daňové zrážkové sadzby
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Community Forum,Fórum Spoločenstva
apps/erpnext/erpnext/config/integrations.py,Connect your bank accounts to ERPNext,Pripojte svoje bankové účty k ERPNext
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Account Type for {0} must be {1},Typ účtu pre {0} musí byť {1}
DocType: Purchase Receipt Item Supplied,Required Qty,Požadované množstvo
apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py,Please select Completion Date for Completed Repair,Prosím vyberte Dátum ukončenia pre dokončenú opravu
DocType: Clinical Procedure,Medical Department,Lekárske oddelenie
DocType: Share Transfer,From Shareholder,Od akcionára
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Time Slots,Pridať časové úseky
DocType: Sales Order Item,Ensure Delivery Based on Produced Serial No,Zabezpečiť dodávku na základe vyrobeného sériového čísla
apps/erpnext/erpnext/hr/doctype/hr_settings/hr_settings.js,Password policy cannot contain spaces or simultaneous hyphens. The format will be restructured automatically,Politika hesiel nemôže obsahovať medzery ani simultánne pomlčky. Formát sa automaticky reštrukturalizuje
,Eway Bill,Eway Bill
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Stock cannot be updated against Delivery Note {0},Sklad nie je možné aktualizovať oproti dodaciemu listu {0}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Sub Type,Podtyp
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,ERPNext could not find any matching payment entry,ERPNext nenašiel žiadny zodpovedajúci záznam o platbe
DocType: Task,Closing Date,Uzávierka
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Go to the Desktop and start using ERPNext,Prejdite na pracovnú plochu a začnite používať ERPNext
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Duplicate Serial No entered for Item {0},Duplikované sériové číslo zadané pre položku {0}
DocType: Item Price,Packing Unit,Baliaca jednotka
DocType: Travel Request,International,medzinárodný
DocType: Item Tax Template Detail,Item Tax Template Detail,Detail položky šablóny dane
DocType: BOM Update Tool,New BOM,Nový kusovník
DocType: Supplier,Is Internal Supplier,Je interný dodávateľ
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Reject,Odmietnuť
DocType: Salary Slip,net pay info,informácie o čistých mzdách
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Duties and Taxes,Clá a dane
DocType: Appraisal Goal,Score Earned,Získané skóre
DocType: Task,Dependent Tasks,Závislé úlohy
DocType: Tax Rule,Shipping Zipcode,Poštové smerovacie číslo
DocType: Naming Series,Update Series,Aktualizovať sériu
apps/erpnext/erpnext/public/js/setup_wizard.js,"e.g. ""Build tools for builders""",napr.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Prospecting,prieskum
DocType: Bank Statement Transaction Entry,Bank Statement,Výpis z účtu
DocType: Appointment Type,Default Duration,Štandardná doba trvania
apps/erpnext/erpnext/config/buying.py,Default settings for buying transactions.,Predvolené nastavenia pre nákupné transakcie.
DocType: Work Order Operation,Actual Time and Cost,Skutočný čas a náklady
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Evaluation,ohodnotenie
apps/erpnext/erpnext/controllers/accounts_controller.py,Account: {0} with currency: {1} can not be selected,Účet: {0} s menou: {1} nie je možné vybrať
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Lifecycle,Životný cyklus
DocType: Student Sibling,Studying in Same Institute,Štúdium v rovnakom inštitúte
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Course Code: ,Kód kurzu:
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution %,Príspevok%
DocType: Journal Entry,Credit Note,Kreditná poznámka
DocType: Batch,Parent Batch,Rodičovská dávka
DocType: Payment Reconciliation,Get Unreconciled Entries,Získajte nezosúladené záznamy
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Please set the Company,Nastavte spoločnosť
DocType: Lead,Lead Type,Typ elektródy
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Riadok # {0}: Dátum zaúčtovania musí byť rovnaký ako dátum nákupu {1} aktíva {2}
DocType: Payment Entry,Difference Amount (Company Currency),Výška rozdielu (mena spoločnosti)
DocType: Invoice Discounting,Sanctioned,schválený
DocType: Course Enrollment,Course Enrollment,Zápis kurzu
DocType: Item,Supplier Items,Položky dodávateľa
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 konca {0}.
DocType: Sales Order,Not Applicable,Nepoužiteľný
DocType: Support Search Source,Response Options,Možnosti odpovede
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/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Select Difference Account,Vyberte rozdielny účet
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Sales Person,Predajná osoba
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Packing Slip,Balenie Slip
apps/erpnext/erpnext/config/manufacturing.py,Global settings for all manufacturing processes.,Globálne nastavenia pre všetky výrobné procesy.
DocType: Shopify Settings,Customer Group will set to selected group while syncing customers from Shopify,Zákaznícka skupina bude nastavená na vybranú skupinu a zároveň bude synchronizovať zákazníkov zo služby Shopify
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Apply Now,Nainštalovať teraz
DocType: Accounts Settings,Credit Controller,Úverový kontrolór
DocType: BOM,Exploded_items,Exploded_items
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Done,hotový
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Manufacturing Quantity is mandatory,Výrobné množstvo je povinné
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Bypass credit check at Sales Order ,Obísť kontrolu kreditu na zákazke odberateľa
DocType: Bin,Stock Value,Hodnota akcie
apps/erpnext/erpnext/config/hr.py,Employee Tax and Benefits,Zamestnanecká daň a dávky
apps/erpnext/erpnext/config/accounting.py,Tax template for item tax rates.,Šablóna dane pre položky sadzby dane.
apps/erpnext/erpnext/accounts/party.py,{0} {1} is not active,{0} {1} nie je aktívne
DocType: Inpatient Record,O Positive,O Pozitívne
DocType: Training Event,Training Program,Tréningový program
DocType: Cashier Closing Payments,Cashier Closing Payments,Uzávierka platieb
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,The 'From Package No.' field must neither be empty nor it's value less than 1.,„Od balíka č.“ Pole nesmie byť prázdne ani menšie ako 1.
,Purchase Order Trends,Trendy nákupnej objednávky
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Please enter parent cost center,Zadajte rodičovské nákladové stredisko
DocType: Purchase Receipt,Supplier Delivery Note,Dodacia poznámka dodávateľa
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Drug,Vyberte položku Drug
DocType: Support Settings,Post Route Key,Uverejnenie kľúča trasy
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Student Admissions,Vstupné pre študentov
apps/erpnext/erpnext/config/non_profit.py,Memebership Details,Podrobnosti o členstve
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Probation,skúška
,Inactive Sales Items,Neaktívne položky predaja
DocType: Amazon MWS Settings,AU,AU
DocType: Vital Signs,Abdomen,brucho
DocType: HR Settings,Employee Settings,Nastavenia zamestnanca
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Arrear,nedoplatok
apps/erpnext/erpnext/config/buying.py,Supplier Group master.,Dodávateľ Skupina master.
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py,A customer with the same name already exists,Zákazník s rovnakým menom už existuje
DocType: Course Enrollment,Program Enrollment,Registrácia programu
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,"Job Openings for designation {0} already open \
					or hiring completed as per Staffing Plan {1}",Voľné pracovné miesta pre označenie {0} už otvorené alebo prenájom dokončený podľa Personálneho plánu {1}
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Prokurista
DocType: Pricing Rule,Discount on Other Item,Zľava na inú položku
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot Count,Počet dopytov
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Nenašli sa žiadni študenti
DocType: Journal Entry,Bank Entry,Vstup do banky
DocType: Antibiotic,Antibiotic,antibiotikum
DocType: Stock Settings,Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.,"Percentuálny podiel, ktorý môžete dostať alebo dodať viac oproti objednanému množstvu. Napríklad: Ak ste si objednali 100 jednotiek. a vaše Prídavok je 10%, potom máte povolené prijímať 110 jednotiek."
apps/erpnext/erpnext/config/support.py,Support queries from customers.,Podporné dotazy zákazníkov.
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Actual,skutočný
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Material Requests in the above table,Do vyššie uvedenej tabuľky zadajte požiadavky na materiál
DocType: Item Reorder,Item Reorder,Zmena poradia položiek
DocType: Company,Stock Settings,Nastavenia skladu
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No is mandatory,Riadok # {0}: Sériové číslo je povinné
DocType: Homepage Section,Number of columns for this section. 3 cards will be shown per row if you select 3 columns.,"Počet stĺpcov pre túto sekciu. Ak vyberiete 3 stĺpce, na riadok sa zobrazia 3 karty."
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py,Consultations,konzultácie
DocType: Employee Benefit Claim,Claim Benefit For,Využitie nároku
DocType: Fiscal Year,Year Name,Názov roka
DocType: Bank Statement Transaction Entry,Reconciled Transactions,Zosúladené transakcie
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 je možné účtovať viac oproti objednanej sume. Napríklad: Ak je hodnota objednávky pre položku 100 USD a tolerancia je nastavená na 10%, potom môžete účtovať 110 USD."
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ť nadmerné dodanie a nadmernú rezerváciu pre položku {0}, pretože množstvo alebo suma je 0"
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,Opening Balance,Počiatočný zostatok
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,'From Date' must be after 'To Date',„Od dátumu“ musí byť za dátumom „Dátum“
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Total Amount {0},Celková suma {0}
DocType: Employee Skill,Evaluation Date,Dátum vyhodnotenia
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot be Purchase Item also",&quot;Položka poskytovaná zákazníkom&quot; nemôže byť tiež zakúpená
DocType: C-Form Invoice Detail,Grand Total,Úhrn
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žší ako aktuálna nesplatená suma pre zákazníka. Limit kreditu musí byť minimálne {0}
apps/erpnext/erpnext/shopping_cart/cart.py,Only {0} in stock for item {1},Len {0} na sklade pre položku {1}
DocType: Payment Reconciliation,Bank / Cash Account,Bankový / hotovostný účet
DocType: Serial No,Creation Date,Dátum vytvorenia
apps/erpnext/erpnext/manufacturing/report/bom_variance_report/bom_variance_report.py,Finished Good,Dokončené Dobré
DocType: Healthcare Settings,Manage Sample Collection,Spravovať kolekciu vzoriek
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Unable to find DocType {0},Nepodarilo sa nájsť dokument DocType {0}
DocType: Purchase Invoice Item,Item Weight Details,Položka Hmotnosť Podrobnosti
DocType: POS Closing Voucher,Modes of Payment,Spôsoby platby
DocType: Naming Series,Series List for this Transaction,Zoznam sérií pre túto transakciu
DocType: Crop,Produce,vyrobiť
DocType: Woocommerce Settings,API consumer key,Spotrebiteľský kľúč API
DocType: Quality Inspection Reading,Reading 2,Čítanie 2
DocType: Driver,Driving License Categories,Kategórie vodičských preukazov
DocType: Asset Repair,Asset Repair,Oprava aktív
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation,Precenenie výmenného kurzu
DocType: Warehouse,Warehouse Contact Info,Skladové kontaktné informácie
DocType: Request for Quotation Supplier,Request for Quotation Supplier,Žiadosť o dodávateľa ponuky
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Please complete your Plaid API configuration before synchronizing your account,Pred synchronizáciou účtu dokončite konfiguráciu Plaid API
DocType: Travel Request,Costing,rozpočet
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Fixed Assets,Dlhodobý majetok
DocType: Purchase Order,Ref SQ,Ref SQ
DocType: Salary Structure,Total Earning,Celkové zárobky
DocType: Share Balance,From No,Od č
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Faktúra na vyrovnanie platieb
DocType: Purchase Invoice,Taxes and Charges Added,Pridané dane a poplatky
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Zvážte daň alebo poplatok za
DocType: Authorization Rule,Authorized Value,Autorizovaná hodnota
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Received From,Prijaté od
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} does not exist,Sklad {0} neexistuje
DocType: Item Manufacturer,Item Manufacturer,Položka Výrobca
DocType: Sales Invoice,Sales Team,Predajný tím
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,Bundle Qty,Balík Qty
DocType: Purchase Order Item Supplied,Stock UOM,Skladové UOM
DocType: Installation Note,Installation Date,Dátum inštalácie
DocType: Email Digest,New Quotations,Nové ponuky
DocType: Production Plan Item,Ordered Qty,Objednané množstvo
,Minutes to First Response for Issues,Zápisnice k prvej reakcii na problémy
DocType: Vehicle Log,Refuelling Details,Podrobnosti o tankovaní
DocType: Sales Partner,Targets,ciele
DocType: Buying Settings,Settings for Buying Module,Nastavenia modulu Nákup
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Purchase Order {0} is not submitted,Objednávka {0} nie je odoslaná
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Material Request {0} submitted.,Žiadosť o materiál {0} bola odoslaná.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Posting date and posting time is mandatory,Dátum účtovania a čas účtovania je povinný
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,{} of {},{} of {}
DocType: Lab Test Template,Lab Routine,Laboratórna rutina
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Failed. Please check your GoCardless Account for more details,Platba zlyhala. Ďalšie podrobnosti nájdete v účte GoCardless
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Row {0}:Start Date must be before End Date,Riadok {0}: Dátum začiatku musí byť pred dátumom ukončenia
apps/erpnext/erpnext/config/education.py,LMS Activity,Aktivita LMS
DocType: Asset,Next Depreciation Date,Nasledujúci dátum odpisovania
DocType: Healthcare Settings,Appointment Reminder,Pripomienka na vymenovanie
DocType: Cost Center,Cost Center Name,Názov nákladového strediska
DocType: Pricing Rule,Margin Rate or Amount,Miera marže alebo suma
DocType: Healthcare Settings,Clinical Procedure Consumable Item,Klinický postup Spotrebný materiál
DocType: Asset,Manual,Manuálny
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Raw Materials cannot be blank.,Suroviny nemôžu byť prázdne.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please enter Cost Center,Zadajte nákladové stredisko
DocType: Support Search Source,Source DocType,Zdroj DocType
DocType: Assessment Group,Parent Assessment Group,Rodičovská hodnotiaca skupina
DocType: Purchase Invoice Item,Accepted Warehouse,Prijatý sklad
DocType: Sales Invoice Item,Discount and Margin,Zľava a marža
,Student and Guardian Contact Details,Podrobnosti o kontakte študenta a opatrovníka
DocType: Pricing Rule,Buying,nákupy
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Unknown Number,Neznáme číslo
DocType: Student Attendance,Present,prítomný
DocType: Membership,Member Since,Členom od
DocType: Tax Rule,Use for Shopping Cart,Použite pre nákupný košík
DocType: Loan,Loan Account,Úverový účet
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 pre tvorbu zamestnancov ešte neboli vykonané.
DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Minimálna dĺžka medzi jednotlivými rastlinami v poli pre optimálny rast
DocType: Budget,Applicable on Purchase Order,Platí pre objednávku
DocType: Stock Entry,Receive at Warehouse,Prijať v sklade
DocType: Cash Flow Mapping,Is Income Tax Expense,Je daň z príjmov
DocType: Journal Entry,Make Difference Entry,Make Difference Entry
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Total (Credit),Spolu (kredit)
apps/erpnext/erpnext/public/js/setup_wizard.js,The Brand,Značka
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 3,Bod 3
DocType: Purchase Invoice Item,Deferred Expense Account,Účet odložených výdavkov
DocType: Depreciation Schedule,Accumulated Depreciation Amount,Výška akumulovaných odpisov
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}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,No accounting entries for the following warehouses,Žiadne účtovné zápisy pre nasledujúce sklady
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Please save first,Uložte najprv
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Extra Small,Extra malý
DocType: Assessment Group,Assessment Group,Posudzovacia skupina
DocType: Pricing Rule,UOM,UOM
apps/erpnext/erpnext/config/accounting.py,Bills raised by Suppliers.,Účty vznesené dodávateľmi.
DocType: Additional Salary,HR User,Užívateľ HR
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py,Profit for the year,Zisk za rok
DocType: Codification Table,Medical Code,Lekársky zákonník
apps/erpnext/erpnext/config/accounting.py,Update bank payment dates with journals.,Aktualizujte dátumy bankových platieb pomocou časopisov.
apps/erpnext/erpnext/controllers/item_variant.py,The value {0} is already assigned to an exisiting Item {2}.,Hodnota {0} je už priradená existujúcej položke {2}.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Current Assets,Aktuálne aktíva
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} does not belong to company {2},Riadok # {0}: Majetok {1} nepatrí spoločnosti {2}
DocType: Purchase Invoice,Contact Person,Kontaktná osoba
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Batch {2},{0} - {1} nie je prihlásený do dávky {2}
DocType: Holiday List,Holiday List Name,Názov dovolenkového zoznamu
DocType: Water Analysis,Collection Temperature ,Teplota odberu
DocType: Healthcare Settings,Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Spravovať faktúru s termínom odoslania a zrušiť automaticky pre stretnutie pacienta
DocType: Employee Benefit Claim,Claim Date,Dátum nároku
DocType: Supplier,Leave blank if the Supplier is blocked indefinitely,"Ak je dodávateľ zablokovaný na neurčito, ponechajte prázdne"
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Attendance From Date and Attendance To Date is mandatory,Účasť od dátumu a dochádzky je povinná
DocType: Serial No,Out of Warranty,po záruke
apps/erpnext/erpnext/buying/utils.py,Same item cannot be entered multiple times.,Rovnakú položku nie je možné zadať viackrát.
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Select students manually for the Activity based Group,Vyberte študentov manuálne pre skupinu založenú na aktivite
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Series Updated,Séria bola aktualizovaná
DocType: Employee,Date Of Retirement,Dátum odchodu do dôchodku
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Please select Patient,Vyberte položku Pacient
DocType: Asset,Straight Line,Priamka
DocType: Quality Action,Resolutions,rezolúcia
DocType: SMS Log,No of Sent SMS,Počet odoslaných SMS
,GST Itemised Sales Register,GST Položkový predajný register
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Celková suma záloh nesmie byť vyššia ako celková sankcionovaná suma
DocType: Lab Test,Test Name,Názov testu
DocType: Task,Total Billing Amount (via Time Sheet),Celková suma fakturácie (prostredníctvom časového výkazu)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Quotation {0} is cancelled,Ponuka {0} sa zruší
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Clear values,Vymazať hodnoty
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Traceability,sledovateľnosť
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py,Same Company is entered more than once,Rovnaká spoločnosť je zadaná viac ako raz
DocType: Delivery Stop,Contact Name,Kontaktné meno
DocType: Customer,Is Internal Customer,Je interný zákazník
DocType: Purchase Taxes and Charges,Account Head,Vedúci účtu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Lower Income,Nižší príjem
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ť kratší ako dátum ukončenia úlohy {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Customer Service,Služby zákazníkom
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,poplatok
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} does not belong to Item {1},BOM {0} nepatrí do položky {1}
DocType: Daily Work Summary,Daily Work Summary Group,Skupina denných pracovných súhrnov
apps/erpnext/erpnext/config/help.py,Customizing Forms,Prispôsobenie formulárov
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Cancel Material Visit {0} before cancelling this Warranty Claim,Cancel Material Visit {0} pred zrušením tejto Reklamácie
DocType: POS Profile,Ignore Pricing Rule,Ignorovať pravidlo určovania cien
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Food,jedlo
DocType: Lost Reason Detail,Lost Reason Detail,Detail strateného dôvodu
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,The following serial numbers were created: <br> {0},Boli vytvorené nasledujúce sériové čísla: <br> {0}
DocType: Maintenance Visit,Customer Feedback,Spätná väzba od zákazníka
DocType: Serial No,Warranty / AMC Details,Podrobnosti o záruke / AMC
DocType: Issue,Opening Time,Otvaracie hodiny
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,View a list of all the help videos,Zobrazte zoznam všetkých videí pomoci
DocType: Purchase Invoice,Party Account Currency,Mena účtu strany
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 numpad"
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Kritériá plánu hodnotenia
DocType: Products Settings,Item Fields,Polia položky
apps/erpnext/erpnext/config/selling.py,Manage Sales Partners.,Správa obchodných partnerov.
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py,"Cannot declare as lost, because Quotation has been made.","Nedá sa prehlásiť za stratené, pretože bola vykonaná ponuka."
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Tu si môžete udržiavať rodinné údaje ako meno a povolanie rodiča, manžela / manželky a detí"
DocType: Tax Rule,Shipping City,Preprava mesta
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update Items,Aktualizovať položky
,Customer Ledger Summary,Súhrnný prehľad zákazníka
DocType: Inpatient Record,B Positive,B Pozitívne
apps/erpnext/erpnext/config/accounting.py,Accounting journal entries.,Účtovníctvo účtovných zápisov.
DocType: Buying Settings,Purchase Order Required,Požadovaná objednávka
DocType: Program Enrollment Tool,New Student Batch,Nová študentská dávka
DocType: Account,Account Type,Typ účtu
DocType: Terms and Conditions,Applicable Modules,Použiteľné moduly
DocType: Vehicle,Fuel Type,Typ paliva
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Email sent to {0},E-mail odoslaný používateľovi {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Change Release Date,Zmena dátumu vydania
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Default BOM for {0} not found,Predvolený kusovník pre {0} sa nenašiel
,HSN-wise-summary of outward supplies,HSN-múdry súhrn vonkajších dodávok
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py,Appointments and Encounters,Schôdze a stretnutia
DocType: Tax Withholding Category,Tax Withholding Category,Kategória zrážkovej dane
DocType: Agriculture Analysis Criteria,Linked Doctype,Prepojený Doctype
DocType: Account,Cost of Goods Sold,Cena predaného tovaru
DocType: Quality Inspection Reading,Reading 3,Čítanie 3
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Voucher,Skupina podľa kupónu
,Delivered Items To Be Billed,Dodané položky na fakturáciu
DocType: Employee Transfer,Employee Transfer Details,Podrobnosti o prevode zamestnancov
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Registračné čísla spoločnosti pre vašu informáciu. Daňové čísla atď.
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Warehouse {1},Sériové číslo {0} nepatrí do skladu {1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Del,del
apps/erpnext/erpnext/templates/pages/task_info.html,on,na
DocType: Crop,"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Tu môžete definovať všetky úlohy, ktoré je potrebné vykonať pre túto plodinu. Denné pole sa používa na označenie dňa, kedy sa úloha musí vykonať, 1 je prvý deň atď."
DocType: Asset Maintenance Log,Task,úloha
DocType: Naming Series,Help HTML,Pomocník HTML
DocType: Drug Prescription,Dosage by time interval,Dávkovanie podľa časového intervalu
DocType: Batch,Batch Description,Popis dávky
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py,Please set associated account in Tax Withholding Category {0} against Company {1},Nastavte priradený účet v kategórii daňovej zrážky {0} voči spoločnosti {1}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Needs Analysis,Analýza potrieb
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Allocated Leaves,Pridelené listy
DocType: Payment Request,Transaction Details,detaily transakcie
DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Publikovať &quot;Na sklade&quot; alebo &quot;Nie je skladom&quot; na Hub na základe skladom k dispozícii v tomto sklade.
apps/erpnext/erpnext/setup/doctype/company/company.js,Company name not same,Názov spoločnosti nie je rovnaký
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Employee Promotion cannot be submitted before Promotion Date ,Propagácia zamestnanca nemôže byť odoslaná pred dátumom propagácie
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Not allowed to update stock transactions older than {0},Nie je povolené aktualizovať akcie transakcií staršie ako {0}
DocType: Employee Checkin,Employee Checkin,Zamestnanec Checkin
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Start date should be less than end date for Item {0},Dátum začiatku by mal byť nižší ako dátum ukončenia pre položku {0}
apps/erpnext/erpnext/utilities/activation.py,Create customer quotes,Vytvorenie úvodzoviek zákazníkov
DocType: Buying Settings,Buying Settings,Nastavenia nákupu
DocType: Restaurant Menu Item,Restaurant Menu Item,Položka menu reštaurácie
DocType: Appraisal,Calculate Total Score,Vypočítajte celkové skóre
DocType: Issue,Issue Type,Typ problému
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Balance Value,Hodnota zostatku
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Groups,skupiny
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Target warehouse in row {0} must be same as Work Order,Cieľový sklad v riadku {0} musí byť rovnaký ako pracovný príkaz
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Serial Number: {0} is already referenced in Sales Invoice: {1},Sériové číslo: {0} je už uvedené v predajnej faktúre: {1}
DocType: Shopify Settings,"If Shopify not contains a customer in Order, then while syncing Orders, the system will consider default customer for order","Ak Shopify neobsahuje zákazníka v objednávke, potom pri synchronizácii objednávok systém zváži predvoleného zákazníka na objednávku"
DocType: Shopify Settings,Shopify Tax Account,Shopify Daňový účet
apps/erpnext/erpnext/setup/doctype/company/company.js,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,"Uistite sa, že chcete vymazať všetky transakcie pre túto spoločnosť. Vaše kmeňové dáta zostanú také, aké sú. Túto akciu nemožno vrátiť späť."
DocType: Purchase Receipt,Auto Repeat Detail,Detail automatického opakovania
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Please supply the specified items at the best possible rates,"Uveďte, prosím, uvedené položky podľa najlepších možných sadzieb"
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} in row {1},{0} v riadku {1}
DocType: Job Card Time Log,Job Card Time Log,Časový záznam pracovnej karty
DocType: Patient,Patient Demographics,Demografia pacienta
DocType: Share Transfer,To Folio No,Na Folio č
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Operations,Peňažné toky z operácií
DocType: Employee Checkin,Log Type,Typ protokolu
DocType: Stock Settings,Allow Negative Stock,Povoliť zápornú zásobu
DocType: Call Log,Ringing,zvoniaci
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,None of the items have any change in quantity or value.,Žiadna z položiek nemá žiadnu zmenu v množstve alebo hodnote.
DocType: Asset,Purchase Date,Dátum nákupu
DocType: Bank Statement Transaction Settings Item,Bank Statement Transaction Settings Item,Položka Nastavenia bankového výpisu
,BOM Stock Report,Výkaz zásob kusovníka
apps/erpnext/erpnext/public/js/payment/pos_payment.html,Write Off,Vypnite
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 užitočnom živote musí byť nižšia ako suma brutto nákupu
DocType: Employee,Personal Bio,Osobné Bio
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Duplicate Entry. Please check Authorization Rule {0},Duplicitný záznam. Skontrolujte Pravidlo autorizácie {0}
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py,IBAN is not valid,IBAN nie je platný
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}:
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Selling,Štandardný predaj
DocType: Clinical Procedure,Invoiced,fakturovaná
apps/erpnext/erpnext/education/doctype/guardian/guardian.py,User {0} already exists,Používateľ {0} už existuje
DocType: Account,Profit and Loss,Zisk a strata
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Diff Qty,Diff Qty
DocType: Asset Finance Book,Written Down Value,Napísaná hodnota dole
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Opening Balance Equity,Otvorenie vlastného imania
DocType: GSTR 3B Report,April,apríl
DocType: Supplier,Credit Limit,Úverový limit
apps/erpnext/erpnext/public/js/setup_wizard.js,Distribution,distribúcia
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,debit_note_amt,debit_note_amt
DocType: Quality Inspection,Inspected By,Kontrolované By
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get Items from Product Bundle,Získajte položky z produktového balíka
DocType: Employee Benefit Claim,Employee Benefit Claim,Nárok na zamestnanecké požitky
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date not mentioned,Dátum neuvádzania
DocType: Company,Default Receivable Account,Default Default Account
DocType: Location,Check if it is a hydroponic unit,"Skontrolujte, či sa jedná o hydroponickú jednotku"
DocType: Student Guardian,Others,iní
DocType: Patient Appointment,Patient Appointment,Vymenovanie pacienta
DocType: Inpatient Record,AB Positive,AB Pozitívne
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py,Depreciation Date,Dátum odpisovania
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Upcoming Calendar Events,Nadchádzajúce udalosti kalendára
apps/erpnext/erpnext/utilities/activation.py,Create Student Batch,Vytvoriť študentskú dávku
DocType: Travel Itinerary,Travel Advance Required,Vyžaduje sa cestovanie Advance
apps/erpnext/erpnext/config/manufacturing.py,Orders released for production.,Objednávky uvoľnené na výrobu.
DocType: Loyalty Program,Collection Rules,Pravidlá zhromažďovania
DocType: Asset Settings,Disable CWIP Accounting,Vypnúť CWIP účtovníctvo
DocType: Homepage Section,Section Based On,Sekcia založená na
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,{0} already allocated for Employee {1} for period {2} to {3},{0} už pridelené pre zamestnanca {1} na obdobie {2} až {3}
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0}: From Time and To Time of {1} is overlapping with {2},Riadok {0}: Od času a do času {1} sa prekrýva s {2}
DocType: Vital Signs,Very Hyper,Veľmi hyper
apps/erpnext/erpnext/public/js/setup_wizard.js,Select the nature of your business.,Vyberte si charakter svojho podnikania.
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Only .csv and .xlsx files are supported currently,V súčasnosti sú podporované iba súbory .csv a .xlsx
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Are you sure you want to make debit note?,Naozaj chcete vykonať debetné upozornenie?
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Please select month and year,Vyberte mesiac a rok
DocType: Service Level,Default Priority,Predvolená priorita
DocType: Student Log,Student Log,Študentský denník
DocType: Shopping Cart Settings,Enable Checkout,Povoliť službu Checkout
apps/erpnext/erpnext/config/settings.py,Human Resources,Ľudské zdroje
DocType: Stock Entry,Total Value Difference (Out - In),Rozdiel celkovej hodnoty (mimo)
DocType: Work Order Operation,Actual End Time,Skutočný čas ukončenia
apps/erpnext/erpnext/config/help.py,Setting up Taxes,Nastavenie daní
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Investing,Čisté peňažné prostriedky z investícií
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Accounting Ledger,Účtovná kniha
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,Item Group Tree,Strom skupiny položiek
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,'Total',", Celkom &#39;"
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 1,Položka 1
apps/erpnext/erpnext/utilities/user_progress.py,Student Batches,Študentské dávky
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Pripojte súbor .csv s dvoma stĺpcami, jeden pre starý názov a druhý pre nový názov"
DocType: Bank Statement Transaction Payment Item,outstanding_amount,nesplatená suma
apps/erpnext/erpnext/healthcare/setup.py,Susceptible,vnímavý
DocType: Purchase Invoice,Total (Company Currency),Spolu (Mena spoločnosti)
DocType: Item,Website Content,Obsah webových stránok
DocType: Driver,Driving License Category,Kategória vodičského preukazu
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
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Make Payment,Vykonať platbu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Typ strany je povinný
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The fields From Shareholder and To Shareholder cannot be blank,Polia Od akcionára a akcionára nemôžu byť prázdne
DocType: Customer Feedback,Quality Management,Manažment kvality
DocType: BOM,Transfer Material Against,Prenos materiálu proti
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,Temporarily on Hold,Dočasne zapnuté
apps/erpnext/erpnext/config/integrations.py,Connect Shopify with ERPNext,Pripojiť Shopify s ERPNext
DocType: Homepage Section Card,Subtitle,podtitul
DocType: Soil Texture,Loam,hlina
DocType: BOM,Scrap Material Cost(Company Currency),Cena materiálu šrotu (mena spoločnosti)
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Delivery Note {0} must not be submitted,Upozornenie o doručení {0} sa nesmie odoslať
DocType: Task,Actual Start Date (via Time Sheet),Skutočný dátum začiatku (prostredníctvom výkazu)
DocType: Sales Order,Delivery Date,Dátum doručenia
,Item Shortage Report,Správa o nedostatku položky
DocType: Subscription Plan,Price Determination,Stanovenie ceny
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Retail & Wholesale,Maloobchod a veľkoobchod
DocType: Project,Twice Daily,Dva krát denne
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Integrated Tax,Integrovaná daň
DocType: Payment Entry,Deductions or Loss,Zrážky alebo straty
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ý, prosíme stanoviť fiškálny režim v spoločnosti {0}"
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Time slots added,Pridané časové úseky
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leaves must be allocated in multiples of 0.5,"Listy musia byť pridelené v násobkoch 0,5"
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} deducted against {2},Suma {0} {1} bola odpočítaná proti {2}
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Platba zúčtovania platieb
apps/erpnext/erpnext/config/buying.py,Template of terms or contract.,Šablóna podmienok alebo zmluvy.
DocType: Item,Barcodes,čiarové kódy
DocType: Course Enrollment,Enrollment Date,Dátum zápisu
DocType: Holiday List,Clear Table,Vymazať tabuľku
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Setting up company,Založenie spoločnosti
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Free item code is not selected,Voľný kód položky nie je vybratý
apps/erpnext/erpnext/public/js/utils.js,Total Unpaid: {0},Celkom nezaplatené: {0}
DocType: Account,Balance must be,Zostatok musí byť
DocType: Supplier,Default Bank Account,Predvolený bankový účet
apps/erpnext/erpnext/regional/india/utils.py,Transport Receipt No and Date are mandatory for your chosen Mode of Transport,Dopravný doklad č. A dátum je povinný pre zvolený spôsob dopravy
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Creating Fees,Vytváranie poplatkov
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select Qty against item {0},Vyberte položku Počet proti položke {0}
DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,"Nepotvrdzujte, či je stretnutie vytvorené pre ten istý deň"
DocType: Loan,Repaid/Closed,Splatená / Zatvorené
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 požadované pre položku {2}. Poskytli ste {3}.
DocType: Exchange Rate Revaluation Account,Gain/Loss,Zisk / strata
DocType: POS Profile,Sales Invoice Payment,Platba predajnej faktúry
DocType: Timesheet,Payslip,výplatná páska
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,HSN,HSN
apps/erpnext/erpnext/config/buying.py,Request for quotation.,Žiadosť o cenovú ponuku.
,Procurement Tracker,Sledovanie nákupu
DocType: Employee Tax Exemption Proof Submission Detail,Type of Proof,Typ dôkazu
DocType: Purchase Receipt,Vehicle Date,Dátum vozidla
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Reconcile Entries,Zosúladenie položiek
DocType: Delivery Settings,Dispatch Settings,Nastavenia odoslania
DocType: Task,Dependencies,závislosti
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js,Lost,stratený
DocType: BOM Update Tool,Replace BOM,Vymeňte kusovník
DocType: Patient,Marital Status,Rodinný stav
DocType: HR Settings,Enter retirement age in years,Vstup do dôchodkového veku v rokoch
apps/erpnext/erpnext/templates/generators/item_group.html,No items listed,Žiadne položky nie sú uvedené
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,No data to export,Žiadne údaje na export
DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,"Ak chcete zahrnúť aj predchádzajúce saldo predchádzajúceho fiškálneho roka do tohto fiškálneho roka, vyberte možnosť Preposlať ďalej"
apps/erpnext/erpnext/config/help.py,Opening Stock Balance,Otvorenie bilancie zásob
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave Blocked,Nechajte zablokované
apps/erpnext/erpnext/stock/doctype/item/item.py,Asset Category is mandatory for Fixed Asset item,Kategória aktív je povinná pre položku Fixed Asset
DocType: Purchase Receipt Item,Required By,Je požadované
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Add to Details,Pridať do Podrobnosti
,Inactive Customers,Neaktívni zákazníci
DocType: Drug Prescription,Dosage,dávkovanie
DocType: Cheque Print Template,Starting position from top edge,Počiatočná pozícia od horného okraja
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Appointment Duration (mins),Trvanie schôdzky (min)
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}
DocType: Accounting Dimension,Disable,zakázať
DocType: Email Digest,Purchase Orders to Receive,Objednávky na príjem
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Productions Orders cannot be raised for:,Výrobné objednávky nie je možné zvýšiť pre:
DocType: Projects Settings,Ignore Employee Time Overlap,Ignorovať prekrytie času zamestnanca
DocType: Employee Skill Map,Trainings,tréningy
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Lost Reasons,Stratené dôvody
DocType: Inpatient Record,A Positive,Pozitívne
DocType: Quality Inspection Reading,Reading 7,Čítanie 7
DocType: Purchase Invoice Item,Serial No,Sériové číslo
DocType: Material Request Plan Item,Required Quantity,Požadované množstvo
DocType: Location,Parent Location,Rodič Poloha
DocType: Production Plan,Material Requests,Žiadosti o materiál
DocType: Buying Settings,Material Transferred for Subcontract,Materiál prevedený na subdodávky
DocType: Job Card,Timing Detail,Detail načasovania
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html,Required On,Povinné On
DocType: Job Offer Term,Job Offer Term,Termín pracovnej ponuky
DocType: SMS Center,All Contact,Všetky kontakty
DocType: Item Barcode,Item Barcode,Čiarový kód položky
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Levels,Úrovne zásob
DocType: Vital Signs,Height (In Meter),Výška (v metri)
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Value,Hodnota objednávky
DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Všetky predajné transakcie môžu byť označené proti viacerým ** predajcom **, takže môžete nastaviť a monitorovať ciele."
apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Už ste si vybrali položky z {0} {1}
DocType: Request for Quotation,Get Suppliers,Získať dodávateľov
DocType: Sales Team,Contribution (%),Príspevok (%)
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 No Quote
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Sales Order,Vytvoriť zákazku odberateľa
apps/erpnext/erpnext/accounts/general_ledger.py,Account: {0} can only be updated via Stock Transactions,Účet: {0} je možné aktualizovať iba prostredníctvom burzových transakcií
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} Request for {1},{0} Žiadosť o {1}
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js,Please select a value for {0} quotation_to {1},Vyberte hodnotu pre {0} quotation_to {1}
DocType: Opportunity,Opportunity Date,Dátum príležitosti
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Next Steps,Ďalšie kroky
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Feedback,Spätná väzba
DocType: Purchase Invoice,ACC-PINV-.YYYY.-,ACC-pInv-.YYYY.-
DocType: Holiday List,Total Holidays,Celkové prázdniny
DocType: Fertilizer,Fertilizer Name,Názov hnojiva
apps/erpnext/erpnext/regional/india/utils.py,House rented dates required for exemption calculation,Dom prenajal dátumy potrebné pre výpočet výnimky
,Expiring Memberships,Ukončenie členstva
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Supplier(s),Dodávateľ (é)
DocType: GL Entry,To Rename,Pre premenovanie
apps/erpnext/erpnext/templates/generators/item/item_configure.html,Contact Us,Kontaktuj nás
DocType: POS Closing Voucher,Cashier,pokladničné
DocType: Drug Prescription,Hour,hodina
DocType: Support Settings,Show Latest Forum Posts,Zobraziť najnovšie príspevky v fóre
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Distributor,distribútor
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 rata komponent
DocType: Invoice Discounting,Short Term Loan Account,Krátkodobý úverový účet
DocType: Cash Flow Mapper,Section Subtotal,Oddiel Medzisúčet
apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Materiálna požiadavka na objednávku
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CESS Amount,CESS Suma
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Not authorized to edit frozen Account {0},Nie je oprávnený upravovať zmrazený účet {0}
DocType: POS Closing Voucher Details,Expected Amount,Očakávaná suma
DocType: Customer,Default Price List,Predvolený cenník
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,No Items selected for transfer,Žiadne položky vybrané na prenos
DocType: Payment Schedule,Payment Amount,Čiastka na úhradu
DocType: Grant Application,Assessment  Manager,Manažér hodnotenia
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Chemical,chemický
apps/erpnext/erpnext/config/education.py,Assessment Reports,Hodnotiace správy
DocType: C-Form,IV,IV
DocType: Student Log,Academic,akademický
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item {0} is not setup for Serial Nos. Check Item master,Položka {0} nie je nastavená pre sériové čísla
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From State,Zo štátu
DocType: Leave Type,Maximum Continuous Days Applicable,Maximálne použiteľné nepretržité dni
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Please enter company name first,Najskôr zadajte názov spoločnosti
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Import Successful,Import bol úspešný
DocType: Guardian,Alternate Number,Alternatívne číslo
apps/erpnext/erpnext/patches/v11_0/create_department_records_for_each_company.py,All Departments,Všetky oddelenia
apps/erpnext/erpnext/config/projects.py,Make project from a template.,Vytvorte projekt zo šablóny.
DocType: Purchase Order,Inter Company Order Reference,Referenčné referenčné číslo spoločnosti
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Work Order {0} must be cancelled before cancelling this Sales Order,Pracovná objednávka {0} musí byť zrušená pred zrušením tejto zákazky odberateľa
DocType: Education Settings,Employee Number,Číslo zamestnanca
DocType: Manufacturing Settings,Capacity Planning For (Days),Plánovanie kapacity pre (dni)
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,From value must be less than to value in row {0},Hodnota musí byť nižšia ako hodnota v riadku {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select BOM and Qty for Production,Vyberte BOM a Qty for Production
DocType: Price List Country,Price List Country,Cenník Krajina
apps/erpnext/erpnext/setup/doctype/company/company.js,Create Tax Template,Vytvoriť daňovú šablónu
DocType: Item Attribute,Numeric Values,Číselné hodnoty
DocType: Delivery Note,Instructions,Inštrukcie
DocType: Blanket Order Item,Blanket Order Item,Položka objednávky deka
DocType: Accounting Dimension,Mandatory For Profit and Loss Account,Povinné pre výkaz ziskov a strát
apps/erpnext/erpnext/controllers/selling_controller.py,Commission rate cannot be greater than 100,Miera Komisie nemôže byť vyššia ako 100%. \ T
DocType: Course Topic,Course Topic,Téma kurzu
DocType: Employee,This will restrict user access to other employee records,Tým sa obmedzí prístup používateľov k iným zamestnaneckým záznamom
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Please create Customer from Lead {0},"Prosím, vytvorte zákazníka z Lead {0}"
DocType: QuickBooks Migrator,Company Settings,Nastavenia spoločnosti
DocType: Travel Itinerary,Vegetarian,vegetarián
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py,"An item exists with same name ({0}), please change the item group name or rename the item","Položka existuje s rovnakým názvom ({0}), zmeňte názov skupiny položiek alebo premenujte položku"
DocType: Hotel Room,Hotel Room Type,Typ izby v hoteli
,Cash Flow,Cash Flow
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Platba vo výške {0} {1} nemôže byť vyššia ako suma v hodnote {2}
DocType: Student Log,Achievement,úspech
apps/erpnext/erpnext/projects/doctype/task/task_tree.js,Add Multiple Tasks,Pridať viac úloh
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant {0} already exists with same attributes,Položka Variant {0} už existuje s rovnakými atribútmi
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Invoice {0} no longer exists,Faktúra {0} už neexistuje
DocType: Item,Will also apply for variants unless overrridden,"Platí aj pre varianty, pokiaľ nie sú prepísané"
DocType: Cash Flow Mapping Accounts,Account,účet
DocType: Sales Order,To Deliver,Dodať
,Customers Without Any Sales Transactions,Zákazníci bez akýchkoľvek obchodných transakcií
DocType: Maintenance Visit Purpose,Against Document No,Proti dokumentu č
apps/erpnext/erpnext/config/education.py,Content Masters,Obsah Masters
apps/erpnext/erpnext/config/accounting.py,Subscription Management,Správa predplatného
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Get customers from,Získajte zákazníkov
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,{0} Digest,{0} Digest
DocType: Employee,Reports to,Hlásenia
DocType: Video,YouTube,YouTube
DocType: Party Account,Party Account,Účet strany
DocType: Assessment Plan,Schedule,plán
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please enter ,Prosím Vlož
DocType: Lead,Channel Partner,Partner kanála
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Invoiced Amount,Fakturovaná čiastka
DocType: Project,From Template,Zo šablóny
,DATEV,DATEV
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,Subscriptions,odbery
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Quantity to Make,"Množstvo, ktoré sa má vykonať"
DocType: Quality Review Table,Achieved,dosiahnuté
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution Amount,Výška príspevku
DocType: Budget,Fiscal Year,Fiškálny rok
DocType: Supplier,Prevent RFQs,Zabráňte RFQ
DocType: Company,Discount Received Account,Účet so zľavou
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py, (Half Day),(Pol dňa)
DocType: Email Digest,Email Digest,Email Digest
DocType: Crop,Crop,Plodina
DocType: Email Digest,Profit & Loss,Strata na zisku
DocType: Homepage Section,Section Order,Poradie sekcií
DocType: Healthcare Settings,Result Printed,Výsledok Vytlačené
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js,Student Group,Študentská skupina
DocType: Purchase Taxes and Charges Template,"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.

#### Note

The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.
10. Add or Deduct: Whether you want to add or deduct the tax.","Štandardná šablóna dane, ktorú možno použiť na všetky nákupné transakcie. Táto šablóna môže obsahovať zoznam daňových hláv a tiež ďalšie výdavkové hlavy, ako napríklad „Preprava“, „Poistenie“, „Manipulácia“ atď. #### Poznámka Tu definovaná sadzba dane bude štandardnou sadzbou dane pre všetky položky **. *. Ak sú ** položky **, ktoré majú rozdielne sadzby, musia byť pridané do ** Položka dane ** tabuľky ** Master ** Master. #### Popis stĺpcov 1. Typ výpočtu: - Toto môže byť na ** Čistý súčet ** (to je súčet základnej čiastky). - ** V predchádzajúcom riadku Spolu / Suma ** (pre kumulatívne dane alebo poplatky). Ak vyberiete túto možnosť, daň sa použije ako percento z predchádzajúceho riadku (v daňovej tabuľke) alebo celkovej sumy. - ** Skutočný ** (ako je uvedené). 2. Vedúci účtu: účtovná kniha, pod ktorou bude táto daň zaúčtovaná. 3. Nákladové stredisko: Ak je daň / poplatok príjmom (napr. Prepravou) alebo nákladom, musí byť zaúčtovaný proti nákladovému stredisku. 4. Popis: Opis dane (ktorá bude vytlačená na faktúrach / kottoch). 5. Sadzba: Sadzba dane. 6. Suma: Výška dane. 7. Spolu: Kumulatívny súčet k tomuto bodu. 8. Zadajte riadok: Ak sa na základe &quot;Predchádzajúca riadka Celkom&quot; môžete zvoliť číslo riadku, ktoré bude brané ako základ pre tento výpočet (predvolené je predchádzajúci riadok). 9. Zvážte daň alebo poplatok za: V tejto sekcii môžete určiť, či daň / poplatok je len pre ocenenie (nie je súčasťou celkovej sumy) alebo len pre celkovú sumu (nepridáva hodnotu k položke) alebo pre obe. 10. Pridanie alebo odpočítanie: Či chcete daň pridať alebo odpočítať."
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Connect to Quickbooks,Pripojenie k Quickbooks
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root cannot be edited.,Koreň sa nedá upraviť.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Engineer,Inžinier
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Item added,Riadok # {0}: Pridaná položka
DocType: Student Admission,Eligibility and Details,Spôsobilosť a podrobnosti
DocType: Staffing Plan,Staffing Plan Detail,Detail personálneho plánu
DocType: Shift Type,Late Entry Grace Period,Neskoré vstupné obdobie
DocType: Email Digest,Annual Income,Ročný príjem
DocType: Journal Entry,Subscription Section,Odberová sekcia
DocType: Salary Slip,Payment Days,Platobné dni
apps/erpnext/erpnext/config/non_profit.py,Volunteer information.,Informácie o dobrovoľníkoch.
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py,`Freeze Stocks Older Than` should be smaller than %d days.,&quot;Zmrazené zásoby staršie ako&quot; by mali byť menšie ako% d dní.
DocType: Bank Reconciliation,Total Amount,Celková suma
DocType: Certification Application,Non Profit,Neziskové
DocType: Subscription Settings,Cancel Invoice After Grace Period,Zrušiť faktúru po období odkladu
DocType: Loyalty Point Entry,Loyalty Points,Vernostné body
DocType: Bank Account,Change this date manually to setup the next synchronization start date,"Tento dátum zmeňte manuálne, aby ste nastavili nasledujúci dátum synchronizácie"
DocType: Purchase Order,Set Target Warehouse,Nastaviť cieľový sklad
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.",{0} má v súčasnosti {1} výsledkové hodnotenie dodávateľov a RFQ pre tohto dodávateľa by sa mali vydávať s opatrnosťou.
DocType: Travel Itinerary,Check-in Date,Dátum registrácie
DocType: Tally Migration,Round Off Account,Účet zaokrúhlený
DocType: Serial No,Warranty Period (Days),Záručná doba (dni)
DocType: Expense Claim Detail,Expense Claim Detail,Detail nároku na výdavky
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Program: ,Program:
DocType: Patient Medical Record,Patient Medical Record,Lekársky záznam pacienta
DocType: Item,Variant Based On,Variant Based On
DocType: Vehicle Service,Brake Oil,Brzdový olej
DocType: Employee,Create User,Vytvoriť používateľa
DocType: Codification Table,Codification Table,Kodifikačná tabuľka
DocType: Training Event Employee,Optional,voliteľný
DocType: HR Settings,Show Leaves Of All Department Members In Calendar,Zobraziť listy všetkých členov oddelenia v kalendári
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Did not found transfered item {0} in Work Order {1}, the item not added in Stock Entry","Nepodarilo sa nájsť prenesenú položku {0} v pracovnom príkaze {1}, položka nebola pridaná do položky Položka"
apps/erpnext/erpnext/templates/pages/help.html,See all open tickets,Pozrite si všetky otvorené vstupenky
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Operations cannot be left blank,Operácie nemožno ponechať prázdne
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,At least one mode of payment is required for POS invoice.,Pre platobnú faktúru sa vyžaduje aspoň jeden spôsob platby.
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Email ID,ID Guardian1
DocType: Sales Order Item,Supplier delivers to Customer,Dodávateľ dodá zákazníkovi
DocType: Procedure Prescription,Appointment Booked,Vymenovanie rezervované
DocType: Crop,Target Warehouse,Cieľový sklad
DocType: Accounts Settings,Stale Days,Stale dní
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Credit entry can not be linked with a {1},Riadok {0}: Zadanie kreditu nie je možné prepojiť s hodnotou {1}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Healthcare Practitioner {0} not available on {1},Lekár pre zdravotnú starostlivosť {0} nie je k dispozícii v {1}
DocType: SMS Center,All Customer Contact,Všetci zákazníci
apps/erpnext/erpnext/stock/doctype/item/item.py," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Udržať vzorku je založená na dávke, prosím skontrolujte, či má vzorka položku Nie"
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Disc,kotúč
DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Vykonajte účtovný zápis pre každé skladové hnutie
DocType: Travel Itinerary,Check-out Date,Dátum odhlásenia
DocType: Agriculture Analysis Criteria,Fertilizer,umelé hnojivo
DocType: Supplier,Default Tax Withholding Config,Štandardná zrážková daň Config
DocType: Production Plan,Total Produced Qty,Spolu Vyrobené Množstvo
DocType: Leave Allocation,Leave Period,Obdobie dovolenky
apps/erpnext/erpnext/education/doctype/fees/fees.py,Payment request {0} created,Bola vytvorená žiadosť o platbu {0}
DocType: Healthcare Service Unit Type,UOM Conversion in Hours,Konverzia UOM v hodinách
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Avg. Selling Price List Rate,Avg. Predajná cena sadzba
apps/erpnext/erpnext/config/manufacturing.py,Generate Material Requests (MRP) and Work Orders.,Generovanie požiadaviek na materiál (MRP) a pracovných príkazov.
DocType: Journal Entry Account,Account Balance,Zostatok na účte
DocType: Asset Maintenance Log,Periodicity,periodicita
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Medical Record,Zdravotný záznam
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,Log Type is required for check-ins falling in the shift: {0}.,Typ logu je potrebný pre check-iny spadajúce do zmeny: {0}.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Execution,poprava
DocType: Item,Valuation Method,Metóda oceňovania
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Invoice {1},{0} proti predajnej faktúre {1}
DocType: Quiz Activity,Pass,priechod
DocType: Sales Partner,Sales Partner Target,Cieľ predajného partnera
DocType: Patient Appointment,Referring Practitioner,Sprostredkujúci praktik
DocType: Account,Expenses Included In Asset Valuation,Náklady zahrnuté do ocenenia majetku
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Publishing,Vydavateľstvo
DocType: Production Plan,Sales Orders Detail,Detail zákazky odberateľa
DocType: Salary Slip,Total Deduction,Celkový odpočet
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.js,Select a company,Vyberte spoločnosť
apps/erpnext/erpnext/hr/report/loan_repayment/loan_repayment.py,EMI,EMI
DocType: Naming Series,Set prefix for numbering series on your transactions,Nastavte prefix pre číslovanie sérií vašich transakcií
apps/erpnext/erpnext/accounts/utils.py,Journal Entries {0} are un-linked,Záznamy žurnálu {0} nie sú prepojené
apps/erpnext/erpnext/config/buying.py,Other Reports,Iné správy
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,All items have already been invoiced,Všetky položky už boli fakturované
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset scrapped via Journal Entry {0},Aktíva vyradené prostredníctvom položky časopisu {0}
DocType: Employee,Prefered Email,Preferovaný e-mail
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Nemôžem zmeniť metódu oceňovania, pretože existujú transakcie proti niektorým položkám, ktoré nemajú vlastnú metódu oceňovania"
DocType: Cash Flow Mapper,Section Name,Názov sekcie
DocType: Packed Item,Packed Item,Balená položka
DocType: Issue,Reset Service Level Agreement,Reset Service Level Agreement
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Pre {2} sa vyžaduje buď debetná alebo kreditná suma
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Submitting Salary Slips...,Odosielanie platových lístkov ...
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,No Action,Žiadna akcia
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 nie je možné priradiť k hodnote {0}, pretože nejde o účet príjmu alebo výdavkov"
DocType: Quality Procedure Table,Responsible Individual,Zodpovedný jednotlivec
apps/erpnext/erpnext/education/doctype/course/course.py,Total Weightage of all Assessment Criteria must be 100%,Celkové váženie všetkých kritérií hodnotenia musí byť 100%
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: Sales Invoice,Customer Name,Meno zákazníka
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Amount should not be less than zero.,Výška by nemala byť nižšia ako nula.
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Average Age,Priemerný vek
DocType: Shopping Cart Settings,Show Price,Zobraziť cenu
DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Študent nástroja na zápis programu
DocType: Tax Rule,Shipping State,Štát lodnej dopravy
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.js,Please set Company,"Prosím, nastavte spoločnosť"
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Balance (Dr - Cr),Zostatok (Dr - Cr)
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Supply Type,Typ dodávky
DocType: Healthcare Settings,Create documents for sample collection,Vytvorte dokumenty pre odber vzoriek
DocType: Selling Settings,Close Opportunity After Days,Zatvorte príležitosť po dňoch
DocType: Item Customer Detail,Ref Code,Ref Code
DocType: Employee,Widowed,ovdovený
DocType: Tally Migration,ERPNext Company,ERPNext Spoločnosť
DocType: Delivery Settings,Leave blank to use the standard Delivery Note format,"Ak chcete použiť štandardný formát dodacieho listu, ponechajte prázdne"
DocType: Purchase Invoice Item,Accepted Qty,Prijaté množstvo
DocType: Pricing Rule,Apply Rule On Brand,Použiť pravidlo na značku
DocType: Products Settings,Show Availability Status,Zobraziť stav dostupnosti
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Import Successfull,Úspešný dovoz
DocType: Agriculture Analysis Criteria,Soil Texture,Textúra pôdy
DocType: Maintenance Schedule Item,No of Visits,Počet návštev
DocType: Customer Feedback Table,Qualitative Feedback,Kvalitatívna spätná väzba
DocType: Support Settings,Service Level Agreements,Dohody o úrovni služieb
DocType: Service Level,Response and Resoution Time,Odozva a čas resoúcie
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Expiring On,Platnosť vyprší
apps/erpnext/erpnext/education/utils.py,Student with email {0} does not exist,Študent s e-mailom {0} neexistuje
DocType: Supplier Scorecard,Scorecard Actions,Skóre karty
DocType: Account,Stock Adjustment,Úprava zásob
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Health Care,Zdravotná starostlivosť
DocType: Restaurant Table,No of Seats,Počet sedadiel
apps/erpnext/erpnext/setup/doctype/company/company.js,Delete all the Transactions for this Company,Vymažte všetky transakcie pre túto spoločnosť
,Lead Details,Podrobnosti o elektrole
DocType: Service Level Agreement,Default Service Level Agreement,Štandardná dohoda o úrovni služieb
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""",Filter Fields Row # {0}: Názov poľa <b>{1}</b> musí byť typu &quot;Link&quot; alebo &quot;Table MultiSelect&quot;
DocType: Lead,Suggestions,Návrhy
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Get from,Dostaňte sa z
DocType: Tax Rule,Tax Rule,Daňové pravidlo
DocType: Payment Entry,Payment Order Status,Stav platobného príkazu
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Duplicate entry,Duplicitný záznam
apps/erpnext/erpnext/utilities/user_progress.py,Example: Masters in Computer Science,Príklad: Masters in Computer Science
DocType: Purchase Invoice Item,Purchase Invoice Item,Položka nákupnej faktúry
apps/erpnext/erpnext/projects/doctype/project/project.py,Status must be Cancelled or Completed,Stav musí byť zrušený alebo dokončený
apps/erpnext/erpnext/crm/doctype/utils.py,Call Summary by {0}: {1},Zhrnutie volania podľa čísla {0}: {1}
DocType: Certified Consultant,Non Profit Manager,Správca neziskových organizácií
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,For Warehouse is required before Submit,Pred odoslaním sa vyžaduje sklad
DocType: Authorization Rule,Applicable To (User),Platné pre (používateľ)
DocType: Appraisal Goal,Appraisal Goal,Cieľ hodnotenia
DocType: Supplier Scorecard,Warn for new Purchase Orders,Upozorniť na nové objednávky
apps/erpnext/erpnext/public/js/setup_wizard.js,View Chart of Accounts,Zobraziť graf účtov
apps/erpnext/erpnext/templates/pages/rfq.html,Quotations: ,citácie:
DocType: Opportunity,To Discuss,Diskutovať
DocType: Quality Inspection Reading,Reading 9,Čítanie 9
DocType: Authorization Rule,Applicable To (Role),Použiteľné pre (úlohu)
DocType: Quotation Item,Additional Notes,Doplňujúce Poznámky
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} can not be negative,{0} nemôže byť záporné
apps/erpnext/erpnext/utilities/activation.py,Create Purchase Orders,Vytvorenie objednávok
DocType: Staffing Plan Detail,Estimated Cost Per Position,Odhadovaná cena za pozíciu
DocType: Loan Type,Loan Name,Názov úveru
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Set default mode of payment,Nastaviť predvolený spôsob platby
DocType: Quality Goal,Revision,opakovanie
DocType: Shift Type,The time before the shift end time when check-out is considered as early (in minutes).,"Čas pred ukončením posunu, keď je odhlásenie považované za skoré (v minútach)."
DocType: Healthcare Service Unit,Service Unit Type,Typ servisnej jednotky
DocType: Purchase Invoice,Return Against Purchase Invoice,Návrat proti nákupnej faktúre
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Generate Secret,Generovať tajomstvo
DocType: Loyalty Program Collection,Loyalty Program Collection,Kolekcia vernostného programu
apps/erpnext/erpnext/config/crm.py,Send mass SMS to your contacts,Posielajte hromadné SMS svojim kontaktom
apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js,Create Fee Schedule,Vytvorenie harmonogramu poplatkov
DocType: Rename Tool,File to Rename,Súbor na premenovanie
apps/erpnext/erpnext/public/js/projects/timer.js,Timer exceeded the given hours.,Časovač prekročil stanovené hodiny.
DocType: Shopify Tax Account,ERPNext Account,ERPDalší účet
DocType: Item Supplier,Item Supplier,Položka Dodávateľ
apps/erpnext/erpnext/stock/get_item_details.py,Price List {0} is disabled or does not exist,Cenník {0} je zakázaný alebo neexistuje
DocType: Sales Invoice Item,Deferred Revenue Account,Odložený výnosový účet
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py,Soil compositions do not add up to 100,Pôdní zloženie nepridáva až 100%
DocType: Salary Slip,Salary Slip Timesheet,Rozvrhy platov
DocType: Budget,Warn,varovať
DocType: Grant Application,Email Notification Sent,Odoslané e-mailové upozornenie
DocType: Work Order,Planned End Date,Dátum plánovaného ukončenia
DocType: QuickBooks Migrator,Quickbooks Company ID,ID spoločnosti Quickbooks
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Sklad nie je možné zmeniť pre sériové číslo
DocType: Loan Type,Rate of Interest (%) Yearly,Úroková miera (%) Ročne
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Scrapped Asset,Náklady na vyradený majetok
apps/erpnext/erpnext/regional/italy/utils.py,Please set an Address on the Company '%s',Nastavte adresu na adrese „% s“ spoločnosti
DocType: Patient Encounter,Encounter Date,Dátum stretnutia
DocType: Shopify Settings,Webhooks,Webhooks
apps/erpnext/erpnext/config/non_profit.py,Memebership Type Details,Podrobnosti typu Memebership
apps/erpnext/erpnext/healthcare/setup.py,Resistant,odolný
DocType: Hotel Room Package,Hotel Room Package,Balíček hotelových izieb
DocType: Sales Team,Contribution to Net Total,Príspevok k čistému súčtu
DocType: Customer,"Reselect, if the chosen contact is edited after save","Znova vyberte, ak sa vybraný kontakt po uložení uloží"
DocType: Employee Tax Exemption Sub Category,Employee Tax Exemption Sub Category,Podkategória pre oslobodenie zamestnancov od dane
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Row {0}# Paid Amount cannot be greater than requested advance amount,Riadok {0} # Platená čiastka nemôže byť vyššia ako požadovaná suma
DocType: Asset Settings,This value is used for pro-rata temporis calculation,Táto hodnota sa používa na výpočet pro-rata temporis
DocType: Company,Change Abbreviation,Zmeniť skratku
DocType: Project,Total Consumed Material Cost  (via Stock Entry),Celkové spotrebované materiálové náklady (cez vstup do skladu)
DocType: Purchase Invoice,Raw Materials Supplied,Dodávané suroviny
DocType: Salary Detail,Condition and Formula Help,Podmienka a pomocník vzorca
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Balance ({0}),Zostatok ({0})
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student ID: ,Študentská karta:
DocType: Leave Control Panel,New Leaves Allocated (In Days),Nové pridelené listy (v dňoch)
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py,To Datetime,Do Datetime
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab result datetime cannot be before testing datetime,Laboratórny výsledok datetime nemôže byť pred testovaním datetime
apps/erpnext/erpnext/setup/doctype/company/company.js,Please re-type company name to confirm,Pre potvrdenie zadajte názov spoločnosti
DocType: Subscription,Subscription Period,Obdobie predplatného
DocType: Cash Flow Mapper,Position,pozície
DocType: Student,Sibling Details,Podrobnosti o súrodenci
DocType: Cash Flow Mapping,Is Finance Cost Adjustment,Úprava finančných nákladov
DocType: Patient Encounter,Encounter Impression,Stretnutie dojem
DocType: Contract,N/A,N / A
DocType: Lab Test,Lab Technician,Laboratórny technik
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, vyberte jeden z jej variantov"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,How Pricing Rule is applied?,Ako sa uplatňuje pravidlo určovania cien?
DocType: Email Digest,Email Digest Settings,Nastavenia Digest Digest
DocType: Journal Entry,Inter Company Journal Entry,Vstup do vnútropodnikového denníka
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Create Delivery Trip,Vytvoriť cestu doručenia
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Riadok # {0}: Poradové číslo {1} sa nezhoduje s hodnotou {2} {3}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Sales Order required for Item {0},Požadovaná objednávka odberateľa pre položku {0}
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Connected,Hovor je pripojený
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_proof_submission/employee_tax_exemption_proof_submission.js,Get Details From Declaration,Získať podrobnosti z vyhlásenia
,Support Hour Distribution,Distribúcia hodín podpory
DocType: Company,Allow Account Creation Against Child Company,Povoliť vytvorenie účtu proti detskej spoločnosti
DocType: Payment Entry,Company Bank Account,Firemný bankový účet
DocType: Amazon MWS Settings,UK,Spojené kráľovstvo
DocType: Normal Test Items,Normal Test Items,Normálne testované položky
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ý počet {1} nemôže byť menší ako minimálna objednávka {2} (definovaná v položke).
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,Not in Stock,Nie je skladom
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,vozík
DocType: Course Activity,Course Activity,Kurz Činnosť
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Thank you for your business!,Ďakujeme za vašu firmu!
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Against Journal Entry {0} is already adjusted against some other voucher,Proti vstupu do časopisu {0} je už upravený proti inému poukazu
DocType: Journal Entry,Bill Date,Dátum fakturácie
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please enter Write Off Account,Zadajte prosím Odpisový účet
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Biotechnology,biotechnológie
apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py,Setup your Institute in ERPNext,Nastavenie vášho inštitútu v ERPNext
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} does not exist,Položka {0} neexistuje
DocType: Asset Maintenance Log,Asset Maintenance Log,Denník údržby majetku
DocType: Accounts Settings,Settings for Accounts,Nastavenia pre účty
DocType: Bank Guarantee,Reference Document Name,Referenčný názov dokumentu
DocType: Warehouse,"If blank, parent Warehouse Account or company default will be considered","Ak je prázdny, bude braný do úvahy materský účet skladu alebo spoločnosť"
DocType: BOM,Rate Of Materials Based On,Množstvo materiálov založených na
DocType: Water Analysis,Container,kontajner
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Available slots,Dostupné sloty
DocType: Quiz,Max Attempts,Max Pokusy
apps/erpnext/erpnext/public/js/financial_statements.js,Cash Flow Statement,Výkaz peňažných tokov
DocType: Loyalty Point Entry,Redeem Against,Uplatniť proti
DocType: Sales Invoice,Offline POS Name,Offline POS Name
DocType: Crop Cycle,ISO 8601 standard,Norma ISO 8601
DocType: Purchase Taxes and Charges,Deduct,odpočítať
DocType: C-Form Invoice Detail,C-Form Invoice Detail,Detail faktúry vo formulári C-Form
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Inventory,Čistá zmena stavu zásob
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ť vygenerovaný len z predloženého dokumentu
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Amount during the period,Odpisy Suma počas obdobia
DocType: Shopify Settings,App Type,Typ aplikácie
DocType: Lead,Blog Subscriber,Účastník blogu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,[Error],[Chyba]
DocType: Restaurant,Active Menu,Aktívna ponuka
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Transactions against the company already exist! ,Transakcie voči spoločnosti už existujú!
DocType: Customer,Sales Partner and Commission,Obchodný partner a Komisia
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Goals cannot be empty,Ciele nemôžu byť prázdne
DocType: Work Order,Warehouses,sklady
DocType: Bank Transaction,ACC-BTN-.YYYY.-,ACC-BTN-.YYYY.-
DocType: Crop Cycle,Detected Diseases,Zistené choroby
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.
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Items and UOMs,Spracovávanie položiek a UOM
DocType: Payment Request,Is a Subscription,Je predplatné
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Stiahnuť ako Json
,Appointment Analytics,Vymenovanie Analytics
DocType: Quality Inspection,Inspection Type,Typ kontroly
DocType: Sales Invoice,Sales Taxes and Charges,Predajné dane a poplatky
DocType: Employee,Health Insurance Provider,Poskytovateľ zdravotného poistenia
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,This is a root item group and cannot be edited.,Toto je skupina koreňových položiek a nedá sa upraviť.
DocType: Production Plan,Projected Qty Formula,Premietaný vzorec
DocType: Payment Order,Payment Order Reference,Referencia platobného príkazu
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Tree Type,Typ stromu
DocType: Activity Type,Default Costing Rate,Predvolená sadzba kalkulácie
DocType: Vital Signs,Constipated,zápchu
DocType: Salary Detail,Default Amount,Predvolená čiastka
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,Budget List,Zoznam rozpočtu
DocType: Job Offer,Awaiting Response,Čaká sa na odpoveď
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.py,Not permitted. Please disable the Procedure Template,Nepovolené. Vypnite šablónu procedúry
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant creation has been queued.,Vytvorenie variantu bolo vo fronte.
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 nárokovaná na komponent {1}, nastavuje hodnotu rovnú alebo väčšiu ako {2}"
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Please add the remaining benefits {0} to any of the existing component,Pridajte zvyšné výhody {0} do niektorého z existujúcich komponentov
DocType: Vehicle Log,Odometer,počítač kilometrov
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 mena platobnej brány
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é číslo
DocType: Additional Salary,Payroll Date,Dátum mzdy
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Mode of payment is required to make a payment,Na uskutočnenie platby sa vyžaduje spôsob platby
DocType: BOM,Materials,materiály
DocType: Delivery Note Item,Against Sales Order,Proti zákazke odberateľa
DocType: Supplier Quotation,PUR-SQTN-.YYYY.-,PUR-SQTN-.YYYY.-
DocType: Delivery Note Item,Against Sales Order Item,Proti položke zákazky odberateľa
DocType: Appraisal,Goals,Ciele
DocType: Employee,ERPNext User,ERPNext Používateľ
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Available Leaves,Dostupné listy
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root Account must be a group,Koreňový účet musí byť skupina
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Email Reminders will be sent to all parties with email contacts,E-mailové pripomienky budú odoslané všetkým stranám s e-mailovými kontaktmi
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Type...,Vyberte typ ...
DocType: Workstation Working Hour,Workstation Working Hour,Pracovná doba pracovnej stanice
apps/erpnext/erpnext/config/agriculture.py,Analytics,analytika
DocType: Maintenance Team Member,Maintenance Role,Údržba Úloha
apps/erpnext/erpnext/config/buying.py,Terms and Conditions Template,Podmienky šablóny
apps/erpnext/erpnext/controllers/status_updater.py,"To allow over billing, update ""Over Billing Allowance"" in Accounts Settings or the Item.","Ak chcete povoliť fakturáciu, aktualizujte položku „Over Billing Allowance“ v položke Accounts Settings alebo Item."
DocType: Fee Schedule Program,Fee Schedule Program,Program poplatkov
DocType: Production Plan Item,Production Plan Item,Položka výrobného plánu
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Total Student,Celkový počet študentov
DocType: Packing Slip,From Package No.,Z čísla balíka
DocType: Accounts Settings,Shipping Address,Poštová adresa
DocType: Vehicle Service,Clutch Plate,Spojkový kotúč
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} does not linked to Item {2},Riadok # {0}: Majetok {1} nie je prepojený s položkou {2}
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Entry {0} created,Vytvoril sa záznam položky {0}
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Date,Dátum objednávky
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Company currencies of both the companies should match for Inter Company Transactions.,Meny spoločností oboch spoločností by sa mali zhodovať s transakciami medzi spoločnosťami.
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Shortage Qty,Kratšie množstvo
DocType: Employee Attendance Tool,Marked Attendance,Označená účasť
DocType: Pricing Rule,System will notify to increase or decrease quantity or amount ,Systém upozorní na zvýšenie alebo zníženie množstva alebo množstva
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Cosmetics,kozmetika
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.,"Označte túto možnosť, ak chcete, aby užívateľ pred uložením vybral sériu. Ak to skontrolujete, nebude to predvolené."
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,No issue raised by the customer.,Žiadny problém nevzniesol zákazník.
DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Používatelia s touto úlohou môžu nastaviť zmrazené účty a vytvárať / upravovať účtovné položky voči zmrazeným účtom
DocType: Expense Claim,Total Claimed Amount,Celková výška nárokovanej sumy
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Unable to find Time Slot in the next {0} days for Operation {1},Časový slot sa nedá nájsť v nasledujúcom {0} dňoch pre operáciu {1}
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Wrapping up,Balenie
DocType: Bank,Plaid Access Token,Token prístupového kódu
apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,"Obnoviť sa môžete len v prípade, že platnosť vášho členstva vyprší do 30 dní"
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Value must be between {0} and {1},Hodnota musí byť medzi hodnotou {0} a hodnotou {1}
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Choose a corresponding payment,Vyberte zodpovedajúcu platbu
DocType: Quality Feedback,Parameters,parametre
DocType: Shift Type,Auto Attendance Settings,Nastavenia automatického dochádzania
,Sales Partner Transaction Summary,Zhrnutie transakcie obchodného partnera
DocType: Asset Maintenance,Maintenance Manager Name,Názov manažéra údržby
apps/erpnext/erpnext/public/js/controllers/transaction.js,It is needed to fetch Item Details.,Je potrebné načítať Podrobnosti položky.
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,This is based on stock movement. See {0} for details,To je založené na pohybe zásob. Podrobnosti nájdete v časti {0}
DocType: Clinical Procedure,Appointment,vymenovanie
apps/erpnext/erpnext/public/js/utils/party.js,Please enter {0} first,Najprv zadajte hodnotu {0}
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/regional/report/gstr_1/gstr_1.py,Following accounts might be selected in GST Settings:,V nastaveniach GST sa môžu vybrať nasledujúce účty:
DocType: Item,You can use any valid Bootstrap 4 markup in this field. It will be shown on your Item Page.,V tomto poli môžete použiť akékoľvek platné označenie Bootstrap 4. Zobrazí sa na stránke s položkami.
DocType: Serial No,Incoming Rate,Prichádzajúca sadzba
DocType: Cashier Closing,POS-CLO-,POS-CLO-
DocType: Invoice Discounting,Accounts Receivable Discounted Account,Účty Diskontované účty
DocType: Tally Migration,Tally Debtors Account,Účet dlžníkov
DocType: Grant Application,Has any past Grant Record,Má nejaké minulé Grant Record
DocType: POS Closing Voucher,Amount in Custody,Suma vo väzbe
DocType: Drug Prescription,Interval,interval
DocType: Warehouse,Parent Warehouse,Rodičovský sklad
apps/erpnext/erpnext/stock/reorder_item.py,Auto Material Requests Generated,Generované automatické požiadavky na materiál
apps/erpnext/erpnext/controllers/stock_controller.py,Row {0}: Quality Inspection rejected for item {1},Riadok {0}: Kontrola kvality zamietnutá pre položku {1}
DocType: Vehicle,Additional Details,Ďalšie podrobnosti
DocType: Sales Partner Type,Sales Partner Type,Typ obchodného partnera
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,"Select BOM, Qty and For Warehouse","Vyberte položku BOM, Qty a For Warehouse"
DocType: Asset Maintenance Log,Maintenance Type,Typ údržby
DocType: Homepage Section,Use this field to render any custom HTML in the section.,Toto pole sa používa na vykreslenie vlastného kódu HTML v sekcii.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,"Appointment cancelled, Please review and cancel the invoice {0}","Zrušenie schôdzky, skontrolujte a zrušte faktúru {0}"
DocType: Sales Invoice,Time Sheet List,Zoznam pracovných výkazov
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Bill {1} dated {2},{0} proti Billovi {1} zo {2}
DocType: Shopify Settings,For Company,Pre spoločnosť
DocType: Linked Soil Analysis,Linked Soil Analysis,Analýza prepojenej pôdy
DocType: Project,Day to Send,Deň na odoslanie
DocType: Salary Component,Is Tax Applicable,Platí daň
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Purchase Order number required for Item {0},Číslo objednávky vyžadované pre položku {0}
DocType: Item Tax Template,Tax Rates,Daňové sadzby
apps/erpnext/erpnext/templates/pages/search_help.py,Help Results for,Výsledky vyhľadávania pre doménu
DocType: Student Admission,Student Admission,Vstupné pre študentov
DocType: Designation Skill,Skill,zručnosť
DocType: Budget Account,Budget Account,Účet rozpočtu
DocType: Employee Transfer,Create New Employee Id,Vytvoriť nové Id zamestnanca
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} is required for 'Profit and Loss' account {1}.,{0} sa vyžaduje pre účet &#39;Zisk a strata&#39; {1}.
apps/erpnext/erpnext/config/accounting.py,Goods and Services Tax (GST India),Daň z tovarov a služieb (GST India)
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Creating Salary Slips...,Vytváranie platových lístkov ...
DocType: Employee Skill,Employee Skill,Zamestnanecká zručnosť
DocType: Pricing Rule,Apply Rule On Item Code,Použiť kód pravidla
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,'Update Stock' can not be checked because items are not delivered via {0},"&#39;Aktualizovať zásoby&#39; nie je možné skontrolovať, pretože položky nie sú dodané prostredníctvom {0}"
DocType: Journal Entry,Stock Entry,Vstup do skladu
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Prosím nastavte číslovaciu sériu pre dochádzku cez Setup&gt; Numbering Series
apps/erpnext/erpnext/regional/india/utils.py,House rent paid days overlapping with {0},Platené nájomné dni sa prekrývajú s {0}
DocType: Employee,Current Address Is,Aktuálna adresa je
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Analyst,analytik
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,No records found in the Payment table,V tabuľke platieb neboli nájdené žiadne záznamy
DocType: Email Digest,Sales Orders to Deliver,Zákazky odberateľa na dodanie
DocType: Item,Units of Measure,Merné jednotky
DocType: Leave Block List,Block Days,Blokové dni
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Quantity must not be more than {0},Množstvo nesmie byť väčšie ako {0}
apps/erpnext/erpnext/public/js/utils/item_selector.js,Add Items,Pridať položky
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Pridané dane a poplatky (firemná mena)
DocType: Accounts Settings,Currency Exchange Settings,Nastavenia meny
DocType: Taxable Salary Slab,From Amount,Od sumy
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Warehouse is mandatory,Sklad je povinný
apps/erpnext/erpnext/utilities/user_progress.py,Add Students,Pridať študentov
DocType: Payment Entry,Account Paid From,Účet platený od
DocType: Employee Attendance Tool,Marked Attendance HTML,Označené HTML dochádzky
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} has been disabled,Položka {0} bola zakázaná
DocType: Cheque Print Template,Amount In Figure,Množstvo na obrázku
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Cannot produce more Item {0} than Sales Order quantity {1},Nie je možné vytvoriť viac položky {0} ako množstvo zákazky odberateľa {1}
DocType: Purchase Invoice,Return,spiatočný
apps/erpnext/erpnext/stock/doctype/batch/batch.py,The selected item cannot have Batch,Vybraná položka nemôže mať dávku
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.js,Print IRS 1099 Forms,Tlač IRS 1099 formulárov
apps/erpnext/erpnext/controllers/accounts_controller.py,'Update Stock' cannot be checked for fixed asset sale,„Aktualizácia zásob“ sa nedá kontrolovať pri predaji fixných aktív
DocType: Asset,Depreciation Schedule,Plán odpisov
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule not applicable for country {0},Pre krajinu {0} neplatí pravidlo dodania
DocType: Purchase Receipt,Time at which materials were received,Čas prijatia materiálu
DocType: Tax Rule,Billing Country,Krajina fakturácie
DocType: Journal Entry Account,Sales Order,Predajné objednávky
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Chýba hodnota
apps/erpnext/erpnext/stock/doctype/item/item.py,Stores,obchody
DocType: Exchange Rate Revaluation Account,New Balance In Base Currency,Nový zostatok v základnej mene
DocType: POS Profile,Price List,Cenník
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Synchronize this account,Synchronizovať tento účet
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Invalid {0}: {1},Neplatné číslo {0}: {1}
DocType: Article,Article,článok
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ý tento systém nastavujete."
apps/erpnext/erpnext/utilities/user_progress.py,A Product,Produkt
DocType: Crop,Crop Name,Názov orezania
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,'From Date' is required,Vyžaduje sa „Od dátumu“
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select a BOM,Vyberte kusovník
DocType: Travel Itinerary,Travel Itinerary,Cestovný itinerár
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Birthday Reminder,Pripomienka k narodeninám
apps/erpnext/erpnext/utilities/user_progress.py,Pair,pár
apps/erpnext/erpnext/stock/get_item_details.py,Item Price added for {0} in Price List {1},Položka Cena pridaná za {0} v cenníku {1}
DocType: Pricing Rule,Validate Applied Rule,Overiť platné pravidlo
DocType: Job Card Item,Job Card Item,Položka pracovnej karty
DocType: Homepage,Company Tagline for website homepage,Spoločnosť Tagline pre domovskú stránku webovej stránky
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 pre prioritu {0} v indexe {1}.
DocType: Company,Round Off Cost Center,Nákladové stredisko
DocType: Supplier Scorecard Criteria,Criteria Weight,Kritériá Hmotnosť
DocType: Asset,Depreciation Schedules,Plány odpisov
DocType: Subscription,Discounts,zľavy
DocType: Shipping Rule,Shipping Rule Conditions,Podmienky prepravného pravidla
DocType: Subscription,Cancelation Date,Dátum zrušenia
DocType: Payment Entry,Party Bank Account,Bankový účet strany
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,New Cost Center Name,Názov nového nákladového strediska
DocType: Promotional Scheme Price Discount,Max Amount,Max
DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Po dokončení platby presmerujte používateľa na vybranú stránku.
DocType: Salary Slip,Total Loan Repayment,Úhrada celkového úveru
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,To Fiscal Year,Do fiškálneho roka
DocType: Delivery Note,Return Against Delivery Note,Návrat proti dodaciemu listu
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,"Edit in full page for more options like assets, serial nos, batches etc.","Upraviť na celej stránke pre viac možností, ako sú napríklad aktíva, sériové čísla, dávky atď."
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Allocate Payment Amount,Prideliť čiastku platby
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Returned Item {1} does not exists in {2} {3},Riadok # {0}: Vrátená položka {1} neexistuje v {2} {3}
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js,Enrolling students,Zapísanie študentov
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Povoliť používateľovi upravovať sadzbu cenníka v transakciách
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Please select the document type first,Najprv vyberte typ dokumentu
DocType: Hotel Room Reservation,Hotel Room Reservation,Rezervácia hotelových izieb
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Researcher,výskumník
apps/erpnext/erpnext/accounts/party.py,{0} {1} is frozen,{0} {1} je zmrazené
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item Code cannot be changed for Serial No.,Kód položky nie je možné zmeniť pre sériové číslo
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Celkové dane a poplatky (mena spoločnosti)
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Rule Conflicts with {0},Konflikty daňových pravidiel s {0}
DocType: Fiscal Year,Year End Date,Dátum konca roka
apps/erpnext/erpnext/utilities/activation.py,Create Leads,Vytvorenie potenciálnych zákazníkov
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js,Show zero values,Zobraziť nulové hodnoty
DocType: Employee Onboarding,Employee Onboarding,Zamestnanec Onboarding
DocType: POS Closing Voucher,Period End Date,Dátum ukončenia obdobia
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Passing Score value should be between 0 and 100,Hodnota skóre odovzdávania by mala byť medzi 0 a 100
DocType: Department,The first Leave Approver in the list will be set as the default Leave Approver.,Prvý Leave Approver v zozname bude nastavený ako predvolený Leave Approver.
DocType: POS Settings,POS Settings,Nastavenia POS
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,All Accounts,Všetky účty
DocType: Hotel Room,Hotel Manager,Hotelový manažér
DocType: Opportunity,With Items,S položkami
DocType: GL Entry,Is Advance,Je Advance
DocType: Membership,Membership Status,Stav členstva
apps/erpnext/erpnext/config/crm.py,Sales campaigns.,Predajné kampane.
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Default BOM not found for Item {0} and Project {1},Pre položku {0} a projekt {1} sa nenašiel predvolený kusovník
DocType: Leave Type,Encashment Threshold Days,Dni prahu splynutia
apps/erpnext/erpnext/stock/report/item_prices/item_prices.js,Items Filter,Filtrovať položky
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} je pozastavené do {1}
DocType: Clinical Procedure Item,Invoice Separately as Consumables,Faktúra samostatne ako spotrebný materiál
DocType: Subscription,Days Until Due,Dni do splatnosti
apps/erpnext/erpnext/templates/pages/projects.js,Show Completed,Zobraziť dokončené
apps/erpnext/erpnext/accounts/doctype/bank/bank_dashboard.py,Bank Deatils,Bankové divízie
apps/erpnext/erpnext/utilities/transaction_base.py,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Riadok # {0}: Rýchlosť musí byť rovnaká ako {1}: {2} ({3} / {4})
DocType: Clinical Procedure,HLC-CPR-.YYYY.-,HLC-CPR-.YYYY.-
DocType: Healthcare Settings,Healthcare Service Items,Položky služby zdravotnej starostlivosti
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 3,Rozsah starnutia 3
DocType: Vital Signs,Blood Pressure,Krvný tlak
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/sales_partner_target_variance_based_on_item_group.js,Target On,Zacieliť na
apps/erpnext/erpnext/patches/v11_0/add_healthcare_service_unit_tree_root.py,All Healthcare Service Units,Všetky jednotky služieb zdravotnej starostlivosti
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Program,Povinné pole - Program
apps/erpnext/erpnext/public/js/projects/timer.js,Timer,časomerač
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Nastaviť {0} v kategórii aktív {1} alebo spoločnosti {2}
DocType: Bank Statement Settings Item,Bank Header,Záhlavie banky
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 v tomto programe podľa DOB
DocType: Assessment Criteria,Assessment Criteria Group,Skupina kritérií hodnotenia
DocType: Options,Is Correct,Je správne
apps/erpnext/erpnext/utilities/user_progress.py,user@example.com,user@example.com
DocType: Department,Parent Department,Rodičovské oddelenie
DocType: Employee Internal Work History,Employee Internal Work History,História internej práce zamestnanca
DocType: Supplier,Warn POs,Upozorniť organizácie výrobcov
DocType: Employee,Offer Date,Dátum ponuky
DocType: Sales Invoice,Product Bundle Help,Pomocník pre balík produktov
DocType: Stock Reconciliation,Stock Reconciliation,Zosúladenie zásob
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Accounting Entry for Stock,Účtovná položka pre zásoby
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ôdzka sa prekrýva s {0}. <br> {1} má naplánované stretnutie s {2} na {3} s {4} minútami.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with child nodes cannot be converted to ledger,Sklady s podriadenými uzlami nie je možné konvertovať do hlavnej knihy
DocType: Project,Projects Manager,Manažér projektov
apps/erpnext/erpnext/hr/doctype/training_event/training_event.py,End time cannot be before start time,Čas ukončenia nemôže byť pred časom začiatku
DocType: UOM,UOM Name,Názov UOM
DocType: Vital Signs,BMI,BMI
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Hours,hodiny
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} {2} {3},Suma {0} {1} {2} {3}
,Supplier Ledger Summary,Súhrnný prehľad dodávateľov
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Email ID,ID študentského e-mailu
apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA mandát
DocType: Bank Account,IBAN,IBAN
DocType: Restaurant Reservation,No of People,Počet ľudí
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ží 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á zákaznícku spätnú fakturáciu
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in condition: {0},Chyba syntaxe v stave: {0}
DocType: Bank Transaction,Transaction ID,ID transakcie
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Please enter message before sending,Pred odoslaním zadajte správu
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Ref Date,Ref Dátum
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Poznámka: Toto nákladové stredisko je skupina. Nie je možné vykonať účtovné zápisy voči skupinám.
DocType: Soil Analysis,Soil Analysis Criterias,Kritériá analýzy pôdy
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Packing Slip(s) cancelled,Balenie Slip (y) zrušené
DocType: Company,Existing Company,Existujúca spoločnosť
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batches,dávky
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Defense,obrana
DocType: Item,Has Batch No,Má šaržu č
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Delayed Days,Oneskorené dni
DocType: Lead,Person Name,Meno osoby
DocType: Item Variant,Item Variant,Položka Variant
DocType: Training Event Employee,Invited,pozvaný
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Maximálna suma oprávnená pre komponent {0} presahuje hodnotu {1}
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py,Amount to Bill,Suma pre Billa
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"For {0}, only debit accounts can be linked against another credit entry",Pre položku {0} je možné prepojiť iba iné debetné účty s iným kreditným záznamom
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py,Creating Dimensions...,Vytváranie dimenzií ...
DocType: Bank Statement Transaction Entry,Payable Account,Platobný účet
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Neuvádzajte žiadne požadované návštevy
DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,"Vyberte len v prípade, že máte nastavený dokument Cash Flow Mapper"
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} is a company holiday,{0} je dovolenka spoločnosti
DocType: Item,Items with higher weightage will be shown higher,Vyššie budú zobrazené položky s vyšším vážením
DocType: Project,Project will be accessible on the website to these users,Projekt bude pre týchto užívateľov prístupný na webovej stránke
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute table is mandatory,Tabuľka atribútov je povinná
DocType: Salary Slip,Total Working Hours,Celkový pracovný čas
DocType: Crop,Planting UOM,Výsadba UOM
DocType: Inpatient Record,O Negative,O Negatív
DocType: Purchase Order,To Receive and Bill,Prijať a Bill
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Dátumy začiatku a konca nie sú v platnom období miezd, nie je možné vypočítať {0}."
DocType: POS Profile,Only show Customer of these Customer Groups,Zákazníkovi zobrazte iba tieto Zákaznícke skupiny
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select items to save the invoice,Vyberte položky na uloženie faktúry
DocType: Service Level Priority,Resolution Time,Čas rozlíšenia
DocType: Grading Scale Interval,Grade Description,Popis triedy
DocType: Homepage Section,Cards,karty
DocType: Quality Meeting Minutes,Quality Meeting Minutes,Zápisnica o kvalite stretnutia
DocType: Linked Plant Analysis,Linked Plant Analysis,Analýza prepojených zariadení
apps/erpnext/erpnext/public/js/controllers/transaction.js,Service Stop Date cannot be after Service End Date,Dátum zastavenia služby nemôže byť po dátume ukončenia služby
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Please set B2C Limit in GST Settings.,Nastavte nastavenie B2C v nastaveniach GST.
DocType: Member,Member Name,Meno člena
DocType: Account,Payable,splatný
DocType: Job Card,For Quantity,Pre množstvo
DocType: Territory,For reference,Pre informáciu
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Add to Cart,Pridať do košíka
DocType: Global Defaults,Global Defaults,Globálne predvolené hodnoty
DocType: Leave Application,Follow via Email,Postupujte prostredníctvom e-mailu
DocType: Leave Allocation,Total Leaves Allocated,Celkový počet pridelených listov
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Raw Material,Surový materiál
DocType: Manufacturer,Limited to 12 characters,Obmedzené na 12 znakov
DocType: Selling Settings,Customer Naming By,Zákaznícke pomenovanie podľa
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Packed quantity must equal quantity for Item {0} in row {1},Balené množstvo musí zodpovedať množstvu pre položku {0} v riadku {1}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js,New Sales Person Name,Nové meno predajnej osoby
DocType: Amazon MWS Settings,Amazon will synch data updated after this date,Amazon bude synchronizovať údaje aktualizované po tomto dátume
DocType: Service Day,Service Day,Deň služby
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Odpočítané dane a poplatky (mena spoločnosti)
DocType: Project,Gross Margin %,Hrubá marža%
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Bank Statement balance as per General Ledger,Zostatok bankového výpisu podľa hlavnej knihy
apps/erpnext/erpnext/public/js/setup_wizard.js,Healthcare (beta),Zdravotná starostlivosť (beta)
DocType: Shopify Settings,Default Warehouse to to create Sales Order and Delivery Note,Predvolený sklad na vytvorenie zákazky odberateľa a dodacieho listu
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} v indexe {1} nemôže byť väčší ako Resolution Time.
DocType: Opportunity,Customer / Lead Name,Meno zákazníka / zákazníka
DocType: Student,EDU-STU-.YYYY.-,EDU-STU-.YYYY.-
DocType: Expense Claim Advance,Unclaimed amount,Nevyžiadaná suma
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Source and target warehouse cannot be same for row {0},Zdrojový a cieľový sklad nemôže byť rovnaký pre riadok {0}
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Riadok odpisu {0}: Očakávaná hodnota po dobe životnosti musí byť väčšia alebo rovná {1}
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Please select date,Vyberte dátum
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Salary Structure should have flexible benefit component(s) to dispense benefit amount,Štruktúra miezd by mala mať flexibilnú (é) zložku (zložky) na vyplácanie dávky
DocType: Employee Attendance Tool,Employee Attendance Tool,Nástroj dochádzky zamestnancov
DocType: Employee,Educational Qualification,Kvalifikácia vzdelávania
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Accessable Value,Dostupná hodnota
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: POS Profile,Taxes and Charges,Dane a poplatky
DocType: Opportunity,Contact Mobile No,Kontakt Mobilné č
DocType: Employee,Joining Details,Podrobnosti o pripojení
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Start Job,Spustite úlohu
DocType: Quality Action Table,Quality Action Table,Tabuľka kvality akcií
DocType: Healthcare Practitioner,Phone (Office),Telefón (kancelária)
DocType: Timesheet Detail,Operation ID,ID prevádzky
DocType: Soil Texture,Silt Loam,Silt Loam
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please set the Default Cost Center in {0} company.,Nastavte si štandardné stredisko nákladov v spoločnosti {0}.
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Update Email Group,Aktualizovať e-mailovú skupinu
DocType: Employee Promotion,Employee Promotion Detail,Detail propagácie zamestnancov
DocType: Loan Application,Repayment Info,Informácie o splácaní
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Show unclosed fiscal year's P&L balances,Zobraziť nezaradené zostatky P&amp;L fiškálneho roka
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
					have been quoted. Updating the RFQ quote status.","{0} označuje, že {1} neposkytne cenovú ponuku, ale všetky položky boli citované. Aktualizácia stavu ponuky RFQ."
DocType: Asset,Finance Books,Finančné knihy
DocType: Stock Settings,Role Allowed to edit frozen stock,Úloha Povolená úprava zmrazených zásob
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: Activity Cost,Costing Rate,Miera kalkulácie
DocType: Shipping Rule,example: Next Day Shipping,príklad: Next Day Shipping
DocType: Bank Statement Transaction Entry,Payment Invoice Items,Položky platobnej faktúry
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py,Tasks have been created for managing the {0} disease (on row {1}),Úlohy boli vytvorené na riadenie ochorenia {0} (na riadku {1})
DocType: Healthcare Settings,Confirmation Message,Potvrdzovacia správa
DocType: Lab Test UOM,Lab Test UOM,Laboratórny test UOM
DocType: Leave Type,Earned Leave Frequency,Frekvencia zarobenej dovolenky
DocType: Loyalty Program,Loyalty Program Type,Typ vernostného programu
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,"Shipping Address does not have country, which is required for this Shipping Rule","Prepravná adresa nemá krajinu, ktorá je potrebná pre toto Pravidlo o preprave"
DocType: POS Profile,Terms and Conditions,Podmienky
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule',Kliknite na položku Generovať plán
DocType: Sales Invoice,Total Qty,Celkový počet
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,All other ITC,Všetky ostatné ITC
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Parties and Addresses,Dovozné strany a adresy
DocType: Item,List this Item in multiple groups on the website.,Zoznam tejto položky vo viacerých skupinách na webovej stránke.
DocType: Request for Quotation,Message for Supplier,Správa pre dodávateľa
DocType: Healthcare Practitioner,Phone (R),Telefón (R)
DocType: Maintenance Team Member,Team Member,Člen tímu
DocType: Issue,Service Level Agreement Creation,Vytvorenie Zmluvy o úrovni služieb
DocType: Asset Category Account,Asset Category Account,Účet kategórie aktív
,Team Updates,Aktualizácie tímu
DocType: Bank Account,Party,večierok
DocType: Soil Analysis,Ca/Mg,Ca / Mg
DocType: Purchase Invoice,Write Off Amount (Company Currency),Odpísať čiastku (mena spoločnosti)
DocType: Stock Entry,Including items for sub assemblies,Vrátane položiek pre podzostavy
DocType: Course Topic,Topic Name,Názov témy
DocType: Budget,Applicable on booking actual expenses,Platí pre rezerváciu skutočných výdavkov
DocType: Purchase Invoice,Start date of current invoice's period,Dátum začiatku obdobia faktúry
apps/erpnext/erpnext/utilities/user_progress.py,Litre,liter
DocType: Marketplace Settings,Hub Seller Name,Meno predávajúceho
DocType: Stock Entry,Total Outgoing Value,Celková odchádzajúca hodnota
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill already exists for this document,Pre tento dokument už existuje e-Way Bill
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Auto repeat document updated,Dokument bol automaticky aktualizovaný
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 zahrnúť hodnotu {2} do položky Item rate, musia byť zahrnuté aj riadky {3}"
apps/erpnext/erpnext/config/stock.py,Serial No and Batch,Sériové číslo a šarža
DocType: Contract,Fulfilment Deadline,Termín plnenia
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Vytvoriť pracovnú kartu
,Sales Person Commission Summary,Zhrnutie Komisie pre predajcov
apps/erpnext/erpnext/education/utils.py,Quiz {0} does not exist,Kvíz {0} neexistuje
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,"Cannot process route, since Google Maps Settings is disabled.","Trasu nie je možné spracovať, pretože Nastavenia služby Mapy Google sú zakázané."
apps/erpnext/erpnext/utilities/user_progress.py,Go to Items,Prejsť na položky
DocType: Asset Value Adjustment,Current Asset Value,Aktuálna hodnota majetku
DocType: Support Search Source,Result Preview Field,Pole Výsledok Náhľad
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please enter serial numbers for serialized item ,Zadajte sériové čísla pre serializovanú položku
DocType: GL Entry,Against Voucher Type,Proti typu poukážky
DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Zmluvné podmienky plnenia zmluvy
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Allocating leaves...,Prideľovanie listov ...
DocType: Student Applicant,Admitted,"pripustil,"
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Get Updates,Získať aktualizácie
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Black,čierna
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,"Dátum začiatku alebo konca roka sa prekrýva s hodnotou {0}. Aby ste sa vyhli, nastavte spoločnosť"
apps/erpnext/erpnext/templates/pages/projects.html,Show closed,Zobraziť zatvorené
DocType: Sample Collection,No. of print,Počet výtlačkov
DocType: Sample Collection,HLC-SC-.YYYY.-,HLC-SC-.YYYY.-
