apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Pension Funds,Pokojninski skladi
DocType: Supplier Quotation,Rounding Adjustment (Company Currency,Prilagoditev zaokroževanja (valuta podjetja
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Course is mandatory in row {0},Tečaj je obvezen v vrstici {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Credit Account,Kreditni račun
DocType: Employee Tax Exemption Proof Submission,Submission Date,Datum oddaje
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Template Code,Spremeni kodo predloge
DocType: Expense Claim,Total Sanctioned Amount,Skupni sankcionirani znesek
apps/erpnext/erpnext/accounts/doctype/accounting_period/accounting_period.py,Accounting Period overlaps with {0},Računovodsko obdobje se prekriva z {0}
DocType: Email Digest,New Expenses,Novi stroški
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Healthcare Practitioner not available on {0},Zdravstveni delavec ni na voljo {0}
DocType: Delivery Note,Transport Receipt No,Potrdilo o prevozu št
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Administrative Officer,Upravni uradnik
DocType: Opportunity,Probability (%),Verjetnost (%)
DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,WooCommerce Products,Izdelki WooCommerce
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Account Pay Only,Samo plačilo računa
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 privzete vrednosti, kot so podjetja, valuta, tekoče davčno leto itd."
apps/erpnext/erpnext/config/projects.py,Time Tracking,Spremljanje časa
DocType: Employee Education,Under Graduate,Pod diplomo
DocType: Request for Quotation Item,Supplier Part No,Številka dela dobavitelja
DocType: Journal Entry Account,Party Balance,Balance strank
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Source of Funds (Liabilities),Vir sredstev (obveznosti)
DocType: Payroll Period,Taxable Salary Slabs,Obdavčljive plačne plošče
DocType: Quality Action,Quality Feedback,Povratne informacije o kakovosti
DocType: Support Settings,Support Settings,Nastavitve podpore
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Please enter Production Item first,Najprej vnesite postavko proizvodnje
DocType: Quiz,Grading Basis,Osnova za ocenjevanje
DocType: Stock Entry Detail,Basic Amount,Osnovni znesek
DocType: Journal Entry,Pay To / Recd From,Pay To / Recd From
DocType: BOM,Scrap Material Cost,Stroški materiala za odpadke
DocType: Material Request Item,Received Quantity,Prejeta količina
,Sales Person-wise Transaction Summary,Povzetek transakcijskih transakcijskih oseb
DocType: Communication Medium,Voice,Glas
DocType: Work Order,Actual Operating Cost,Dejanski operativni stroški
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html,Mode of Payments,Način plačila
DocType: Stock Entry,Send to Subcontractor,Pošlji podizvajalcu
DocType: Purchase Invoice,Select Shipping Address,Izberite Naslov dostave
DocType: Student,AB-,AB-
apps/erpnext/erpnext/projects/doctype/project/project.py,Project Summary for {0},Povzetek projekta za {0}
apps/erpnext/erpnext/regional/india/bank_remittance.py,"{0} is mandatory for generating remittance payments, set the field and try again","{0} je obvezen za ustvarjanje plačil z nakazilom, nastavite polje in poskusite znova"
apps/erpnext/erpnext/public/js/hub/marketplace.js,Some emails are invalid,Nekatera e-poštna sporočila niso veljavna
DocType: Asset,Calculate Depreciation,Izračunaj amortizacijo
DocType: Academic Term,Term Name,Ime izraza
DocType: Question,Question,Vprašanje
DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Podkategorija Izjeme
apps/erpnext/erpnext/www/all-products/item_row.html,More Details,Več podrobnosti
DocType: Salary Component,Earning,Služenje
DocType: Restaurant Order Entry,Click Enter To Add,Kliknite Vnos za dodajanje
DocType: Communication Medium Timeslot,Employee Group,Skupina zaposlenih
DocType: Quality Procedure,Processes,Procesi
DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Določite tečaj za pretvorbo ene valute v drugo
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 4,Območje staranja 4
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Warehouse required for stock Item {0},Potrebna skladišča za zalogo Postavka {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.,"Funkcije za ocenjevanje meril za {0} ni bilo mogoče rešiti. Prepričajte se, da je formula veljavna."
DocType: Bank Reconciliation,Include Reconciled Entries,Vključi usklajene vnose
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Dovoli stopnjo ničelne vrednosti
apps/erpnext/erpnext/templates/includes/product_list.js,Nothing more to show.,Nič več za prikaz.
apps/erpnext/erpnext/controllers/buying_controller.py,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Davčna kategorija je bila spremenjena v &quot;Skupaj&quot;, ker so vse postavke na zalogi"
DocType: Salary Detail,Tax on flexible benefit,Davek na fleksibilne dajatve
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py,This is based on the Time Sheets created against this project,"To temelji na časovnih listih, ustvarjenih za ta projekt"
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Rate,Stopnja nakupa
DocType: Water Analysis,Type of Sample,Vrsta vzorca
DocType: Budget,Budget Accounts,Proračunski računi
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} quantity {1} cannot be a fraction,Serijska številka {0} {0} ne more biti del
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock In Hand,Stock In Hand
DocType: Workstation,Wages,Plače
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,No leave record found for employee {0} for {1},Za zaposlenega {0} ni na voljo noben zapis o zapustitvi za {1}
DocType: Invoice Discounting,Accounts Receivable Unpaid Account,Neplačani račun terjatev
DocType: GST Account,SGST Account,Račun 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,Datum polovičnega dneva mora biti med delom od datuma do konca dela
DocType: Employee Boarding Activity,Applicable in the case of Employee Onboarding,Velja v primeru zaposlenega delavca
apps/erpnext/erpnext/controllers/buying_controller.py,Specified BOM {0} does not exist for Item {1},Podana BOM {0} ne obstaja za element {1}
apps/erpnext/erpnext/config/accounting.py,Company (not Customer or Supplier) master.,Podjetje (ni naročnik ali dobavitelj) poveljnik.
DocType: Shopify Settings,Sales Invoice Series,Serija računov za prodajo
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Asset Movement record {0} created,Zapis premikanja sredstva {0} je ustvarjen
DocType: Lab Prescription,Test Created,Ustvarjen test
DocType: Communication Medium,Catch All,Ujemi vse
DocType: Academic Term,Term Start Date,Datum začetka trajanja
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Appointment {0} and Sales Invoice {1} cancelled,Dogodek {0} in prodajni račun {1} sta bila preklicana
DocType: Purchase Receipt,Vehicle Number,Številka vozila
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Your email address...,Vaš email naslov...
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js,Include Default Book Entries,Vključi privzete vnose knjige
DocType: Activity Cost,Activity Type,Vrsta dejavnosti
DocType: Purchase Invoice,Get Advances Paid,Plačan napredek
DocType: Company,Gain/Loss Account on Asset Disposal,Račun dobička / izgube pri odstranitvi sredstev
DocType: GL Entry,Voucher No,Kupon št
DocType: Item,Reorder level based on Warehouse,Spremeni raven na podlagi skladišča
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Prekinjenega delovnega naloga ni mogoče preklicati, najprej prekličite prekinitev"
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,{0} Serial Numbers required for Item {1}. You have provided {2}.,"{0} Serijske številke, potrebne za element {1}. Vnesli ste {2}."
DocType: Customer,Customer Primary Contact,Primarni stik s stranko
DocType: Purchase Order Item Supplied,BOM Detail No,Podrobnosti kosovnice
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Cash In Hand,Denarna sredstva v blagajni
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py,The holiday on {0} is not between From Date and To Date,Počitnice na {0} niso med datumom in datumom
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction can not be converted to group.,Računa z obstoječo transakcijo ni mogoče pretvoriti v skupino.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Timesheet {0} is already completed or cancelled,Časovni list {0} je že dokončan ali preklican
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.","Standardni pogoji in določila, ki jih lahko dodate v prodajo in nakup. Primeri: 1. Veljavnost ponudbe. 1. Plačilni pogoji (vnaprej, na kredit, del predplačilo itd). 1. Kaj je dodatno (ali plačljivo s strani stranke). 1. Opozorilo o varnosti / uporabi. 1. Garancija, če obstaja. 1. Politika vračanja. 1. Pogoji odpreme, če je primerno. 1. Načini reševanja sporov, odškodnine, odgovornosti itd. 1. Naslov in stik vašega podjetja."
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Status Notification,Pusti obvestilo o statusu
DocType: Designation Skill,Designation Skill,Oblikovanje Skill
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},"Količina, potrebna za element {0} v vrstici {1}"
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"To filter based on Party, select Party Type first","Če želite filtrirati glede na stranko, najprej izberite tip pogodbenice"
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,No Salary Structure assigned for Employee {0} on given date {1},"Št. Strukture plač, dodeljene zaposlenemu {0} na določen datum {1}"
DocType: Prescription Duration,Number,Številka
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Ločeno skupino za vsako serijo
DocType: Healthcare Settings,Require Lab Test Approval,Zahtevajte odobritev laboratorijskih testov
DocType: Bank Reconciliation,Update Clearance Date,Datum posodobitve posodobitve
DocType: Chart of Accounts Importer,Import Chart of Accounts from a csv file,Uvozi grafikon računov iz datoteke 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 za javno aplikacijo je opuščena. Nastavite zasebno aplikacijo, za več podrobnosti pa si oglejte uporabniški priročnik"
DocType: Contract,Signed,Podpisano
DocType: Purchase Invoice,Terms and Conditions1,Pogoji in določila1
apps/erpnext/erpnext/hr/doctype/department_approver/department_approver.py,Please select Employee Record first.,Najprej izberite Zapis zaposlenega.
apps/erpnext/erpnext/hr/doctype/hr_settings/hr_settings.py,Password policy for Salary Slips is not set,Pravilnik o geslih za preskok plač ni določen
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() failed for valid IBAN {},BankAccount.validate_iban () ni uspel za veljavni IBAN {}
DocType: Assessment Result Tool,Result HTML,Rezultat HTML
DocType: Agriculture Task,Ignore holidays,Prezri praznike
DocType: Linked Soil Texture,Linked Soil Texture,Povezana tekstura tal
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py,This is based on logs against this Vehicle. See timeline below for details,To temelji na dnevniku tega vozila. Za podrobnosti si oglejte časovni pas spodaj
DocType: Payment Entry,ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-
DocType: Employee,Emergency Contact,Stik v sili
DocType: QuickBooks Migrator,Authorization URL,URL za avtorizacijo
DocType: Attendance,On Leave,Na dopustu
DocType: Item,Show a slideshow at the top of the page,Pokaži diaprojekcijo na vrhu strani
DocType: Cheque Print Template,Payer Settings,Nastavitve plačnika
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Set Tax Rule for shopping cart,Nastavite davčno pravilo za nakupovalni voziček
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,In Production,V izdelavi
DocType: Payment Entry,Payment References,Reference plačil
DocType: Fee Validity,Valid Till,Veljavno do
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0}: From {0} of type {1},{0}: Od {0} vrste {1}
DocType: Request for Quotation Item,Project Name,Ime Projekta
DocType: Purchase Invoice Item,Stock Qty,Količina zaloge
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Otroška postavka ne bi smela biti paket izdelkov. Odstranite element &quot;{0}&quot; in shranite
DocType: Support Search Source,Response Result Key Path,Ključna pot rezultatov odgovora
DocType: Travel Request,Fully Sponsored,V celoti sponzoriran
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py,Not permitted. Please disable the Service Unit Type,Ni dovoljeno. Izključite vrsto storitvene enote
DocType: POS Profile,Offline POS Settings,Offline POS nastavitve
DocType: Supplier Scorecard Period,Calculations,Izračuni
DocType: Production Plan,Material Requested,Zahtevani material
DocType: Payment Reconciliation Payment,Reference Row,Referenčna vrstica
DocType: Leave Policy Detail,Annual Allocation,Letna dodelitev
DocType: Buying Settings,Subcontract,Podizvajanje
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Valuation type charges can not marked as Inclusive,Stroški vrednotenja ne morejo biti označeni kot vključujoči
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} does not belong to company: {2},Račun {0}: nadrejeni račun {1} ne pripada podjetju: {2}
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Prijava ni uspela
apps/erpnext/erpnext/config/buying.py,Items and Pricing,Postavke in cene
DocType: Payment Terms Template,Payment Terms Template,Predloga plačilnih pogojev
DocType: Employee,Previous Work Experience,Prejšnje delovne izkušnje
DocType: Assessment Plan,Program,Programa
DocType: Antibiotic,Healthcare,Skrb za zdravje
DocType: Complaint,Complaint,Pritožba
DocType: Shipping Rule,Restrict to Countries,Omeji na države
DocType: Hub Tracked Item,Item Manager,Upravitelj izdelkov
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Currency of the Closing Account must be {0},Valuta zaključnega računa mora biti {0}
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Budgets,Proračuni
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Opening Invoice Item,Odpiranje postavke na računu
DocType: Work Order,Plan material for sub-assemblies,Načrtujte material za podsestave
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Hardware,Strojna oprema
DocType: Budget,Action if Annual Budget Exceeded on MR,"Ukrep, če je letni proračun presežen na ZD"
DocType: Sales Invoice Advance,Advance Amount,Predhodni znesek
DocType: Accounting Dimension,Dimension Name,Ime dimenzije
DocType: Delivery Note Item,Against Sales Invoice Item,Proti prodajnemu računu postavka
DocType: Expense Claim,HR-EXP-.YYYY.-,HR-EXP-.YYYY.-
DocType: BOM Explosion Item,Include Item In Manufacturing,Vključi postavko v predelovalnih dejavnostih
DocType: Item Reorder,Check in (group),Prijava v (skupina)
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,"Ne pokažite simbolov, kot sta $ etc, poleg valut."
DocType: Additional Salary,Salary Component Type,Tip komponente plač
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shareholder does not belong to this company,Delničar ne pripada tej družbi
DocType: Payment Term,Day(s) after the end of the invoice month,Dan (i) po koncu meseca računa
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Vehicle Type,Tip vozila
DocType: Antibiotic,Healthcare Administrator,Administrator zdravstvenega varstva
DocType: Tax Withholding Rate,Single Transaction Threshold,Enotni prag transakcij
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Broadcasting,Oddaja
DocType: Support Search Source,Post Title Key,Ključ naslova objave
DocType: Customer,Customer Primary Address,Primarni naslov stranke
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select batches for batched item ,Izberite pakete za paketni element
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Are you sure you want to make credit note?,"Ali ste prepričani, da želite beležiti?"
DocType: Pricing Rule,Min Qty,Min
DocType: Payment Entry,Payment Deductions or Loss,Odbitki plačila ali izguba
DocType: Purchase Taxes and Charges,On Item Quantity,Na količino izdelka
apps/erpnext/erpnext/config/manufacturing.py,Replace BOM and update latest price in all BOMs,Zamenjajte BOM in posodobite najnovejšo ceno v vseh BOM
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Both Trial Period Start Date and Trial Period End Date must be set,Nastaviti je treba začetni datum preskusnega obdobja in datum končnega obdobja
apps/erpnext/erpnext/templates/pages/projects.html,No time sheets,Ni časovnih listov
DocType: Bank Statement Settings,Statement Header Mapping,Preslikava glave izjave
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Half Day,Označi pol dneva
DocType: Stock Entry,Material Transfer for Manufacture,Prenos materiala za proizvodnjo
DocType: Supplier,Block Supplier,Block Supplier
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter Woocommerce Server URL,Vnesite URL strežnika Woocommerce
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Place,Od kraja
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,No contacts with email IDs found.,Ni najdenih stikov z e-poštnimi ID-ji.
DocType: Clinical Procedure,Consumption Invoiced,Poraba fakturirana
DocType: Bin,Requested Quantity,Zahtevana količina
DocType: Student,Exit,Izhod
DocType: Delivery Stop,Dispatch Information,Informacije o pošiljanju
DocType: BOM Scrap Item,Basic Amount (Company Currency),Osnovni znesek (valuta podjetja)
DocType: Selling Settings,Selling Settings,Nastavitve prodaje
apps/erpnext/erpnext/education/doctype/question/question.py,A question must have more than one options,Vprašanje mora imeti več kot eno možnost
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Please set the Date Of Joining for employee {0},Nastavite datum združevanja za zaposlenega {0}
apps/erpnext/erpnext/public/js/hub/components/profile_dialog.js,About your company,O vašem podjetju
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} does not exist,Fiskalno leto {0} ne obstaja
DocType: Sales Invoice,Unpaid and Discounted,Neplačani in diskontirani
DocType: Attendance,Leave Application,Zapusti aplikacijo
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Maintenance Log,Dnevnik vzdrževanja
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid Posting Time,Neveljaven čas objavljanja
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Discount,Popust
DocType: Sales Invoice,Redeem Loyalty Points,Izkoristite točke zvestobe
DocType: Shopping Cart Settings,Quotation Series,Serija ponudb
DocType: Guardian,Occupation,Poklic
DocType: Item,Opening Stock,Odpiranje zalog
DocType: Supplier Scorecard,Supplier Score,Ocena dobavitelja
DocType: POS Profile,Only show Items from these Item Groups,Prikaži samo elemente iz teh skupin izdelkov
DocType: Sales Invoice,Overdue and Discounted,Zapadli in popustili
DocType: Job Card Time Log,Time In Mins,Čas v min
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Item {0} does not exist in the system or has expired,Element {0} ne obstaja v sistemu ali je potekel
DocType: Pricing Rule,Price Discount Scheme,Shema popusta na cene
DocType: Vital Signs,Hyper,Hyper
apps/erpnext/erpnext/public/js/setup_wizard.js,What does it do?,Kaj to naredi?
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Summary Saved,Povzetek klica je shranjen
,Sales Invoice Trends,Trendi prodajnega računa
DocType: Bank Reconciliation,Payment Entries,Plačilni vnosi
DocType: Employee Education,Class / Percentage,Razred / odstotek
,Electronic Invoice Register,Elektronski register računa
DocType: Shift Type,The number of occurrence after which the consequence is executed.,"Število dogodkov, po katerem se izvede posledica."
DocType: Sales Invoice,Is Return (Credit Note),Je vrnitev (kreditna opomba)
DocType: Price List,Price Not UOM Dependent,Cena ni UOM odvisna
DocType: Lab Test Sample,Lab Test Sample,Laboratorijski testni vzorec
DocType: Shopify Settings,status html,stanje html
DocType: Fiscal Year,"For e.g. 2012, 2012-13","Za npr. 2012, 2012-13"
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,disabled user,onemogočen uporabnik
DocType: Amazon MWS Settings,ES,ES
DocType: Warehouse,Warehouse Type,Vrsta skladišča
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Quick Journal Entry,Hitri vnos v dnevnik
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Potrošeni znesek
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Already completed,Že končano
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Pending Amount,Čakajoči znesek
DocType: Supplier,Warn RFQs,Opozorilo RFQ
DocType: Lab Prescription,Lab Prescription,Laboratorijski recept
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,"Vrstica amortizacije {0}: naslednji datum amortizacije ne more biti pred datumom, ki je na voljo za uporabo"
DocType: Certification Application,USD,ameriški dolar
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,"Asset {0} cannot be scrapped, as it is already {1}","Sredstva {0} ni mogoče razrezati, saj je že {1}"
DocType: Delivery Trip,Departure Time,Čas odhoda
DocType: Donor,Donor Type,Vrsta darovalca
DocType: Company,Monthly Sales Target,Mesečni cilj prodaje
DocType: Loyalty Point Entry Redemption,Redemption Date,Datum odkupa
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Approving User cannot be same as user the rule is Applicable To,Odobritev uporabnika ne more biti enaka kot pravilo Uporablja se
DocType: Fee Schedule Student Group,Fee Schedule Student Group,Razpored plačil Študentska skupina
apps/erpnext/erpnext/projects/report/billing_summary.py, From Date can not be greater than To Date,Od datuma ne more biti daljši od datuma
apps/erpnext/erpnext/public/js/queries.js,Please specify a {0},Navedite {0}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To GSTIN,Za GSTIN
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Datum konca obdobja ne sme biti prej kot datum začetka izraza. Popravite datume in poskusite znova.
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,No Employee Found,Ni najdenega zaposlenega
DocType: Employee Tax Exemption Declaration Category,Exemption Category,Kategorija izjeme
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Disbursement Entry,Ustvarite vnos za izplačilo
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Purpose must be one of {0},Namen mora biti eden od {0}
DocType: Content Activity,Last Activity ,Zadnja aktivnost
DocType: Crop Cycle,A link to all the Locations in which the Crop is growing,"Povezava z vsemi lokacijami, kjer rastlina raste"
apps/erpnext/erpnext/education/doctype/course_activity/course_activity.py,Course Enrollment {0} does not exists,Vnos predmeta {0} ne obstaja
apps/erpnext/erpnext/hr/doctype/leave_policy/leave_policy.py,Maximum leave allowed in the leave type {0} is {1},Največji dovoljeni dopust v vrsti dopusta {0} je {1}
,Qty to Transfer,Količina za prenos
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please identify/create Account (Group) for type - {0},Prepoznajte / ustvarite račun (skupina) za vrsto - {0}
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Please set default customer group and territory in Selling Settings,V nastavitvah za prodajo nastavite privzeto skupino uporabnikov in ozemlje
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,There isn't any item variant for the selected item,Za izbrano postavko ni nobene variacije elementa
DocType: Contract,Contract Details,Podrobnosti pogodbe
DocType: Customer,"Select, to make the customer searchable with these fields","Izberite, če želite uporabniku omogočiti iskanje s temi polji"
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Actual,Skupno dejansko
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Code,Spremeni kodo
DocType: Crop,Planting Area,Območje sajenja
DocType: Leave Control Panel,Employee Grade (optional),Stopnja zaposlenih (neobvezno)
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Cost Center For Item with Item Code ',Mesto stroškov za element s kodo postavke &quot;
DocType: Stock Settings,Default Stock UOM,Privzeta vrednost UOM za zalogo
DocType: Workstation,Rent Cost,Cena najema
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Result,Rezultat usposabljanja
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order not created,Delovni nalog ni ustvarjen
apps/erpnext/erpnext/utilities/user_progress.py,Meter,Meter
DocType: Course,Hero Image,Slika junaka
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,No Items to pack,Ni elementov za pakiranje
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Delivery warehouse required for stock item {0},Potrebno skladišče dostave za postavko zaloge {0}
apps/erpnext/erpnext/controllers/buying_controller.py,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Rezervirano skladišče je obvezno za element {0} v dobavljenih surovinah
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Target Location is required for the asset {0},Ciljna lokacija je potrebna za sredstvo {0}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,SGST Amount,Znesek SGST
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'",Stanje v računu že v kreditu ni dovoljeno nastaviti »Stanje mora biti« kot »bremenitev«
DocType: GSTR 3B Report,GSTR 3B Report,Poročilo GSTR 3B
DocType: BOM Item,Rate & Amount,Stopnja in znesek
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To is required,Zahtevana je obremenitev
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Item Name,Ime predmeta
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of New Purchase,Stroški novega nakupa
DocType: Customer,Additional information regarding the customer.,Dodatne informacije o stranki.
DocType: Quiz Result,Wrong,Napačno
apps/erpnext/erpnext/config/help.py,Batch Inventory,Serijski inventar
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Unable to find Salary Component {0},Komponente plač ni mogoče najti {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.","Plačilni listek, ki ste ga poslali zaposlenemu, bo zaščiten z geslom, geslo bo ustvarjeno na podlagi pravilnika o geslih."
DocType: Payment Entry,Received Amount,Prejeti znesek
DocType: Item,Is Sales Item,Je prodajna postavka
apps/erpnext/erpnext/accounts/doctype/payment_order/regional/india.js,Generate Text File,Ustvari besedilno datoteko
DocType: Item,Variants,Različice
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","Stroški bodo porazdeljeni sorazmerno glede na količino artikla ali znesek, glede na vaš izbor"
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Pending activities for today,Trenutno potekajoče dejavnosti
DocType: Quality Procedure Process,Quality Procedure Process,Postopek kakovosti
DocType: Fee Schedule Program,Student Batch,Študentska serija
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Valuation Rate required for Item in row {0},"Stopnja vrednotenja, zahtevana za postavko v vrstici {0}"
DocType: BOM Operation,Base Hour Rate(Company Currency),Osnovna urna postavka (valuta podjetja)
apps/erpnext/erpnext/education/doctype/question/question.py,No correct answer is set for {0},Ni pravilnega odgovora za {0}
DocType: Job Offer,Printing Details,Tiskanje podrobnosti
DocType: Asset Repair,Manufacturing Manager,Vodja proizvodnje
DocType: BOM,Job Card,Job Card
DocType: Subscription Settings,Prorate,Proraz
DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","ID uporabnika sistema (prijava). Če je nastavljena, bo postala privzeta za vse obrazce HR."
apps/erpnext/erpnext/public/js/pos/pos.html,All Item Groups,Vse skupine postavk
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Status,Izberite Status
DocType: Subscription Plan,Fixed rate,Fiksna obrestna mera
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Airline,Letalski prevoznik
DocType: Quotation,Term Details,Podrobnosti o pogojih
DocType: Vehicle,Acquisition Date,Datum pridobitve
DocType: SMS Center,Send To,Pošlji
apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py,Average Rate,Povprečna stopnja
DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Nastavi količino transakcij na osnovi vnosa zaporednih številk
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Advance account currency should be same as company currency {0},Valuta vnaprejšnjega računa mora biti enaka valuti podjetja {0}
apps/erpnext/erpnext/portal/doctype/homepage/homepage.js,Customize Homepage Sections,Prilagodi odseke domače strani
apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Nastavite Sistem za poimenovanje inštruktorja v izobraževanju&gt; Nastavitve izobraževanja
DocType: GSTR 3B Report,October,Oktober
DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Skrij davčni ID naročnika iz transakcij prodaje
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! A GSTIN must have 15 characters.,Neveljaven GSTIN! GSTIN mora imeti 15 znakov.
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Pricing Rule {0} is updated,Pravilo o določanju cen {0} je posodobljeno
DocType: Contract Fulfilment Checklist,Contract Fulfilment Checklist,Kontrolni seznam za izpolnitev pogodbe
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py,All Products,Vsi izdelki
apps/erpnext/erpnext/www/all-products/index.html,Product Search,Iskanje izdelkov
DocType: Salary Slip,Net Pay,Neto plača
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,{0} bank transaction(s) created and {1} errors,Ustvarjenih {0} bančnih transakcij in {1} napak
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py,Total Invoiced Amt,Skupaj fakturirani amt
DocType: Clinical Procedure,Consumables Invoice Separately,Potrošni material Račun ločeno
DocType: Shift Type,Working Hours Threshold for Absent,Prag dela za odsoten
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}.,Sporazum o ravni storitev je spremenjen v {0}.
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Budget cannot be assigned against Group Account {0},Proračuna ni mogoče dodeliti za skupinski račun {0}
DocType: Purchase Receipt Item,Rate and Amount,Stopnja in znesek
DocType: Patient Appointment,Check availability,Preveri razpoložljivost
apps/erpnext/erpnext/public/js/controllers/transaction.js,Cannot find Item with this barcode,Elementa s to črtno kodo ni mogoče najti
DocType: Hotel Settings,Default Invoice Naming Series,Privzeta serija imenovanja računa
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.","Če {0} {1} količine elementa <b>{2}</b> , se bo na elementu uporabila shema <b>{3}</b> ."
DocType: Student Siblings,Student Siblings,Študentske sestre
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Journal Entry {0} does not have account {1} or already matched against other voucher,Vnos dnevnika {0} nima računa {1} ali se že ujema z drugim kuponom
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Pravni stroški
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html,Checkout,Preveri
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Membership Details,Podrobnosti o članstvu
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Customer Address,Nastavite naslov stranke
apps/erpnext/erpnext/utilities/user_progress.py,List your products or services that you buy or sell.,"Navedite svoje izdelke ali storitve, ki jih kupujete ali prodajate."
DocType: Account,Income,dohodek
DocType: Account,Rate at which this tax is applied,"Stopnja, po kateri se ta davek uporablja"
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Payment Receipt Note,Opomba o prejemu plačila
DocType: Asset Finance Book,In Percentage,V odstotku
apps/erpnext/erpnext/config/buying.py,Quotations received from Suppliers.,Ponudbe dobaviteljev.
DocType: Journal Entry Account,Reference Due Date,Referenčni rok zapadlosti
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Lead Time Days,Dnevi časa vodenja
DocType: Quality Goal,Revision and Revised On,Revizija in Revised On
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Purchase Order {1},{0} proti naročilu za nakup {1}
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py,Fee Records Created - {0},Ustvarjeni podatki o plačilih - {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Note: {0},Opomba: {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} has already been received,Serijska številka {0} je že prejeta
DocType: HR Settings,Leave Settings,Zapusti nastavitve
DocType: Delivery Note,Issue Credit Note,Opomba k izdaji
,Batch Item Expiry Status,Status izteka paketne postavke
apps/erpnext/erpnext/config/stock.py,Stock Transactions,Transakcije z zalogami
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html,Event Location,Lokacija dogodka
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Motion Picture & Video,Film in video
DocType: Crop,Row Spacing,Razmik vrstic
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.,Številka računa za račun {0} ni na voljo. <br> Pravilno nastavite računski račun.
DocType: Cheque Print Template,Starting location from left edge,Začetna lokacija z levega roba
DocType: HR Settings,HR Settings,Nastavitve HR
DocType: Healthcare Practitioner,Appointments,Imenovanja
apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Ustvarjeno sredstvo {0}
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Planned Qty for Item {0} at row {1},Vnesite načrtovano količino za element {0} v vrstici {1}
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch,Izberite Paket
DocType: BOM,Item Description,opis izdelka
DocType: Account,Account Name,Ime računa
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Key,Vnesite uporabniški ključ API
DocType: Products Settings,Products per Page,Izdelki na stran
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Duplicate {0} found in the table,V tabeli najdete dvojnik {0}
DocType: Global Defaults,Default Distance Unit,Privzeta enota za razdaljo
DocType: Clinical Procedure,Consume Stock,Potrošna zaloga
DocType: Appraisal Template Goal,Key Performance Area,Ključno območje uspešnosti
apps/erpnext/erpnext/selling/report/pending_so_items_for_purchase_request/pending_so_items_for_purchase_request.py,S.O. No.,SO ne.
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,{0} not found for item {1},{0} ni na voljo za element {1}
DocType: Sales Invoice,Set Source Warehouse,Nastavite skladišče virov
DocType: Healthcare Settings,Out Patient Settings,Nastavitve bolnika
DocType: Asset,Insurance End Date,Datum konca zavarovanja
DocType: Bank Account,Branch Code,Kodeks podružnice
apps/erpnext/erpnext/public/js/conf.js,User Forum,Uporabniški forum
DocType: Landed Cost Item,Landed Cost Item,Postavka iztovorjene cene
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The seller and the buyer cannot be the same,Prodajalec in kupec ne moreta biti enaka
DocType: Project,Copied From,Kopirano iz
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Available,Na voljo
DocType: Sales Person,Sales Person Targets,Cilji prodajne osebe
DocType: BOM Operation,BOM Operation,Delovanje BOM-a
DocType: Student,O-,O-
DocType: Repayment Schedule,Interest Amount,Znesek obresti
DocType: Water Analysis,Origin,Izvor
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Add a new address,Dodajte nov naslov
DocType: POS Profile,Write Off Account,Napiši račun
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal/Price Quote,Predlog / cena
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Associate,Pridružen
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Please input all required Result Value(s),Vnesite vse zahtevane vrednosti rezultatov
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Predložena postavka naročila
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Item {0} is not a serialized Item,Element {0} ni serijski element
DocType: GoCardless Mandate,GoCardless Customer,Stranka GoCardless
DocType: Leave Encashment,Leave Balance,Pusti ravnovesje
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance Schedule {0} exists against {1},Urnik vzdrževanja {0} obstaja proti {1}
DocType: Assessment Plan,Supervisor Name,Ime nadzornika
DocType: Selling Settings,Campaign Naming By,Oglaševalska akcija poimenovanja
DocType: Student Group Creation Tool Course,Course Code,Šifra predmeta
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Aerospace,Aerospace
DocType: Landed Cost Voucher,Distribute Charges Based On,"Porazdeli stroške, ki temeljijo na"
DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Merila za točkovanje s kazalcem dobaviteljev
DocType: Account,Stock,Zaloga
DocType: Landed Cost Item,Receipt Document Type,Vrsta dokumenta za prejem
DocType: Territory,Classification of Customers by region,Klasifikacija kupcev po regijah
DocType: Hotel Room Amenity,Billable,Obračunaj
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Government,Vlado
apps/erpnext/erpnext/utilities/activation.py,"Create Employee records to manage leaves, expense claims and payroll","Ustvarite zapise zaposlenih za upravljanje listov, odškodninskih zahtevkov in plačilnih listov"
apps/erpnext/erpnext/config/help.py,Point-of-Sale,Prodajno mesto
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","Elementa {0} v vrstici {1} ni mogoče preveč zaračunati za več kot {2}. Če želite omogočiti prekomerno zaračunavanje, nastavite v nastavitvah zalog"
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner.py,User {0} is already assigned to Healthcare Practitioner {1},Uporabnik {0} je že dodeljen zdravstvenemu delavcu {1}
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Buying,Standardno nakupovanje
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Apprentice,Vajenec
apps/erpnext/erpnext/utilities/activation.py,Add Timesheets,Dodajte urnike
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Number of new Account, it will be included in the account name as a prefix",Število novega računa bo vključeno v ime računa kot predpona
apps/erpnext/erpnext/controllers/buying_controller.py,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Skladišče dobavitelja je obvezno za podizvajalski prevzem
apps/erpnext/erpnext/hr/doctype/employee/employee.js,Please enter Preferred Contact Email,Vnesite želeni e-poštni naslov za stik
DocType: Vital Signs,Normal,Normalno
DocType: Customer,Customer POS Id,ID stranke POS
DocType: Purchase Invoice Item,Weight Per Unit,Teža na enoto
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,Child nodes can be only created under 'Group' type nodes,Otroška vozlišča se lahko ustvarijo samo v vozliščih tipa „Skupina“
DocType: Share Transfer,(including),(vključno)
,Requested,Zahtevano
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is not a stock Item,Postavka {0} ni stalež
DocType: Journal Entry,Multi Currency,Več valut
DocType: Payment Entry,Write Off Difference Amount,Odpis Razlika Znesek
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is disabled,Element {0} je onemogočen
DocType: Asset Maintenance Task,Last Completion Date,Zadnji datum dokončanja
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py,Fulfillment,Izpolnitev
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",Naloga je bila uvrščena v ozadje. V primeru kakršne koli težave pri obdelavi v ozadju bo sistem dodal komentar o napaki na tej uskladitvi zalog in se vrnil v fazo osnutka.
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Total Order Considered,Skupni naročilo je bilo obravnavano
DocType: Delivery Trip,Optimize Route,Optimiziraj pot
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.,Odstotek popusta se lahko uporabi za cenik ali za celoten cenik.
DocType: Training Event,Trainer Email,E-naslov trenerja
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Get from Patient Encounter,Pridite s srečanjem s pacienti
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Software Developer,Razvijalec programske opreme
DocType: Clinical Procedure Template,Sample Collection,Zbiranje vzorcev
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',"Podajte svoje povratne informacije o usposabljanju, tako da kliknete »Povratne informacije o usposabljanju« in nato »Novo«"
DocType: QuickBooks Migrator,Connecting to QuickBooks,Povezovanje z QuickBooks
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Enrolling student,Vpis študenta
DocType: Employee Advance,Claimed,Zahtevano
apps/erpnext/erpnext/config/hr.py,Leaves,Listi
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Razpad plač na podlagi zaslužka in odbitka.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Structure Missing,Manjka struktura plač
DocType: Setup Progress Action,Action Field,Polje dejanja
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill JSON can only be generated from Sales Invoice,E-Way Bill JSON je mogoče ustvariti samo iz prodajnega računa
,Quotation Trends,Trendi ponudb
apps/erpnext/erpnext/config/integrations.py,Connect Amazon with ERPNext,Povežite Amazon z ERPNext
DocType: Service Level Agreement,Response and Resolution Time,Odziv in čas reševanja
DocType: Loyalty Program,Collection Tier,Zbirna stopnja
DocType: Guardian,Guardian Of ,Skrbnik
DocType: Payment Request,Payment Gateway Details,Podrobnosti o plačilnem prehodu
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,Staffing Plan {0} already exist for designation {1},Kadrovski načrt {0} že obstaja za oznako {1}
DocType: Item,Website Warehouse,Spletno skladišče
DocType: Sales Invoice Item,Rate With Margin,Stopnja z maržo
apps/erpnext/erpnext/regional/india/utils.py,Salary Structure must be submitted before submission of Tax Ememption Declaration,Struktura plač mora biti predložena pred predložitvijo Deklaracije o davčni oprostitvi
apps/erpnext/erpnext/public/js/event.js,Add Leads,Dodaj vodnike
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reserve Warehouse,Rezervno skladišče
DocType: Payment Term,Payment Term Name,Ime plačilnega roka
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,No Permission,Brez dovoljenja
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Company...,Izberite podjetje ...
DocType: Stock Settings,Use Naming Series,Uporabite niz imen
DocType: Salary Component,Formula,Formula
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on Actual,"Dejanje, če je skupni mesečni proračun presežen na dejanski"
DocType: Leave Type,Allow Encashment,Dovoli izplačilo
apps/erpnext/erpnext/config/projects.py,Project activity / task.,Projektna dejavnost / naloga.
DocType: Bank Statement Transaction Invoice Item,Bank Statement Transaction Invoice Item,Postavka računa transakcijskega izkaza
DocType: Work Order,Total Operating Cost,Skupni obratovalni stroški
DocType: Employee Onboarding,Employee Onboarding Template,Predloga za zaposlene
DocType: Pricing Rule,Same Item,Ista toč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","Znesek za posamezno transakcijo presega največji dovoljeni znesek, ustvarite ločen plačilni nalog z razdelitvijo transakcij"
DocType: Payroll Entry,Salary Slips Created,Izplačane plače
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,Lab Test(s) ,Laboratorijski testi
DocType: Bank Account,Party Details,Podrobnosti stranke
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Purchased Items,Stroški nabavljenih predmetov
apps/erpnext/erpnext/support/doctype/issue/issue.js,All communications including and above this shall be moved into the new Issue,"Vsa sporočila, vključno s temi in nad njimi, se prenesejo v novo izdajo"
DocType: Stock Entry,Material Consumption for Manufacture,Poraba materiala za proizvodnjo
DocType: Item Website Specification,Table for Item that will be shown in Web Site,"Tabela za postavko, ki bo prikazana na spletnem mestu"
DocType: Restaurant Menu,Restaurant Menu,Meni restavracije
DocType: Asset Movement,Purpose,Namen
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,Salary Structure Assignment for Employee already exists,Dodelitev strukture plač za zaposlenega že obstaja
DocType: Clinical Procedure,Service Unit,Servisna enota
DocType: Travel Request,Identification Document Number,Številka identifikacijskega dokumenta
DocType: Stock Entry,Additional Costs,Dodatni stroški
DocType: Employee Education,Employee Education,Izobraževanje zaposlenih
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.js,Number of positions cannot be less then current count of employees,Število pozicij ne sme biti manjše od trenutnega števila zaposlenih
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Customer Groups,Vse skupine strank
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Price List,Odkup cenikov
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Finished Good Item Code,Dokončana dobra koda izdelka
apps/erpnext/erpnext/controllers/accounts_controller.py,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,"Za datum {0} obstaja več fiskalnih let. Prosimo, določite podjetje v poslovnem letu"
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available for use date is required,"Potreben je datum, ki je na voljo za uporabo"
DocType: Employee Training,Training Date,Datum usposabljanja
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Branje naložene datoteke
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material Request,Zahteva za material
DocType: Payment Entry,Total Allocated Amount (Company Currency),Skupni dodeljeni znesek (valuta podjetja)
DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Vnos naročila v restavraciji
DocType: Delivery Stop,Distance,Razdalja
DocType: Amazon MWS Settings,Get financial breakup of Taxes and charges data by Amazon ,Pridobite finančni razrez podatkov o davkih in dajatvah s strani Amazona
DocType: Vehicle Service,Mileage,Prevožena kilometra
apps/erpnext/erpnext/controllers/status_updater.py,"For an item {0}, quantity must be positive number",Za postavko {0} mora biti količina pozitivna
apps/erpnext/erpnext/public/js/pos/pos.html,Item Cart,Postavka Košarica
apps/erpnext/erpnext/accounts/utils.py,Payment Entries {0} are un-linked,Plačilni vnosi {0} niso povezani
DocType: Email Digest,Open Notifications,Odpri obvestila
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Successfully created payment entries,Uspešno ustvarjeni vnosi plačil
DocType: Soil Analysis,Mg/K,Mg / K
DocType: Item,Has Serial No,Ima serijsko št
DocType: Asset Maintenance,Manufacturing User,Uporabnik proizvodnje
apps/erpnext/erpnext/accounts/doctype/account/account.js,Ledger,Ledger
DocType: Journal Entry Account,Loan,Posojilo
DocType: Vehicle,Fuel UOM,Gorivo UOM
DocType: Issue,Support,Podpora
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid Company for Inter Company Transaction.,Neveljavna družba za medpodjetniško transakcijo.
DocType: Company,Fixed Asset Depreciation Settings,Nastavitve amortizacije fiksnih sredstev
DocType: Employee,Department and Grade,Oddelek in razred
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Cheques Required,Potrebno preverjanje
DocType: Lead,Do Not Contact,Ne kontaktirajte
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Expense,New Expense
DocType: Sales Invoice,Update Billed Amount in Sales Order,Posodobi obračunani znesek v prodajnem nalogu
DocType: Travel Itinerary,Meal Preference,Prednost obroka
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:","Tudi če obstaja več prednostnih pravil za določanje cen, se uporabijo naslednje notranje prednostne naloge:"
DocType: Item,Over Delivery/Receipt Allowance (%),Nadomestilo za dobavo / prejem (%)
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} is not active or does not exist,Zaposleni {0} ni aktiven ali ne obstaja
apps/erpnext/erpnext/config/accounting.py,List of all share transactions,Seznam vseh transakcij z delnicami
DocType: Item Default,Sales Defaults,Privzete prodajne vrednosti
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Overlap in scoring between {0} and {1},Prekrivanje rezultatov med {0} in {1}
DocType: Course Assessment Criteria,Weightage,Teža
DocType: Bank Statement Transaction Entry,Create New Payment/Journal Entry,Ustvari novo plačilo / vnos dnevnika
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.","Če sta na podlagi zgornjih pogojev ugotovljeni dve ali več cenovnih pravil, se uporabi prednost. Prednost je število med 0 in 20, privzeta vrednost pa je nič (prazno). Višje število pomeni, da ima prednost, če obstaja več pravil za določanje cen z enakimi pogoji."
apps/erpnext/erpnext/controllers/selling_controller.py,Row {0}: Qty is mandatory,Vrstica {0}: Količina je obvezna
DocType: Sales Invoice,Against Income Account,Račun dohodkov
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Vrstica # {0}: računa za nakup ni mogoče ustvariti za obstoječe sredstvo {1}
apps/erpnext/erpnext/config/buying.py,Rules for applying different promotional schemes.,Pravila za uporabo različnih promocijskih shem.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,UOM coversion factor required for UOM: {0} in Item: {1},Za UOM potreben faktor pokritja UOM: {0} v elementu: {1}
apps/erpnext/erpnext/buying/utils.py,Please enter quantity for Item {0},Vnesite količino za element {0}
DocType: Workstation,Electricity Cost,Stroški električne energije
DocType: Vehicle Service,Vehicle Service,Servis za vozila
apps/erpnext/erpnext/config/help.py,Making Stock Entries,Izdelava zalog
DocType: Bank Guarantee,Fixed Deposit Number,Številka fiksnega depozita
apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Če želite omogočiti več prejemanja / dostave, posodobite »Nadomestilo za več prejemov / dostave« v nastavitvah zalog ali v postavki."
DocType: Vital Signs,Very Coated,Zelo prevlečeno
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 ?,"S tem dejanjem boste prekinili povezavo tega računa z zunanjimi storitvami, ki vključujejo ERPNext z vašimi bančnimi računi. Ni ga mogoče razveljaviti. Ste prepričani?"
DocType: Delivery Trip,Initial Email Notification Sent,Začetno e-poštno obvestilo je poslano
DocType: Production Plan,For Warehouse,Za skladišče
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,"{0}: Employee email not found, hence email not sent","{0}: e-poštnega naslova zaposlenega ni mogoče najti, zato e-poštni naslov ni poslan"
DocType: Currency Exchange,From Currency,Iz valute
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Return / Debit Note,Opomba o vračilu / obremenitvi
DocType: Homepage Section,"Order in which sections should appear. 0 is first, 1 is second and so on.","Vrstni red, v katerem odsekih naj se pojavi. Najprej je 0, 1 je drugo in tako naprej."
apps/erpnext/erpnext/utilities/activation.py,Create Sales Orders to help you plan your work and deliver on-time,"Ustvarite prodajne naročila, da boste lažje načrtovali svoje delo in zagotovili pravočasno dostavo"
apps/erpnext/erpnext/templates/includes/cart.js,Something went wrong!,Nekaj je šlo narobe!
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Healthcare Service,Izberite zdravstveno službo
DocType: Leave Application,Apply / Approve Leaves,Uporabi / odobri liste
DocType: Leave Block List,Applies to Company,Velja za podjetje
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Row {0}: Bill of Materials not found for the Item {1},"Vrstica {0}: delni račun, ki ni na voljo za element {1}"
DocType: Loan,Account Info,Informacije o računu
DocType: Item Attribute Value,Abbreviation,Okrajšava
DocType: Email Digest,Purchase Orders to Bill,Naročilnice za račun
DocType: Purchase Invoice,Total Net Weight,Skupna neto teža
DocType: Authorization Rule,Approving Role (above authorized value),Odobritev vloge (nad dovoljeno vrednostjo)
DocType: Employee Advance,HR-EAD-.YYYY.-,HR-EAD-.LLLL.-
DocType: Job Applicant,Resume Attachment,Nadaljuj priponko
DocType: Agriculture Analysis Criteria,Agriculture Manager,Vodja za kmetijstvo
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batch Entries,Serijski vnosi
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,"Prosimo, omogočite Velja za naročilnico in veljajo za dejanske stroške rezervacije"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Gain/Loss on Asset Disposal,Dobiček / izguba pri odstranitvi sredstev
DocType: Loan,Total Payment,Skupni znesek plačila
DocType: Asset,Total Number of Depreciations,Skupno število amortizacij
DocType: Asset,Fully Depreciated,Popolnoma amortizirana
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant Settings,Nastavitev postavke Variant
DocType: Supplier Group,Supplier Group Name,Ime skupine dobaviteljev
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,Sales Price List,Prodajni cenik
DocType: Email Digest,How frequently?,Kako pogosto?
DocType: Purchase Invoice,Supplier Warehouse,Skladišče dobavitelja
DocType: Salary Component,Only Tax Impact (Cannot Claim But Part of Taxable Income),Samo davčni učinek (ne morem zahtevati dela davčnega dohodka)
DocType: Item Default,Purchase Defaults,Privzete nastavitve nakupa
DocType: Contract,Contract Template,Predloga pogodbe
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Batch {1},Serijska številka {0} ne pripada skupini {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Pending Leaves,Čakajoči listi
DocType: Student Applicant,Applied,Uporabljeno
DocType: Clinical Procedure,Consumption Details,Podrobnosti o porabi
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.html,Loading Payment System,Nalaganje plačilnega sistema
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.py,Repayment Amount must be greater than ,Povračilo Znesek mora biti večji od
DocType: Assessment Plan,Maximum Assessment Score,Najvišja ocena
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Status Notification in HR Settings.,V nastavitvah za HR nastavite privzeto predlogo za obvestilo o opustitvi statusa.
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Report Card,Študentska izkaznica
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Nature Of Supplies,Narava potrebščin
DocType: Shopify Settings,Last Sync Datetime,Datum zadnje sinhronizacije
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Code {0} already exist,Koda {0} že obstaja
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Based On Payment Terms,Na podlagi pogojev plačila
DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Ta vrednost je posodobljena v privzetem prodajnem ceniku.
DocType: Special Test Template,Special Test Template,Posebna testna predloga
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Ustvarite različice
DocType: Item Default,Default Expense Account,Privzeti račun za stroške
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py,Please setup Students under Student Groups,"Prosimo, nastavite učence v okviru skupin dijakov"
apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Obdavčljivi znesek
DocType: Lead,Lead Owner,Glavni lastnik
DocType: Share Transfer,Transfer,Prenos
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Search Item (Ctrl + i),Element iskanja (Ctrl + i)
DocType: Call Log,Call Log,Seznam klicev
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,{0} Result submittted,{0} Vneseni rezultat
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,From date can not be greater than than To date,Od datuma ne more biti večja kot do danes
DocType: Supplier,Supplier of Goods or Services.,Dobavitelj blaga ali storitev.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Ime novega računa. Opomba: ne ustvarjajte računov za stranke in dobavitelje
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Student Group or Course Schedule is mandatory,Študentska skupina ali urnik tečaja je obvezen
DocType: Tax Rule,Sales Tax Template,Predloga za davek od prodaje
DocType: BOM,Routing,Usmerjanje
DocType: Payment Reconciliation,Payment Reconciliation,Usklajevanje plačil
apps/erpnext/erpnext/config/accounting.py,Match non-linked Invoices and Payments.,Ujemanje nepovezanih računov in plačil.
apps/erpnext/erpnext/utilities/user_progress.py,Opening Balances,Odpiranje stanj
DocType: Supplier,PAN,PAN
DocType: Work Order,Operation Cost,Stroški delovanja
DocType: Bank Guarantee,Name of Beneficiary,Ime upravičenca
apps/erpnext/erpnext/public/js/templates/address_list.html,New Address,Nov naslov
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","Hčerinska podjetja so že načrtovala {1} prostih delovnih mest s proračunom {2}. Kadrovski načrt za {0} bi moral nameniti več prostih delovnih mest in proračun za {3}, kot je bilo načrtovano za njegove hčerinske družbe"
DocType: Stock Entry,From BOM,Iz BOM
DocType: Program Enrollment Tool,Student Applicant,Študent prijavitelj
DocType: Leave Application,Leave Balance Before Application,Pustite ravnovesje pred aplikacijo
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Expiry date is mandatory for selected item,Datum izbire je obvezen za izbrani element
DocType: Stock Entry,Default Target Warehouse,Privzeto ciljno skladišče
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Show Salary Slip,Pokaži izplačilo plač
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py,Percentage Allocation should be equal to 100%,Dodelitev odstotka mora biti enaka 100%
DocType: Purchase Invoice Item,UOM Conversion Factor,Konverzijski faktor UOM
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Stock cannot be updated against Purchase Receipt {0},Stanja ni mogoče posodobiti glede na potrdilo o nakupu {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,Vrstica postavke {0}: {1} {2} ne obstaja v tabeli &#39;{1}&#39;
DocType: Asset Maintenance Task,2 Yearly,2 Letno
DocType: Guardian Student,Guardian Student,Študent varuhov
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please add a Temporary Opening account in Chart of Accounts,V kontni shemi dodajte začasni račun za začetek
DocType: Account,Include in gross,Vključite bruto
apps/erpnext/erpnext/config/hr.py,Loans,Posojila
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Patient History,Zgodovina bolnika
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Serial Numbers,Izberite Serijske številke
DocType: Tally Migration,UOMs,UOM
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Vrstica {0}: stranka / račun se ne ujema z {1} / {2} v {3} {4}
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid reference {0} {1},Neveljavna navedba {0} {1}
DocType: Quality Action,Corrective/Preventive,Popravljalno / preventivno
DocType: Work Order Operation,Work In Progress,Delo v teku
DocType: Bank Reconciliation,Account Currency,Valuta računa
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,credit_note_amt,credit_note_amt
DocType: Setup Progress Action,Action Name,Ime dejanja
DocType: Employee,Health Insurance,Zdravstveno zavarovanje
DocType: Student Group,Max Strength,Največja moč
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate customer group found in the cutomer group table,Podvojena skupina kupcev najdemo v tabeli skupine 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}","Pustitve ni mogoče uporabiti / preklicati pred {0}, ker je bil preostanek že prenesen v zapisu o dodelitvi prihodnjega dopusta {1}"
DocType: Promotional Scheme Price Discount,Min Amount,Min znesek
DocType: Sales Invoice Item,Rate With Margin (Company Currency),Stopnja z maržo (valuta podjetja)
DocType: Lead,Follow Up,Nadaljuj
DocType: Tax Rule,Shipping Country,Država pošiljanja
DocType: Delivery Note,Track this Delivery Note against any Project,Sledite tej dostavnici z vsemi projekti
apps/erpnext/erpnext/regional/india/utils.py,Vehicle Type is required if Mode of Transport is Road,"Tip vozila se zahteva, če je način prevoza cestni"
DocType: Company,Default Payroll Payable Account,Privzeti račun plačila plač
DocType: Drug Prescription,Update Schedule,Razpored posodobitev
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Updating estimated arrival times.,Posodobitev ocenjenih časov prihoda.
DocType: Asset Category,Finance Book Detail,Finance Book Detail
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Serial No {0} does not belong to Delivery Note {1},Zaporedna številka {0} ne spada v opombo o dostavi {1}
apps/erpnext/erpnext/regional/italy/utils.py,Please set Tax ID for the customer '%s',Nastavite davčni ID za stranko »% s«
DocType: Sales Partner,Logo,Logotip
DocType: Leave Type,Include holidays within leaves as leaves,V liste vključite praznike kot liste
DocType: Shift Assignment,Shift Request,Zahteva za premik
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py,"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Ne morem označiti praznega bolnišničnega zapisa, obstajajo neobračunani računi {0}"
DocType: QuickBooks Migrator,Scope,Področje uporabe
DocType: Purchase Invoice Item,Service Stop Date,Datum ustavitve storitve
apps/erpnext/erpnext/setup/doctype/company/test_company.py,No Account matched these filters: {},Noben račun se ne ujema s temi filtri: {}
DocType: Article,Publish Date,Datum objave
DocType: Student,O+,O +
DocType: BOM,Work Order,Delovni nalog
DocType: Bank Statement Transaction Settings Item,Transaction,Transakcija
DocType: Workstation,per hour,na uro
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,This action will stop future billing. Are you sure you want to cancel this subscription?,"S tem dejanjem boste ustavili prihodnje obračunavanje. Ali ste prepričani, da želite preklicati to naročnino?"
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,State/UT Tax,Država / UT davek
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py,Scorecards,Preglednice
,Projected Quantity as Source,Predvidena količina kot vir
DocType: Supplier Group,Parent Supplier Group,Skupina matičnih dobaviteljev
apps/erpnext/erpnext/controllers/accounts_controller.py,Rows with duplicate due dates in other rows were found: {0},Našli smo vrstice z dvojnimi datumi zapadlosti v drugih vrsticah: {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,Predloga grafikona računov
DocType: Lead,Lead,Svinec
DocType: Appraisal Template Goal,KRA,KRA
apps/erpnext/erpnext/utilities/user_progress.py,Setup Institution,Nastavitvena ustanova
DocType: Invoice Discounting,Loan Period (Days),Obdobje izposoje (dnevi)
,Salary Register,Register plač
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 primeru večplastnega programa bodo stranke samodejno dodeljene zadevni stopnji, kot so porabljene"
DocType: Bank Reconciliation Detail,Posting Date,Datum knjiženja
DocType: Upload Attendance,Attendance From Date,Udeležba od datuma
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py,Program in the Fee Structure and Student Group {0} are different.,Program v strukturi pristojbin in študentska skupina {0} sta različna.
DocType: GST Settings,GST Summary,Povzetek GST
DocType: Education Settings,Make Academic Term Mandatory,Obvezni akademski mandat
DocType: Vehicle,Odometer Value (Last),Vrednost števca prevoženih kilometrov (zadnje)
apps/erpnext/erpnext/config/assets.py,Transfer an asset from one warehouse to another,Prenesite sredstvo iz enega skladišča v drugo
DocType: Room,Seating Capacity,Število sedežev
DocType: Employee Benefit Application Detail,Employee Benefit Application Detail,Podrobnosti o vlogi za zaposlene
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Employee {0} has already applied for {1} between {2} and {3} : ,Zaposleni {0} se je že prijavil za {1} med {2} in {3}:
DocType: Asset Category Account,Capital Work In Progress Account,Račun kapitalskega dela na napredku
DocType: Employee Benefit Claim,Benefit Type and Amount,Vrsta in znesek koristi
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Please set default payable account for the company {0},Nastavite privzeti račun za podjetje {0}
DocType: Daily Work Summary Group,Holiday List,Seznam počitnic
DocType: Job Card,Total Time in Mins,Skupni čas v min
DocType: Shipping Rule,Shipping Amount,Znesek dostave
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Absent,Skupno ni bilo
DocType: Fee Validity,Reference Inv,Referenca 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,Vrstica {0}: {1} je potrebna za ustvarjanje odprtih računov {2}
DocType: Bank Account,Is Company Account,Je račun podjetja
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Do you want to notify all the customers by email?,Želite obvestiti vse stranke po elektronski pošti?
DocType: Opening Invoice Creation Tool,Sales,Prodaja
DocType: Vital Signs,Tongue,Jezik
DocType: Journal Entry,Excise Entry,Vnos trošarine
apps/erpnext/erpnext/www/all-products/index.html,Clear filters,Počistite filtre
DocType: Delivery Trip,In Transit,V tranzitu
apps/erpnext/erpnext/stock/doctype/item/item.py,Barcode {0} is not a valid {1} code,Črtna koda {0} ni veljavna koda {1}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Balance for Account {0} must always be {1},Stanje za račun {0} mora biti vedno {1}
apps/erpnext/erpnext/public/js/controllers/transaction.js,Invalid Blanket Order for the selected Customer and Item,Neveljavna naročila za izbrano stranko in postavko
DocType: Production Plan Item,"If enabled, system will create the work order for the exploded items against which BOM is available.","Če je omogočeno, bo sistem ustvaril delovni nalog za eksplodirane postavke, za katere je na voljo BOM."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Product Bundle,Paket izdelkov
DocType: Exchange Rate Revaluation Account,New Exchange Rate,Novi tečaj
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open To Do,Odpri za
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Receiver List is empty. Please create Receiver List,Seznam prejemnikov je prazen. Ustvarite seznam prejemnikov
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Current Liabilities,Tekoče obveznosti
apps/erpnext/erpnext/templates/pages/demo.html,ERPNext Demo,ERPNext Demo
DocType: Patient,Other Risk Factors,Drugi dejavniki tveganja
DocType: Item Attribute,To Range,V razpon
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} applicable after {1} working days,{0} velja po {1} delovnih dneh
DocType: Task,Task Description,Opis naloge
DocType: Bank Account,SWIFT Number,Številka SWIFT
DocType: Accounts Settings,Show Payment Schedule in Print,Prikaži razpored plačil v tiskanju
DocType: Purchase Invoice,Apply Tax Withholding Amount,Uporabi znesek davčnega odtegljaja
DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Stanje kazalnika dobaviteljev
DocType: Quality Inspection Reading,Quality Inspection Reading,Bralno preverjanje kakovosti
DocType: Healthcare Settings,Valid number of days,Veljavno število dni
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,Podpis po meri v tiskalniku
DocType: Patient Encounter,Procedures,Postopki
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Issues,Odprta vprašanja
DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Vnos za amortizacijo vnosa (vnos v dnevnik)
DocType: Healthcare Service Unit,Occupancy Status,Status zaposlitve
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Privilege Leave,Privilege dopust
DocType: Subscription,Current Invoice End Date,Trenutni datum konca računa
DocType: Sample Collection,Collected Time,Zbrani čas
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please select BOM for Item in Row {0},Izberite BOM za postavko v vrstici {0}
DocType: Department,Expense Approver,Odobritve stroškov
DocType: Bank Statement Transaction Entry,New Transactions,Nove transakcije
apps/erpnext/erpnext/hr/report/loan_repayment/loan_repayment.py,Payable Amount,Znesek za plačilo
DocType: SMS Center,All Supplier Contact,Vsi stiki dobaviteljev
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Quotation {0} not of type {1},Ponudba {0} ni vrste {1}
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,Leave Type {0} is not encashable,Vrsta zapuščine {0} ni mogoče shraniti
DocType: Contract,Fulfilment Status,Status izpolnitve
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Unsubscribe from this Email Digest,Odjavite se iz tega e-poštnega povzetka
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.py,{0} {1} created,Ustvarjeno je {0} {1}
DocType: Water Analysis,Person Responsible,Odgovorna oseba
DocType: Asset,Asset Category,Kategorija sredstva
DocType: Cash Flow Mapping Accounts,Cash Flow Mapping Accounts,Računi za kartiranje denarnega toka
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Select Serial No,Izberite Serijska št
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Vračilo prodaje
apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py,No record found,Ni zapisov
DocType: Department,Expense Approvers,Odobritve stroškov
DocType: Purchase Invoice,Group same items,Skupina enake postavke
DocType: Company,Parent Company,Matična družba
DocType: Daily Work Summary Group,Reminder,Opomnik
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Bank Overdraft Account,Račun prekoračitve bančnega računa
DocType: Journal Entry,Difference (Dr - Cr),Razlika (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 postavk obstaja z istim imenom, spremenite ime elementa ali preimenujte skupino postavk"
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,Naslednji element {0} ni označen kot element {1}. Omogočite jih lahko kot element {1} iz glavnega elementa
DocType: Healthcare Service Unit,Allow Overlap,Dovoli prekrivanje
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},Vrednost za atribut {0} mora biti v razponu od {1} do {2} v korakih {3} za element {4}
DocType: Timesheet,Billing Details,Podrobnosti za obračun
DocType: Quality Procedure Table,Quality Procedure Table,Tabela postopkov kakovosti
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} created,Ustvarjena je serijska številka {0}
DocType: Warehouse,Warehouse Detail,Podrobnosti o skladišču
DocType: Sales Order,To Deliver and Bill,Za dostavo in Bill
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Dodano v podrobnosti
apps/erpnext/erpnext/public/js/hub/marketplace.js,Add Users to Marketplace,Dodajte uporabnike v Marketplace
DocType: Healthcare Settings,Remind Before,Opomni pred
DocType: Healthcare Settings,Manage Customer,Upravljanje stranke
DocType: Loyalty Program Collection,Tier Name,Ime stopnje
DocType: Manufacturing Settings,Manufacturing Settings,Nastavitve proizvodnje
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,Taken,Vzeto
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select Start Date and End Date for Item {0},Izberite datum začetka in končni datum za element {0}
DocType: Education Settings,Education Settings,Nastavitve izobraževanja
DocType: Student Admission,Admission End Date,Datum zaključka sprejema
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.
				","Če ste {0} {1} vredni element <b>{2}</b> , bo za element uporabljena shema <b>{3}</b> ."
DocType: Bank Account,Mask,Maska
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Please specify Company to proceed,Za nadaljevanje navedite podjetje
DocType: Asset Maintenance Team,Asset Maintenance Team,Skupina za vzdrževanje sredstev
DocType: Production Plan Material Request,Material Request Date,Datum zahteve za material
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Responsibilities,Odgovornosti
DocType: Project,Total Costing Amount (via Timesheets),Skupni znesek obračunavanja stroškov (prek časovnih listov)
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Make New Contact,Ustvari nov stik
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Uvažanje elementov in posredniških enot
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Leaves per Year,Listi na leto
DocType: Student,Date of Leaving,Datum odhoda
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,Export E-Invoices,Izvozi e-račune
DocType: Healthcare Settings,Laboratory SMS Alerts,Opozorila o laboratorijskih SMS sporočilih
DocType: Program,Is Published,Objavljeno
DocType: Clinical Procedure,Healthcare Practitioner,Zdravstveni delavec
apps/erpnext/erpnext/stock/get_item_details.py,Item Price updated for {0} in Price List {1},Cena artikla je posodobljena za {0} v ceniku {1}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Bared Item {0} ni mogoče posodobiti z usklajevanjem zalog, namesto tega pa uporabite vnos zaloge"
DocType: Employee External Work History,Total Experience,Skupna izkušnja
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material to Supplier,Material za dobavitelja
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Customer is required against Receivable account {2},{0} {1}: Stranka je zahtevana proti računu terjatev {2}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Healthcare Services,Zdravstvene storitve
DocType: Grading Scale Interval,Grade Code,Koda stopnje
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Imenovanja in srečanja bolnikov
,TDS Computation Summary,Povzetek izračuna TDS
DocType: Shipping Rule,Shipping Rule Label,Oznaka pravil za pošiljanje
DocType: Buying Settings,Supplier Naming By,Imenovanje dobavitelja
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Admissions for {0},Sprejem za {0}
DocType: Loan,Loan Details,Podrobnosti o posojilu
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} on Half day on {1},Zaposleni {0} na pol dneva {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},Najvišji znesek za izvzetje ne sme presegati najvišje zneske oprostitve {0} kategorije davčne oprostitve {1}
apps/erpnext/erpnext/hr/utils.py,Please set leave policy for employee {0} in Employee / Grade record,"Prosimo, nastavite politiko dopusta za zaposlenega {0} v zapisu zaposlenega / razreda"
DocType: Bank Reconciliation Detail,Cheque Number,Preverite številko
,Prospects Engaged But Not Converted,"Obeti, ki so bili vključeni, vendar niso preoblikovani"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Liabilities,Obveznosti
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py,-Above,-Nad
DocType: Item Website Specification,Item Website Specification,Predmet Spletna specifikacija
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}.","Element {0} (Serijska št.: {1}) ni mogoče porabiti, kot je to mogoče, če je izpolnjen popoln prodajni nalog {2}."
DocType: Vehicle,Electric,Električni
apps/erpnext/erpnext/config/hr.py,Fleet Management,Upravljanje flote
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.","Postavka Cena se prikaže večkrat na podlagi cenika, dobavitelja / kupca, valute, postavke, UOM, količin in datumov."
DocType: Stock Ledger Entry,Stock Ledger Entry,Vnos v knjigo zaloge
DocType: HR Settings,Email Salary Slip to Employee,E-poštno sporočilo o plači zaposlenega
DocType: Stock Entry,Delivery Note No,Opomba za dostavo št
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Timeslots,Dodajte časovne presledke
DocType: Packing Slip Item,Packing Slip Item,Pakirni listič
DocType: Payroll Period,Standard Tax Exemption Amount,Standardni znesek davčne oprostitve
apps/erpnext/erpnext/config/help.py,Serialized Inventory,Serialized Inventory
DocType: Contract,Requires Fulfilment,Zahteva izpolnitev
DocType: Quality Inspection,MAT-QA-.YYYY.-,MAT-QA-.YYYY.-
DocType: Bank Statement Transaction Entry,Receivable Account,Račun terjatev
DocType: Website Attribute,Website Attribute,Lastnost spletne strani
apps/erpnext/erpnext/public/js/templates/address_list.html,No address added yet.,Noben naslov še ni dodan.
DocType: Sales Order,Partly Billed,Delno zaračunan
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,Customer isn't enrolled in any Loyalty Program,Stranka ni vpisana v noben program zvestobe
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Jobs,Službe
DocType: Expense Claim,Approval Status,Status odobritve
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Opening Qty,Kol
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čitev dodeljevanja strukture plač za naslednje zaposlene, saj zanje že obstaja evidenca o strukturi plač. {0}"
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Datum konca obdobja ne sme biti poznejši od datuma konca leta akademskega leta, na katerega je izraz povezan (akademsko leto {}). Popravite datume in poskusite znova."
DocType: Purchase Order,% Billed,% Zaračuna
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Variance,Skupna varianca
apps/erpnext/erpnext/support/doctype/issue/issue.js,Split Issue,Razdeljeno vprašanje
DocType: Item Default,Default Supplier,Privzeti dobavitelj
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Base,Base
apps/erpnext/erpnext/config/accounting.py,Share Management,Upravljanje delnic
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Sales Order {0} is not valid,Prodajni nalog {0} ni veljaven
DocType: Leave Control Panel,Branch (optional),Podružnica (izbirno)
DocType: Bank Reconciliation Detail,Clearance Date,Datum potrditve
DocType: Supplier Scorecard Period,Criteria,Merila
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,"Povpraševanje po materialu, ko zaloga doseže stopnjo ponovnega naročanja"
,Campaign Efficiency,Učinkovitost kampanje
apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Ustvari urnik
DocType: Employee,Internal Work History,Notranja delovna zgodovina
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Select Target Warehouse,Izberite Ciljno skladišče
DocType: Subscription Settings,Grace Period,Odlog plačila
DocType: Patient,Married,Poročen
DocType: Work Order Item,Available Qty at Source Warehouse,Na voljo Qty at Source Warehouse
DocType: Shipping Rule Country,Shipping Rule Country,Pravilo o pošiljanju Država
DocType: Delivery Stop,Email Sent To,E-poštno sporočilo je poslano
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Material Consumption,Poraba materiala
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Nothing to change,Ničesar ni treba spremeniti
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,No Lab Test created,Noben laboratorijski test ni ustvarjen
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}.,Največji vzorci - {0} so že shranjeni za paketni {1} in element {2} v paketni {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.","Privzete valute podjetja ni mogoče spremeniti, ker obstajajo obstoječe transakcije. Transakcije je treba preklicati, da spremenite privzeto valuto."
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Maintenance Expenses,Stroški vzdrževanja v pisarni
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,Skupaj dodeljeni listi so več dni kot največja dodelitev za {0} vrsto dopusta za zaposlenega {1} v obdobju
DocType: Stock Entry,Update Rate and Availability,Hitrost posodabljanja in razpoložljivost
DocType: Item Variant Attribute,Item Variant Attribute,Atribut Varianta postavke
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Razpoložljiva količina paketa iz skladišča
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Popust (%) na ceno z maržo
DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,"Preverite, ali je za premoženje potrebno preventivno vzdrževanje ali kalibracija"
DocType: Lab Test,Technician Name,Ime tehnika
DocType: Lab Test Groups,Normal Range,Normalno območje
DocType: Item,Total Projected Qty,Skupna predvidena količina
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Boms,Boms
DocType: Work Order,Actual Start Date,Dejanski datum začetka
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,You are not present all day(s) between compensatory leave request days,Niste prisotni ves dan (dni) med dnevi zahtevkov za nadomestni dopust
apps/erpnext/erpnext/config/accounting.py,Tree of financial accounts.,Drevo finančnih računov.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Indirect Income,Posredni dohodek
DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,Rezervacija za hotelsko sobo
DocType: Course Scheduling Tool,Course Start Date,Datum začetka tečaja
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Sell,Prodaj
DocType: Support Search Source,Post Route String,Post String Route
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Electrical,Električni
DocType: Journal Entry,Total Debit,Skupna obremenitev
DocType: Guardian,Guardian,Skrbnik
DocType: Share Transfer,Transfer Type,Vrsta prenosa
apps/erpnext/erpnext/config/crm.py,Database of potential customers.,Baza potencialnih strank.
DocType: Skill,Skill Name,Ime spretnosti
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js,Print Report Card,Natisni kartico s poročilom
DocType: Soil Texture,Ternary Plot,Ternary Plot
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Support Tickets,Vstopnice za podporo
DocType: Asset Category Account,Fixed Asset Account,Račun osnovnih sredstev
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Latest,Zadnje
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Pošlji izplačilo plač
DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Hitrost utripa odraslih je med 50 in 80 utripov na minuto.
DocType: Program Enrollment Course,Program Enrollment Course,Program za vpis v program
,IRS 1099,IRS 1099
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set the series to be used.,"Nastavite serijo, ki jo želite uporabiti."
DocType: Delivery Trip,Distance UOM,Razdalja UOM
DocType: Accounting Dimension,Mandatory For Balance Sheet,Obvezno za bilanco stanja
DocType: Payment Entry,Total Allocated Amount,Skupni dodeljeni znesek
DocType: Sales Invoice,Get Advances Received,Prejmite prejete predujme
DocType: Shift Type,Last Sync of Checkin,Zadnja sinhronizacija prijave
DocType: Student,B-,B-
DocType: Purchase Invoice Item,Item Tax Amount Included in Value,Znesek davka na postavko vključen v vrednost
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","Vrstica {0}: Račun {1} je neveljaven, morda je preklican / ne obstaja. Vnesite veljaven račun"
DocType: Subscription Plan,Subscription Plan,Naročniški načrt
DocType: Student,Blood Group,Krvna skupina
apps/erpnext/erpnext/config/healthcare.py,Masters,Mojstri
DocType: Crop,Crop Spacing UOM,Obrezovanje razmika UOM
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,View call log,Prikaži dnevnik klicev
DocType: Shift Type,The time after the shift start time when check-in is considered as late (in minutes).,"Čas po začetku prehoda, ko se prijava šteje za pozno (v minutah)."
apps/erpnext/erpnext/templates/pages/home.html,Explore,Raziščite
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,No outstanding invoices found,Ni bilo ugotovljenih neplačanih računov
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,"{0} vacancies and {1} budget for {2} already planned for subsidiary companies of {3}. \
				You can only plan for upto {4} vacancies and and budget {5} as per staffing plan {6} for parent company {3}.","{0} prostih delovnih mest in {1} proračuna za {2}, ki sta že načrtovana za hčerinske družbe {3}. Načrtujete lahko samo {4} prostih delovnih mest in proračun {5} glede na kadrovski načrt {6} za matično podjetje {3}."
DocType: Promotional Scheme,Product Discount Slabs,Plošče za popust za izdelke
DocType: Hotel Room Package,Amenities,Opremljenost
DocType: Lab Test Groups,Add Test,Dodaj test
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Cannot return more than {1} for Item {2},Vrstica # {0}: ni mogoče vrniti več kot {1} za element {2}
DocType: Student Leave Application,Student Leave Application,Aplikacija za dopust za študente
DocType: Maintenance Schedule Item,Maintenance Schedule Item,Postavka urnika vzdrževanja
DocType: Bank Account,Integration Details,Podrobnosti o integraciji
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS profil potreben za POS vstop
DocType: Education Settings,Enable LMS,Omogoči LMS
DocType: POS Closing Voucher,Sales Invoices Summary,Povzetek prodajnih računov
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Benefit,Korist
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Balance Sheet account,Kredit za račun mora biti račun stanja
DocType: Call Log,Duration,Trajanje
DocType: Lab Test Template,Descriptive,Opisno
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select Price List,Izberite Cenik
DocType: Payment Reconciliation,From Invoice Date,Od datuma računa
DocType: Education Settings,Validate Batch for Students in Student Group,Potrdite paket za študente v študentski skupini
DocType: Leave Policy,Leave Allocations,Pustite dodelitve
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js,Score cannot be greater than Maximum Score,Ocena ne sme biti večja od najvišje ocene
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,BOM is not specified for subcontracting item {0} at row {1},BOM ni podana za podizvajalski element {0} v vrstici {1}
DocType: Item,Automatically Create New Batch,Samodejno ustvarite nov paket
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() accepted invalid IBAN {},BankAccount.validate_iban () je sprejel neveljaven IBAN {}
DocType: Restaurant Menu,Price List (Auto created),Cenik (samodejno ustvarjen)
DocType: Customer,Credit Limit and Payment Terms,Kreditni limit in pogoji plačila
apps/erpnext/erpnext/stock/doctype/item/item.js,Show Variants,Prikaži različice
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},V podjetju {0} nastavite račun &quot;Dobiček / izguba pri odstranjevanju sredstev&quot;
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Slip of employee {0} already created for time sheet {1},Zapis plače zaposlenega {0} je že ustvarjen za časovni list {1}
apps/erpnext/erpnext/config/projects.py,Timesheet for tasks.,Časovni razpored nalog.
DocType: Purchase Invoice,Rounded Total (Company Currency),Zaokroženo skupno (valuta podjetja)
apps/erpnext/erpnext/config/website.py,Settings for website product listing,Nastavitve za seznam izdelkov spletnega mesta
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Successfully Set Supplier,Uspešno nastavite dobavitelja
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Start Date of Agreement can't be greater than or equal to End Date.,Datum začetka pogodbe ne sme biti večji ali enak končnemu datumu.
,Item Prices,Cene izdelkov
DocType: Products Settings,Product Page,Stran izdelka
DocType: Amazon MWS Settings,Market Place ID,ID tržnega mesta
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Production Order has been {0},Proizvodni nalog je bil {0}
DocType: Employee Benefit Application,Employee Benefit Application,Prijava za zaposlene
DocType: BOM Item,Item operation,Delovanje izdelka
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Received,Delno prejeto
DocType: Landed Cost Voucher,MAT-LCV-.YYYY.-,MAT-LCV-.YYYY.-
DocType: Employee Advance,Due Advance Amount,Znesek zapadlih predujmov
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,Skupaj dodeljeni listi {0} ne morejo biti manjši od že odobrenih listov {1} za obdobje
DocType: Email Digest,New Purchase Orders,Nove naročilnice
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Item: {0} does not exist in the system,Element: {0} ne obstaja v sistemu
DocType: Loan Application,Loan Info,Informacije o posojilu
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Poskusite načrtovati operacije za X dni vnaprej.
DocType: Serial No,Is Cancelled,Preklicano
DocType: Request for Quotation,For individual supplier,Za posameznega dobavitelja
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Min Qty can not be greater than Max Qty,Min Qty ne sme biti večji od Max Qty
DocType: Soil Texture,Loamy Sand,Loamy Sand
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Vrstica {0}: plačilo za prodajo / naročilo mora biti vedno označeno kot predplačilo
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.","Primer: ABCD. #####. Če je serija nastavljena in serijska številka ni navedena v transakcijah, bo na podlagi te serije izdelana avtomatska številka serije. Če želite za to postavko vedno izrecno omeniti serijsko št., Pustite to prazno. Opomba: ta nastavitev bo imela prednost pred predpono serije Imenovanje v nastavitvah zaloge."
apps/erpnext/erpnext/config/healthcare.py,Consultation,Posvetovanje
DocType: Item,Item Defaults,Privzete nastavitve elementa
DocType: Sales Invoice,Total Commission,Skupaj Komisija
DocType: Hotel Room,Hotel Room,Hotelska soba
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,{0} hours,{0} ur
apps/erpnext/erpnext/controllers/buying_controller.py,Serial no is mandatory for the item {0},Serijska številka je obvezna za element {0}
DocType: Company,Standard Template,Standardna predloga
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The number of shares and the share numbers are inconsistent,Število delnic in številk delnic so neskladne
DocType: Project,Start and End Dates,Začetni in končni datumi
DocType: Supplier Scorecard,Notify Employee,Obvestite zaposlenega
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Software,Programska oprema
DocType: Program,Allow Self Enroll,Dovoli samodejni vpis
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Expenses,Stroški zalog
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference No is mandatory if you entered Reference Date,"Referenčna številka je obvezna, če ste vnesli referenčni datum"
DocType: Training Event,Workshop,Delavnica
DocType: Stock Settings,Auto insert Price List rate if missing,"Avtomatsko vstavljanje Cenovni tečaj, če manjka"
DocType: Course Content,Course Content,Vsebina tečaja
DocType: Purchase Order Item,Material Request Item,Postavka zahtevka za material
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Namen obiska za vzdrževanje
DocType: Designation,Skills,Spretnosti
DocType: Asset,Out of Order,V okvari
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Available {0},Na voljo {0}
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js,Select Customer,Izberite stranko
DocType: Projects Settings,Ignore Workstation Time Overlap,Prezri prekrivanje delovnega mesta
DocType: Shareholder,Hidden list maintaining the list of contacts linked to Shareholder,"Skrit seznam ohranja seznam stikov, povezanih z delničarjem"
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","Izbrišite zaposlenega <a href=""#Form/Employee/{0}"">{0},</a> da prekličete ta dokument"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Same item has been entered multiple times,Isti element je bil vnesen večkrat
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} is under maintenance contract upto {1},Zaporedna št. {0} je na podlagi pogodbe o vzdrževanju do {1}
DocType: Bin,FCFS Rate,Stopnja FCFS
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Negative Quantity is not allowed,Negativna količina ni dovoljena
DocType: Quotation Item,Planning,Načrtovanje
DocType: Marketplace Settings,Marketplace URL (to hide and update label),URL tržnice (za skrivanje in posodabljanje oznake)
DocType: Item Group,Parent Item Group,Skupina matične postavke
DocType: Bank,Data Import Configuration,Konfiguracija uvoza podatkov
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Avg. Buying Price List Rate,Povp. Nakupna cena
,Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC]
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,Row #{0}: Timings conflicts with row {1},Vrstica # {0}: Časovno obdobje je v navzkrižju z vrstico {1}
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customers,Ponovite stranke
DocType: Fee Schedule,Fee Schedule,Cenik
DocType: Quality Inspection Reading,Reading 10,Branje 10
apps/erpnext/erpnext/config/help.py,Setting up Employees,Vzpostavitev zaposlenih
DocType: Selling Settings,Settings for Selling Module,Nastavitve za prodajni modul
DocType: Payment Reconciliation,Reconcile,Uskladi
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","Račun razlik mora biti račun vrste sredstva / obveznosti, ker je ta vnos delnic začetni vnos"
apps/erpnext/erpnext/accounts/report/financial_statements.py,End Year cannot be before Start Year,Končno leto ne more biti pred začetkom leta
apps/erpnext/erpnext/regional/india/utils.py,Unsupported GST Category for e-Way Bill JSON generation,Nepodprta kategorija GST za generiranje JSON obrazcev za e-Way
DocType: Task,Parent Task,Nadrejena naloga
DocType: Attendance,Attendance Request,Zahteva za obisk
DocType: Item,Moving Average,Gibljivo povprečje
DocType: Employee Attendance Tool,Unmarked Attendance,Neoznačena prisotnost
DocType: Homepage Section,Number of Columns,Število stolpcev
DocType: Issue Priority,Issue Priority,Prednostna naloga
DocType: Holiday List,Add Weekly Holidays,Dodaj tedenske počitnice
DocType: Shopify Log,Shopify Log,Shopify Log
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Salary Slip,Ustvarite izplačilo plač
DocType: Customs Tariff Number,Customs Tariff Number,Carinska tarifna številka. \ T
DocType: Job Offer Term,Value / Description,Vrednost / opis
DocType: Warranty Claim,Issue Date,Datum izdaje
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,"Izberite paket za postavko {0}. Ni mogoče najti posameznega paketa, ki bi izpolnjeval to zahtevo"
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py,Cannot create Retention Bonus for left Employees,Bonusa za zadržanje za leve zaposlene ni mogoče ustvariti
DocType: Employee Checkin,Location / Device ID,ID lokacije / naprave
DocType: Purchase Order,To Receive,Prejeti
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 načinu brez povezave. Ne boste mogli ponovno naložiti, dokler ne boste imeli omrežja."
DocType: Course Activity,Enrollment,Vpis
DocType: Lab Test Template,Lab Test Template,Predloga za laboratorijsko preizkušanje
,Employee Birthday,Rojstni dan zaposlenega
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Max: {0},Največ: {0}
apps/erpnext/erpnext/regional/italy/utils.py,E-Invoicing Information Missing,Manjkajo podatki o elektronskem izdajanju računov
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No material request created,Ustvarjena ni bila nobena zahteva za material
DocType: Loan,Total Amount Paid,Skupni znesek plačila
DocType: Bank Account,Is the Default Account,Je privzeti račun
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,All these items have already been invoiced,Vsi ti elementi so že bili zaračunani
DocType: Training Event,Trainer Name,Ime trenerja
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Project Manager,Vodja projekta
DocType: Travel Itinerary,Non Diary,Ne dnevnik
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shares don't exist with the {0},Delnice ne obstajajo z {0}
DocType: Lab Test,Test Group,Testna skupina
DocType: Subscription,Number of days that the subscriber has to pay invoices generated by this subscription,"Število dni, ko mora naročnik plačati račune, ustvarjene s to naročnino"
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,Please set Unrealized Exchange Gain/Loss Account in Company {0},Nastavite nerealizirani račun dobička / izgube Exchange v podjetju {0}
DocType: Payroll Entry,Select Payment Account to make Bank Entry,Izberite Plačilni račun za vnos bančnega računa
apps/erpnext/erpnext/hub_node/api.py,No items to publish,Ni elementov za objavo
DocType: Supplier Scorecard,Scoring Setup,Točkovanje Nastavitev
DocType: Salary Slip,Total Interest Amount,Skupni znesek obresti
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},V začetnem proračunskem letu {0} so že določeni začetni datum fiskalnega leta in datum konca proračunskega leta
apps/erpnext/erpnext/projects/report/billing_summary.py,Billable Hours,Plačljive ure
apps/erpnext/erpnext/config/accounting.py,Accounting Masters,Računovodstvo Masters
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge with Existing Account,Spoji se z obstoječim računom
DocType: Lead,Lost Quotation,Izgubljena ponudba
DocType: Email Digest,Note: Email will not be sent to disabled users,Opomba: E-poštni naslov ne bo poslan uporabnikom s posebnimi potrebami
apps/erpnext/erpnext/config/settings.py,"Create and manage daily, weekly and monthly email digests.","Ustvarite in upravljajte dnevne, tedenske in mesečne e-poštne analize."
DocType: Academic Term,Academic Year,Študijsko leto
DocType: Sales Stage,Stage Name,Ime stopnje
DocType: SMS Center,All Employee (Active),Vsi zaposleni (aktivni)
DocType: Accounting Dimension,Accounting Dimension,Dimenzija računovodstva
DocType: Project,Customer Details,Podatki o kupcu
DocType: Buying Settings,Default Supplier Group,Privzeta skupina dobaviteljev
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please cancel Purchase Receipt {0} first,Najprej prekličite potrdilo o nakupu {0}
DocType: Bank Transaction Mapping,Field in Bank Transaction,Polje v bančnih transakcijah
apps/erpnext/erpnext/controllers/accounts_controller.py,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Polnjenje vrste »Dejansko« v vrstici {0} ni mogoče vključiti v količino elementov
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Business Development Manager,Razvojni upravnik podjetja
DocType: Agriculture Task,Urgent,Nujno
DocType: Shipping Rule Condition,From Value,Iz vrednosti
DocType: Asset Maintenance Task,Next Due Date,Naslednji rok zapadlosti
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Buy,Nakup
apps/erpnext/erpnext/projects/doctype/task/task.py,Progress % for a task cannot be more than 100.,Napredek% za nalogo ne more biti več kot 100.
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Number of root accounts cannot be less than 4,Število korenskih računov ne sme biti manjše od 4
DocType: Item,Website Item Groups,Skupine elementov spletne strani
DocType: Certified Consultant,Certified Consultant,Certificirani svetovalec
DocType: Driving License Category,Class,Razred
DocType: Asset,Sold,Prodano
apps/erpnext/erpnext/accounts/party.py,There can only be 1 Account per Company in {0} {1},V {0} {1} je lahko samo en račun na podjetje
DocType: GL Entry,Against,Proti
DocType: Company,Default Deferred Expense Account,Privzeti račun za odložene stroške
DocType: Stock Settings,Auto Material Request,Auto Material Request
DocType: Marketplace Settings,Sync in Progress,Trenutno poteka sinhronizacija
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,"Ni plačilnega listka, ki bi predložil zgoraj navedene kriterije ALI plačilni list, ki je že predložen"
apps/erpnext/erpnext/config/settings.py,Create rules to restrict transactions based on values.,Ustvarite pravila za omejitev transakcij na podlagi vrednosti.
DocType: Products Settings,Enable Field Filters,Omogoči filtre polj
DocType: Loan,Loan Amount,Znesek posojila
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Miscellaneous Expenses,Različni stroški
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the public administration '%s',"Prosimo, nastavite fiskalni zakonik za javno upravo &quot;% s&quot;"
apps/erpnext/erpnext/config/retail.py,Setup mode of POS (Online / Offline),Način namestitve POS-a (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.,Uporabnik {0} nima privzetega profila POS. Preverite Privzeto v vrstici {1} za tega uporabnika.
DocType: Department,Leave Block List,Zapusti seznam blokov
apps/erpnext/erpnext/healthcare/page/patient_history/patient_history.html,Select Patient,Izberite Bolnik
DocType: Attendance,Leave Type,Izpusti tip
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Creating student groups,Ustvarjanje skupin študentov
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Plants and Machineries,Rastline in stroji
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Not Marked,Ni označeno
DocType: Bank Statement Transaction Invoice Item,Purchase Invoice,Račun za nakup
DocType: GL Entry,Is Opening,Odpre se
DocType: Accounts Settings,Accounts Settings,Nastavitve računov
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Actual Qty: Quantity available in the warehouse.,Dejanska količina: količina na voljo v skladišču.
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expires On,Poteče
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Accounting Entry for Asset,Računovodski vnos za sredstva
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Urnik tečaja
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cost Center with existing transactions can not be converted to ledger,Stroškovnega središča z obstoječimi transakcijami ni mogoče pretvoriti v knjigo
,Bank Clearance Summary,Povzetek bančnega potrdila
DocType: SMS Center,SMS Center,SMS center
DocType: Pricing Rule,Threshold for Suggestion,Prag za predlog
DocType: Stock Entry,Sales Invoice No,Št
DocType: Project Update,Project Update,Posodobitev projekta
DocType: Student Sibling,Student ID,ID študenta
,Pending SO Items For Purchase Request,Stroški v teku na zahtevo za nakup
DocType: Task,Timeline,Časovnica
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,The Loyalty Program isn't valid for the selected company,Program zvestobe ni veljaven za izbrano podjetje
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfiguriraj {0}
DocType: Employee,Contact Details,Kontaktni podatki
apps/erpnext/erpnext/utilities/user_progress.py,Classrooms/ Laboratories etc where lectures can be scheduled.,Učilnice / Laboratoriji itd.
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Cannot cancel because submitted Stock Entry {0} exists,"Ne morem preklicati, ker je predložen vnos stanj {0}"
DocType: Exchange Rate Revaluation Account,Balance In Account Currency,Stanje v valuti računa
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Close the POS,Zaprite POS
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"For {0}, only credit accounts can be linked against another debit entry",Za {0} je mogoče povezati samo kreditne račune z drugim debetnim vnosom
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Pharmaceutical,Farmacevtska
DocType: Program Enrollment,Boarding Student,Vkrcanje študenta
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js,Total Contribution Amount: {0},Skupni znesek prispevka: {0}
DocType: Item Alternative,Two-way,Dvosmerno
DocType: Appraisal,Appraisal,Ocena
DocType: Plaid Settings,Plaid Settings,Nastavitve Plaid
apps/erpnext/erpnext/controllers/trends.py,Fiscal Year: {0} does not exists,Fiskalno leto: {0} ne obstaja
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Create Employee,Ustvari zaposlenega
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Structures have been assigned successfully,Strukture so bile uspešno dodeljene
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Expenses,Neposredni stroški
DocType: Support Search Source,Result Route Field,Rezultat Polje poti
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,There is not enough leave balance for Leave Type {0},Ni dovolj ravnotežja za vrsto zapustitve {0}
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Faktor pretvorbe UOM ({0} -&gt; {1}) ni bil najden za element: {2}
DocType: Material Request Plan Item,Actual Qty,Dejanska količina
DocType: Purchase Invoice,Supplier Invoice Date,Datum računa dobavitelja
DocType: Depreciation Schedule,Finance Book Id,Finance Book Id
DocType: Exchange Rate Revaluation Account,Current Exchange Rate,Trenutni tečaj
DocType: Account,Equity,Pravičnost
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","Vrstica # {0}: Vrsta referenčnega dokumenta mora biti ena od prodajnega naloga, prodajnega računa ali vnosa v dnevnik"
apps/erpnext/erpnext/utilities/user_progress.py,Explore Sales Cycle,Raziščite prodajni cikel
DocType: Shopify Log,Request Data,Zahtevaj podatke
DocType: Quality Procedure,Quality Procedure,Postopek kakovosti
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Email sent to supplier {0},"E-poštno sporočilo, poslano dobavitelju {0}"
,Course wise Assessment Report,Poročilo o oceni predmeta
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Automotive,Avtomobilska industrija
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},Vrstica {0}: dodeljeni znesek {1} mora biti manjši ali enak računu za neporavnani znesek {2}
DocType: Student Report Generation Tool,Total Parents Teacher Meeting,Skupni sestanek učiteljev staršev
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0} : Operation is required against the raw material item {1},Vrstica {0}: Potrebna je operacija proti elementu surovine {1}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Posting timestamp must be after {0},Časovni žig objavljanja mora biti po {0}
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Please mention the Lead Name in Lead {0},Navedite vodilno ime v svincu {0}
DocType: Employee,You can enter any date manually,Ročno lahko vnesete poljuben datum
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Postavka usklajevanja zalog
DocType: Shift Type,Early Exit Consequence,Zgodnja izstopna posledica
DocType: Item Group,General Settings,Splošne nastavitve
apps/erpnext/erpnext/accounts/party.py,Due Date cannot be before Posting / Supplier Invoice Date,Rok ne more biti pred knjiženjem / datumom računa dobavitelja
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the name of the Beneficiary before submittting.,Pred pošiljanjem vnesite ime upravičenca.
apps/erpnext/erpnext/config/healthcare.py,Record Patient Vitals,Posnemite vitalne podatke o bolniku
DocType: Shopping Cart Settings,Show Configure Button,Pokaži gumb za konfiguriranje
DocType: Industry Type,Industry Type,Vrsta industrije
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,Za prvo vrstico ni mogoče izbrati vrste bremenitve kot »Na prejšnjem številu vrstic« ali »Na prejšnji vrstici skupaj«
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shares already exist,Deleži že obstajajo
DocType: Work Order Item,Available Qty at WIP Warehouse,Na voljo Qty at WIP Warehouse
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Resolve error and upload again.,Odpravite napako in jo prenesite znova.
DocType: Travel Request,Copy of Invitation/Announcement,Kopija vabila / obvestila
DocType: Healthcare Service Unit,Healthcare Service Unit,Zdravstvena služba
apps/erpnext/erpnext/controllers/trends.py,Total(Qty),Skupaj (Kol.)
DocType: Employee,Health Insurance No,Zdravstveno zavarovanje št. \ T
DocType: Supplier Scorecard Scoring Standing,Max Grade,Najvišja stopnja
DocType: Department Approver,Approver,Odobritev
,Sales Order Trends,Trendi prodajnega naročila
DocType: Asset Repair,Repair Cost,Stroški popravila
apps/erpnext/erpnext/accounts/general_ledger.py,Please mention Round Off Account in Company,V podjetju navedite »Zaokrožen račun«
DocType: Payroll Entry,Select Payroll Period,Izberite Obračun plač
DocType: Price List,Price List Name,Ime cenovnika
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,You can only submit Leave Encashment for a valid encashment amount,Za veljavno vsoto vplačila lahko pošljete samo oprostitev plačila
DocType: Pricing Rule,"Higher the number, higher the priority","Višje število, višja prednost"
DocType: Designation,Required Skills,Zahtevane spretnosti
DocType: Marketplace Settings,Disable Marketplace,Onemogoči tržnico
DocType: Budget,Action if Annual Budget Exceeded on Actual,"Ukrep, če je letni proračun presežen na dejanski ravni"
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as {1} on leave.,Prisotnost ni bila predložena za {0} kot {1} na dopustu.
DocType: Pricing Rule,Promotional Scheme Id,ID sheme za promocijo
DocType: Driver,License Details,Podrobnosti licence
DocType: Cash Flow Mapper,e.g Adjustments for:,npr. prilagoditve za:
DocType: Selling Settings,Default Quotation Validity Days,Dnevi veljavnosti privzete ponudbe
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,"Bank Account, From Date and To Date are Mandatory","Obvezni so bančni račun, datum in datum"
DocType: Travel Request Costing,Expense Type,Vrsta stroškov
DocType: Account,Auditor,Revizor
apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html,Payment Confirmation,Potrdilo plačila
,Available Stock for Packing Items,Razpoložljiva zaloga za pakirne izdelke
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please remove this Invoice {0} from C-Form {1},Odstranite ta račun {0} iz obrazca C {1}
DocType: Shift Type,Every Valid Check-in and Check-out,Vsaka veljavna prijava in odjava
DocType: Support Search Source,Query Route String,Vrstica poizvedovalne poti
DocType: Customer Feedback Template,Customer Feedback Template,Predloga za povratne informacije strank
apps/erpnext/erpnext/config/selling.py,Quotes to Leads or Customers.,Citati za voditelje ali stranke.
DocType: Driver,Transporter,Transporter
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Slip of employee {0} already created for this period,Zaposlitveni odliv zaposlenega {0} je že ustvarjen za to obdobje
apps/erpnext/erpnext/controllers/selling_controller.py,To {0} | {1} {2},V {0} | {1} {2}
DocType: Leave Block List Date,Block Date,Datum blokiranja
DocType: Sales Team,Contact No.,Št.
DocType: Manufacturing Settings,Overproduction Percentage For Work Order,Odstotek prekomerne proizvodnje za delovni nalog
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Enroll,Včlanite se
DocType: Quotation Lost Reason,Quotation Lost Reason,Izgubljeni razlog
,Employee Billing Summary,Povzetek obračunavanja zaposlenih
apps/erpnext/erpnext/config/settings.py,Country wise default Address Templates,Privzete predloge naslovov za državo
DocType: Cost Center,Parent Cost Center,Nadrejeni stroškovni center
DocType: Pricing Rule,Apply Rule On Item Group,Uporabi pravilo o skupini izdelkov
apps/erpnext/erpnext/utilities/user_progress.py,Example: Basic Mathematics,Primer: Osnovna matematika
DocType: Expense Claim,Total Amount Reimbursed,Skupni povrnjeni znesek
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Validity period of this quotation has ended.,Obdobje veljavnosti te kotacije se je končalo.
,Item-wise Sales History,Element prodajne zgodovine
DocType: Employee,Personal Email,Osebna e-pošta
DocType: Bank Reconciliation Detail,Cheque Date,Datum preverjanja
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Previous Financial Year is not closed,Prejšnje poslovno leto ni zaključeno
DocType: Lead,Next Contact Date,Datum naslednjega stika
DocType: Membership,Membership,Članstvo
DocType: Buying Settings,Default Buying Price List,Privzeti cenik za nakup
DocType: Asset,Depreciation Method,Metoda amortizacije
DocType: Travel Request,Travel Request,Zahteva za potovanje
apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,Ustvarjenih je bilo {0} različic.
DocType: Healthcare Settings,Avoid Confirmation,Izogibajte se potrditvi
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}","Za skladišče, zahtevano pri vrstici št. {0}, nastavite privzeto skladišče za element {1} za podjetje {2}"
DocType: Authorization Control,Authorization Control,Nadzor avtorizacije
,Daily Work Summary Replies,Povzetki dnevnega dela
apps/erpnext/erpnext/projects/doctype/project/project.py,You have been invited to collaborate on the project: {0},Povabljeni ste k sodelovanju v projektu: {0}
DocType: Issue,Response By Variance,Odziv z odstopanjem
DocType: Item,Sales Details,Podrobnosti o prodaji
apps/erpnext/erpnext/config/settings.py,Letter Heads for print templates.,Črke za tiskanje predlog.
DocType: Salary Detail,Tax on additional salary,Davek na dodatno plačo
apps/erpnext/erpnext/public/js/setup_wizard.js,Attach Logo,Priloži logotip
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,For row {0}: Enter Planned Qty,Za vrstico {0}: Vnesite načrtovano količino
DocType: Asset Settings,Calculate Prorated Depreciation Schedule Based on Fiscal Year,Izračunajte razporejen načrt amortizacije na podlagi poslovnega leta
apps/erpnext/erpnext/config/crm.py,Logs for maintaining sms delivery status,Dnevniki za vzdrževanje stanja dostave sms
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Current Job Openings,Trenutno odprta delovna mesta
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.","Pravilo o določanju cen se najprej izbere na podlagi polja »Uporabi na«, ki je lahko predmet, skupina izdelkov ali blagovna znamka."
DocType: Purchase Receipt,Add / Edit Taxes and Charges,Dodaj / uredi davke in stroške
DocType: Item,Supply Raw Materials for Purchase,Dobava surovin za nakup
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal Writing,Pisanje predlogov
DocType: Landed Cost Item,Purchase Receipt Item,Postavka potrdila o nakupu
DocType: Production Plan,Get Sales Orders,Pridobite prodajne naloge
DocType: Pricing Rule,Selling,Prodaja
DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Prepreči naročila za nakup
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Print and Stationery,Tisk in tiskovine
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Buying,Pravilo o dostavi velja samo za nakup
apps/erpnext/erpnext/templates/includes/product_list.js,No products found.,Ni najdenih izdelkov.
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,Vrstica {0}: nastavite na podlagi davčne oprostitve v prometnih davkih in stroških
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Group: ,Skupina za ocenjevanje:
DocType: Tally Migration,Parties,Pogodbenice
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Show exploded view,Prikaži razstavljeni pogled
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,No Delivery Note selected for Customer {},Za stranko ni izbrana dobavnica
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,End on,Konec
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,You can't redeem Loyalty Points having more value than the Grand Total.,Točke zvestobe ne morete unovčiti z večjo vrednostjo kot Grand Total.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Designer,Oblikovalec
DocType: QuickBooks Migrator,Default Warehouse,Privzeto skladišče
DocType: Company,Default Cash Account,Privzeti denarni račun
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please enter Reference date,Vnesite Referenčni datum
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Item {0} must be a stock Item,Postavka {0} mora biti stalna postavka
DocType: POS Profile,Print Format for Online,Format tiskanja za spletno stran
,Employee Leave Balance,Zaposlenost pusti ravnotežje
DocType: Projects Settings,Ignore User Time Overlap,Prezri prekrivanje časa uporabnika
DocType: Stock Entry,As per Stock UOM,Kot na zalogo UOM
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cost Center with existing transactions can not be converted to group,Stroškovnega središča z obstoječimi transakcijami ni mogoče pretvoriti v skupino
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,cannot be greater than 100,ne sme biti večja od 100
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Please Delivery Note first,Prosim najprej dostavite dobavnico
DocType: Leave Type,Leave Type Name,Pusti ime vrste
DocType: Homepage Featured Product,Homepage Featured Product,Predstavljeni izdelek na domači strani
DocType: Assessment Plan,Examiner Name,Ime izpraševalca
,Hotel Room Occupancy,Zasedenost hotelske sobe
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Telecommunications,Telekomunikacije
DocType: Certification Application,Certification Application,Vloga za certificiranje
apps/erpnext/erpnext/stock/doctype/item/item.py,Website Image should be a public file or website URL,Slika spletne strani mora biti javna datoteka ali URL spletnega mesta
apps/erpnext/erpnext/utilities/user_progress.py,Your Suppliers,Vaši dobavitelji
DocType: Appraisal Goal,Weightage (%),Teža (%)
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inter-State Supplies,Meddržavne dobave
DocType: Fees,Send Payment Request,Pošlji zahtevo za plačilo
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} is not added in the table,{0} se ne doda v tabelo
apps/erpnext/erpnext/controllers/stock_controller.py,Quality Inspection required for Item {0} to submit,Za pošiljanje elementa {0} je potrebna kontrola kakovosti
apps/erpnext/erpnext/utilities/activation.py,Create Student,Ustvari študenta
apps/erpnext/erpnext/config/projects.py,Gantt chart of all tasks.,Ganttov diagram vseh nalog.
DocType: Department,Leave Approvers,Pusti odobritve
DocType: BOM,Materials Required (Exploded),Potrebni materiali (eksplodirano)
DocType: Loan,Repay Over Number of Periods,Vračilo v številnih obdobjih
DocType: Account,Receivable,Terjatve
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py,Price List must be applicable for Buying or Selling,Cenik mora biti uporaben za nakup ali prodajo
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Resend Payment Email,Ponovno pošljite e-pošto za plačilo
apps/erpnext/erpnext/regional/italy/utils.py,Please set {0} for address {1},Nastavite {0} za naslov {1}
DocType: Stock Entry,Default Source Warehouse,Privzeto skladišče vira
DocType: Timesheet Detail,Bill,Bill
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Podvojena številka zvitka za študenta {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Batch {0} of Item {1} has expired.,Paket {0} elementa {1} je potekel.
DocType: Lab Test,Approved Date,Odobreni datum
DocType: Item Group,Item Tax,Davek na postavko
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Cannot transfer Employee with status Left,Zaposlenega ni mogoče prenesti s statusom levo
DocType: BOM,Total Cost,Skupni stroški
DocType: Request for Quotation Supplier,Quote Status,Citiraj stanje
DocType: Employee Education,Qualification,Kvalifikacija
DocType: Complaint,Complaints,Pritožbe
DocType: Item,Is Purchase Item,Je nakupna postavka
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Purchase Receipt,Potrdilo o nakupu
DocType: Subscription,Trial Period Start Date,Začetni datum poskusnega obdobja
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Credit Balance,Stanje kredita
DocType: Employee Benefit Application,Payroll Period,Obdobje plač
apps/erpnext/erpnext/config/buying.py,Supplier database.,Podatkovna baza dobaviteljev.
DocType: Tax Rule,Tax Type,Vrsta davka
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Move Item,Premakni element
DocType: Job Opening,Description of a Job Opening,Opis odpiranja delovnega mesta
apps/erpnext/erpnext/utilities/activation.py,Create Users,Ustvarite uporabnike
DocType: Global Defaults,Current Fiscal Year,Tekoče davčno leto
DocType: Item,Hub Warehouse,Skladišče Hub
DocType: Purchase Invoice,Tax Breakup,Davčni prelom
DocType: Job Card,Material Transferred,Preneseni material
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Nimate dovoljenja za dodajanje ali posodabljanje vnosov pred {0}
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date of Birth cannot be greater than today.,Datum rojstva ne more biti večji kot danes.
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Number of serial nos and quantity must be the same,Število serijskih številk in količin mora biti enako
DocType: Company,Exception Budget Approver Role,Vloga izjeme proračunskega pooblaščenca
DocType: Fee Schedule,In Process,V teku
DocType: Daily Work Summary Group,Send Emails At,Pošlji e-pošto na naslov
apps/erpnext/erpnext/public/js/hub/hub_call.js,Marketplace Error,Napaka na tržnici
DocType: Salary Slip,Working Days,Delovni dnevi
DocType: Bank Guarantee,Margin Money,Margin Money
DocType: Chapter,Chapter,Poglavje
DocType: Purchase Receipt Item Supplied,Current Stock,Trenutna zaloga
DocType: Employee,History In Company,Zgodovina v podjetju
DocType: Purchase Invoice Item,Manufacturer,Proizvajalec
apps/erpnext/erpnext/healthcare/setup.py,Moderate Sensitivity,Zmerna občutljivost
DocType: Compensatory Leave Request,Leave Allocation,Pustite dodelitev
apps/erpnext/erpnext/projects/doctype/task/task.js,Timesheet,Časovni list
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation already used for another company,"Kratica, ki se že uporablja za drugo podjetje"
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Please select Patient to get Lab Tests,"Izberite »Bolnik«, da dobite laboratorijske teste"
DocType: Purchase Order,Advance Paid,Advance Paid
DocType: Supplier Scorecard,Load All Criteria,Naloži vse kriterije
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Serial Numbers in row {0} does not match with Delivery Note,Serijske številke v vrstici {0} se ne ujemajo z obvestilom o dobavi
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Creditors,Upniki
DocType: Warranty Claim,Raised By,Povišano
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Reference No and Reference Date is mandatory for Bank transaction,Referenčni št. In referenčni datum je obvezen za bančno transakcijo
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 podlagi skupnega porabljenega zneska je lahko večkratni faktor zbiranja. Vendar bo pretvorbeni faktor za odkup vedno enak za vse stopnje.
DocType: Purchase Invoice Item,Batch No,Serijska št
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Executive Search,Iskanje vodstva
DocType: Company,Stock Adjustment Account,Račun za prilagoditev delnic
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Gross Profit %,Bruto dobiček %
DocType: Lead,Request Type,Vrsta zahteve
DocType: Patient Appointment,Reminded,Opomniti
DocType: Accounts Settings,Billing Address,Naslov za pošiljanje računa
DocType: Student Leave Application,Mark as Present,Označi kot prisotno
DocType: Landed Cost Voucher,Landed Cost Voucher,Kupon za iztovorjene stroške
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Total working hours should not be greater than max working hours {0},Skupno število delovnih ur ne sme biti večje od največjega delovnega časa {0}
DocType: Communication Medium Timeslot,Communication Medium Timeslot,Komunikacijska srednja časovna vrstica
apps/erpnext/erpnext/config/selling.py,Customer Addresses And Contacts,Naslovi strank in stiki
DocType: Project,Task Progress,Napredek naloge
DocType: Journal Entry,Opening Entry,Začetni vnos
DocType: Bank Guarantee,Charges Incurred,Nastali stroški
DocType: Shift Type,Working Hours Calculation Based On,Izračun delovnih ur na podlagi
DocType: Work Order,Material Transferred for Manufacturing,Preneseni material za proizvodnjo
DocType: Products Settings,Hide Variants,Skrij različice
DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Onemogoči načrtovanje zmogljivosti in sledenje času
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* V transakciji se izračuna.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} is required for 'Balance Sheet' account {1}.,{0} je potreben za račun »Bilanca stanja« {1}.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} not allowed to transact with {1}. Please change the Company.,"{0} ni dovoljeno opravljati transakcij z {1}. Prosimo, spremenite podjetje."
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}","V skladu z nastavitvami nakupa, če je potreben nakup za nakup == &quot;DA&quot;, mora uporabnik za ustvarjanje računa za nakup najprej ustvariti potrdilo o nakupu za element {0}"
DocType: Delivery Trip,Delivery Details,Podrobnosti o dostavi
DocType: Inpatient Record,Discharge Scheduled,Načrtovano razrešnico
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,"Reference: {0}, Item Code: {1} and Customer: {2}","Referenca: {0}, koda izdelka: {1} in stranka: {2}"
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Caution,Pozor!
DocType: Project User,View attachments,Oglejte si priloge
DocType: Manufacturing Settings,Allow Production on Holidays,Dovoli proizvodnjo na počitnicah
apps/erpnext/erpnext/config/accounting.py,Update Bank Transaction Dates,Posodobite datume bančnih transakcij
DocType: Quality Inspection Reading,Reading 4,Branje 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",Element {0} nima serijskega števila. Samo serilizirani elementi imajo lahko dostavo na podlagi serijske številke
DocType: Program Course,Program Course,Programski tečaj
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefonski stroški
DocType: Patient,Widow,Vdova
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Number of Interaction,Število interakcij
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}","Za več cenovnih pravil veljajo enaka merila, zato razrešite spor tako, da določite prednost. Pravila cen: {0}"
apps/erpnext/erpnext/config/accounting.py,Cost Center and Budgeting,Mesto stroškov in oblikovanje proračuna
,Ordered Items To Be Delivered,"Naročene postavke, ki jih je treba dostaviti"
DocType: Homepage Section Card,Homepage Section Card,Kartica spletne strani
DocType: Account,Depreciation,Amortizacija
DocType: Guardian,Interests,Interesi
DocType: Purchase Receipt Item Supplied,Consumed Qty,Porabljena količina
DocType: Education Settings,Education Manager,Vodja izobraževanja
DocType: Employee Checkin,Shift Actual Start,Premakni dejanski začetek
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Načrtujte dnevnike časa izven delovnega časa delovne postaje.
apps/erpnext/erpnext/public/js/utils.js,Loyalty Points: {0},Točke zvestobe: {0}
DocType: Healthcare Settings,Registration Message,Sporočilo o registraciji
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Select an account to print in account currency,Izberite račun za tiskanje v valuti računa
apps/erpnext/erpnext/accounts/page/pos/pos.js,Serial no item cannot be a fraction,Serijska postavka ne more biti del
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Skladišče ni mogoče izbrisati, ker za to skladišče obstaja postavka knjig."
apps/erpnext/erpnext/templates/pages/cart.html,See past quotations,Oglejte si prejšnje ponudbe
apps/erpnext/erpnext/www/all-products/index.html,Prev,Prejšnja
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Unit of Measure,Merska enota
DocType: Lab Test,Test Template,Preskusna predloga
DocType: Fertilizer,Fertilizer Contents,Vsebina gnojila
DocType: Quality Meeting Minutes,Minute,Minuta
apps/erpnext/erpnext/controllers/accounts_controller.py,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Vrstice # {0}: Sredstvo {1} ni mogoče poslati, že {2}"
DocType: Task,Actual Time (in Hours),Dejanski čas (v urah)
DocType: Period Closing Voucher,Closing Account Head,Vodja zaključnega računa
DocType: Purchase Invoice,Shipping Rule,Pravilo pošiljanja
DocType: Shipping Rule,Net Weight,Neto teža
apps/erpnext/erpnext/public/js/setup_wizard.js,Please enter valid Financial Year Start and End Dates,Vnesite veljaven začetni in končni datum finančnega leta
DocType: POS Closing Voucher Invoices,Quantity of Items,Količina predmetov
DocType: Warehouse,PIN,PIN
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab testing datetime cannot be before collection datetime,Datetime čas laboratorijskega testiranja ne more biti pred datumom zbiranja podatkov
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Invoice already created for all billing hours,Račun je že ustvarjen za vse obračunske ure
DocType: Sales Partner,Contact Desc,Kontaktna služba
DocType: Purchase Invoice,Pricing Rules,Pravila o določanju cen
apps/erpnext/erpnext/stock/doctype/item/item.py,"As there are existing transactions against item {0}, you can not change the value of {1}","Ker obstajajo obstoječe transakcije z elementom {0}, ne morete spremeniti vrednosti {1}"
DocType: Hub Tracked Item,Image List,Seznam slik
DocType: Item Variant Settings,Allow Rename Attribute Value,Dovoli preimenovanje vrednosti atributa
apps/erpnext/erpnext/templates/generators/bom.html,Time(in mins),Čas (v min)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Basic,Osnovno
DocType: Loan,Interest Income Account,Račun prihodkov iz obresti
DocType: Shipping Rule Condition,A condition for a Shipping Rule,Pogoj za plovni predpis
DocType: Payroll Period Date,Payroll Period Date,Datum plačilnega obdobja
DocType: Employee,Employment Type,tip zaposlitve
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Select POS Profile,Izberite profil POS
DocType: Support Settings,Get Latest Query,Prenesite najnovejšo poizvedbo
DocType: Employee Incentive,Employee Incentive,Spodbuda za zaposlene
DocType: Service Level,Priorities,Prednostne naloge
apps/erpnext/erpnext/config/website.py,Add cards or custom sections on homepage,Dodajte kartice ali razdelke po meri na domačo stran
DocType: Homepage,Hero Section Based On,Odsek junaka na podlagi
DocType: Project,Total Purchase Cost (via Purchase Invoice),Skupna nabavna cena (prek računa za nakup)
DocType: Staffing Plan Detail,Total Estimated Cost,Skupna ocenjena cena
DocType: Item,"Sales, Purchase, Accounting Defaults","Prodaja, nakup, privzeti računi"
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Requesting payment against {0} {1} for amount {2},Zahteva za plačilo za {0} {1} za znesek {2}
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Please set the Item Code first,Najprej nastavite kodo postavke
DocType: Payment Term,Due Date Based On,Datum zapadlosti na podlagi
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Payment,Novo plačilo
DocType: Quality Inspection,Incoming,Dohodni
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Ordered,Delno naročeno
DocType: Delivery Note,Customer's Purchase Order No,Naročniška naročilnica št
apps/erpnext/erpnext/public/js/utils.js,Select Alternate Item,Izberite nadomestni element
DocType: Employee,Applicable Holiday List,Veljavni praznični seznam
DocType: Hub Tracked Item,Hub Tracked Item,Element sledilnega središča
DocType: Vehicle Log,Service Details,Podrobnosti storitve
DocType: Program,Is Featured,Predstavljeno je
DocType: HR Settings,Don't send Employee Birthday Reminders,Ne pošiljajte opominov za rojstni dan zaposlenih
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Ohranite enako hitrost v celotnem prodajnem ciklu
DocType: Program Enrollment,Transportation,Prevoz
DocType: Patient Appointment,Date TIme,Datum čas
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Izberite količino v vrstici
DocType: Employee Benefit Application Detail,Earning Component,Komponenta zaslužka
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Please select Company first,Najprej izberite podjetje
DocType: Item,Publish Item to hub.erpnext.com,Objavi element na hub.erpnext.com
apps/erpnext/erpnext/projects/doctype/project/project.py,Join,Pridruži se
DocType: BOM,Set rate of sub-assembly item based on BOM,Nastavi hitrost postavke podsklopa na podlagi BOM
DocType: Vehicle,Wheels,Kolesa
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","Zbirna skupina ** elementov ** v drugo ** postavko **. To je uporabno, če združujete določene postavke ** v paket in vzdržujete zalogo pakiranih ** predmetov ** in ne agregat ** element **. Paket ** Item ** bo imel &quot;Je postavka&quot; kot &quot;Ne&quot; in &quot;Je prodajna postavka&quot; kot &quot;Da&quot;. Primer: Če prodajate prenosnike in nahrbtnike ločeno in imate posebno ceno, če kupec kupi oboje, bo Laptop + nahrbtnik nov element paketa izdelkov. Opomba: BOM = ponudba materialov"
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},Drugi proračunski zapis &quot;{0}&quot; že obstaja za {1} &#39;{2}&#39; in račun &#39;{3}&#39; za proračunsko leto {4}
DocType: Asset,Purchase Receipt Amount,Znesek potrdila o nakupu
DocType: Issue,Ongoing,V teku
DocType: Service Level Agreement,Agreement Details,Podrobnosti pogodbe
DocType: Purchase Invoice,Posting Time,Čas objavljanja
DocType: Loyalty Program,Loyalty Program Name,Ime programa zvestobe
DocType: Patient,Dormant,Miren
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,Priložite datoteko po meri Chart of Accounts
apps/erpnext/erpnext/config/help.py,Item Variants,Točka Različice
DocType: Maintenance Visit,Fully Completed,Popolnoma končano
apps/erpnext/erpnext/controllers/item_variant.py,Rename Not Allowed,Preimenuj ni dovoljeno
DocType: Bank Statement Transaction Invoice Item,Transaction Date,Datum transakcije
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,No data for this period,Za to obdobje ni podatkov
DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,"Privzeti račun bo samodejno posodobljen v POS računu, ko je izbran ta način."
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation cannot have more than 5 characters,Kratica podjetja ne sme imeti več kot 5 znakov
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting_list.js,Canceled,Prekinjeno
apps/erpnext/erpnext/utilities/user_progress.py,Customers and Suppliers,Kupci in dobavitelji
,To Produce,Izdelovati
DocType: Location,Is Container,Is Container
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Research & Development,Raziskave in razvoj
DocType: QuickBooks Migrator,Application Settings,Nastavitve aplikacij
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Production Order cannot be raised against a Item Template,Proizvodne naloge ni mogoče uveljaviti za predlogo postavke
DocType: Work Order,Manufacture against Material Request,Izdelava glede na zahtevo za material
DocType: Blanket Order Item,Ordered Quantity,Naročena količina
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Vrstica # {0}: zavrnjeno skladišče je obvezno proti zavrnjeni postavki {1}
,Received Items To Be Billed,"Prejeti elementi, ki jih je treba zaračunati"
DocType: Attendance,Working Hours,Delovni čas
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py,Payment Mode,Način plačila
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Purchase Order Items not received on time,Postavke naročila niso bile prejete pravočasno
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Duration in Days,Trajanje v dneh
DocType: Customer,Sales Team Details,Podrobnosti prodajne ekipe
DocType: BOM Update Tool,Replace,Zamenjati
DocType: Training Event,Event Name,Ime dogodka
DocType: SMS Center,Receiver List,Seznam sprejemnikov
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?,"Ali ste prepričani, da želite preklicati ta sestanek?"
DocType: Invoice Discounting,Accounts Receivable Credit Account,Kreditni račun terjatev
DocType: Naming Series,Prefix,Predpona
DocType: Work Order Operation,Actual Operation Time,Dejanski čas delovanja
DocType: Purchase Invoice Item,Net Rate,Neto stopnja
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Neto sprememba gotovine
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.py,Set warehouse for Procedure {0} ,Nastavi skladišče za postopek {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Block Invoice,Blokiraj račun
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} does not exist,Račun {0}: nadrejeni račun {1} ne obstaja
DocType: HR Settings,Encrypt Salary Slips in Emails,Šifriranje plače zdrsne v e-poštnih sporočilih
DocType: Supplier Scorecard Scoring Criteria,Score,Ocena
DocType: Delivery Note,Driver Name,Ime voznika
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select Incharge Person's name,"Prosimo, izberite ime osebe za polnjenje"
DocType: Employee Training,Training,Usposabljanje
apps/erpnext/erpnext/config/stock.py,Stock Reports,Poročila o zalogah
apps/erpnext/erpnext/stock/doctype/item/item.py,Conversion factor for default Unit of Measure must be 1 in row {0},Faktor pretvorbe za privzeto mersko enoto mora biti 1 v vrstici {0}
DocType: Course Scheduling Tool,Course Scheduling Tool,Orodje za načrtovanje tečaja
,Finished Goods,Končnih izdelkov
DocType: Sales Invoice Item,Customer Warehouse (Optional),Skladišče stranke (izbirno)
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Master Data,Glavni podatki sinhronizacije
DocType: Lead,Address & Contact,Naslov in stik
DocType: Bank Reconciliation,To Date,Do datuma
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Error in some rows,Napaka v nekaterih vrsticah
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py,Lab Tests and Vital Signs,Laboratorijski testi in vitalni znaki
apps/erpnext/erpnext/config/accounting.py,Tax Rule for transactions.,Davčno pravilo za transakcije.
DocType: Stock Settings,Show Barcode Field,Pokaži polje črtne kode
DocType: Packing Slip Item,DN Detail,DN Podrobnosti
DocType: Vital Signs,Fluid,Fluid
DocType: GST Settings,B2C Limit,Omejitev B2C
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Electronic Equipments,Elektronska oprema
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Cannot find active Leave Period,Obdobja aktivnega dopusta ni mogoče najti
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Create Maintenance Visit,Ustvarite obisk za vzdrževanje
DocType: Healthcare Service Unit Type,Change In Item,Sprememba postavke
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,{0} Students have been enrolled,{0} Študenti so bili vpisani
DocType: Vehicle Service,Inspection,Pregled
DocType: Location,Area,Območje
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Summary for this week and pending activities,Povzetek za ta teden in nedokončane dejavnosti
DocType: Asset Maintenance Task,Maintenance Task,Naloga vzdrževanja
DocType: Subscription,Current Invoice Start Date,Trenutni datum začetka računa
DocType: Purchase Invoice Item,Item,Postavka
DocType: Program Enrollment Tool,Get Students From,Pridobite študente
DocType: Amazon MWS Settings,Always synch your products from Amazon MWS before synching the Orders details,Pred sinhronizacijo podrobnosti o naročilih vedno usklajujte svoje izdelke z Amazon MWS
DocType: Leave Block List,Leave Block List Name,Zapusti ime seznama blokov
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,"Could not update stock, invoice contains drop shipping item.","Stanje ni bilo mogoče posodobiti, račun vsebuje izdelek za pošiljanje."
DocType: Asset Maintenance Log,Completion Date,datum dokončanja
DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,"Stopnja, pri kateri se valuta dobavitelja preračuna v osnovno valuto podjetja"
DocType: Leave Control Panel,Leave Control Panel,Pustite nadzorno ploščo
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,Skupne veljavne dajatve v preglednici Postavke prejemkov za nakup morajo biti enake skupnim davkom in stroškom
DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,"V besedi bo viden, ko shranite opombo o dostavi."
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Suppliies made to Composition Taxable Persons,Dobave za sestavo davčnih zavezancev
DocType: Bin,Reserved Qty for Production,Rezervirana količina za proizvodnjo
DocType: Asset,Quality Manager,Vodja kakovosti
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.","Konfigurirajte polja, kot so UOM, skupina izdelkov, opis in število ur."
apps/erpnext/erpnext/hr/doctype/department/department_tree.js,New Department,Novi oddelek
DocType: Employee,Job Applicant,Prijavitelj dela
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Create Invoices,Ustvari račune
DocType: Purchase Invoice Item,Purchase Order Item,Postavka naročila
apps/erpnext/erpnext/config/settings.py,Data Import and Export,Uvoz in izvoz podatkov
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Please contact to the user who have Sales Master Manager {0} role,"Obrnite se na uporabnika, ki ima vlogo Sales Master Managerja {0}"
apps/erpnext/erpnext/projects/doctype/project_type/project_type.py,You cannot delete Project Type 'External',Tipa »Zunanji« ne morete izbrisati
DocType: Account,Temporary,Začasno
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Column Labels : ,Oznake stolpcev:
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Employee A/C Number,Številka zaposlenega A / C
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date should be before Closing Date,Datum odprtja mora biti pred datumom zaključka
DocType: Packed Item,Parent Detail docname,Osnovni podrobni dokument
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Podrobnosti o bančni poravnavi
DocType: Tax Withholding Rate,Cumulative Transaction Threshold,Skupni prag transakcij
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","Število intervalov za polje intervalov, npr. Če je interval &quot;dnevi&quot; in štetje intervala obračunavanja 3, bodo računi ustvarjeni vsake 3 dni"
apps/erpnext/erpnext/projects/doctype/task/task.py,'Actual Start Date' can not be greater than 'Actual End Date',»Dejanski datum začetka« ne sme biti večji od »Dejanski končni datum«
DocType: Payment Entry Reference,Payment Entry Reference,Referenca vnosa plačil
DocType: Salary Component Account,Salary Component Account,Račun sestavnih delov plač
DocType: Supplier,Default Payable Accounts,Privzeti plačljivi računi
DocType: Purchase Invoice,In Words,V besedah
DocType: Journal Entry Account,Purchase Order,Naročilnica
apps/erpnext/erpnext/education/utils.py,You are not enrolled in program {0},Niste vpisani v program {0}
DocType: Journal Entry,Entry Type,Vrsta vnosa
apps/erpnext/erpnext/config/healthcare.py,Laboratory,Laboratorij
DocType: Purchase Order,To Bill,Billu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Utility Expenses,Stroški komunalnih storitev
DocType: Manufacturing Settings,Time Between Operations (in mins),Čas med operacijami (v min)
DocType: GSTR 3B Report,May,May
apps/erpnext/erpnext/accounts/utils.py,"Payment Gateway Account not created, please create one manually.","Račun plačilnega prehoda ni ustvarjen, ustvarite ga ročno."
DocType: Opening Invoice Creation Tool,Purchase,Nakup
DocType: Program Enrollment,School House,Šolska hiša
apps/erpnext/erpnext/public/js/setup_wizard.js,Please select at least one domain.,Izberite vsaj eno domeno.
apps/erpnext/erpnext/projects/doctype/project/project.py,Daily Project Summary for {0},Dnevni povzetek projekta za {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py,All Territories,Vsa ozemlja
DocType: Asset Repair,Failure Date,Datum odpovedi
DocType: Training Event,Attendees,Udeleženci
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Total Outstanding,Skupaj neporavnanih
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Amount of TDS Deducted,Znesek TDS Odštet
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Cash or Bank Account is mandatory for making payment entry,Gotovinski ali bančni račun je obvezen za opravljanje plačilnega vnosa
DocType: Company,Registration Details,Podrobnosti registracije
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Calculated Bank Statement balance,Izračunano stanje bančnega izida
DocType: Bank Transaction,Bank Transaction,Bančna transakcija
apps/erpnext/erpnext/hub_node/api.py,Only users with {0} role can register on Marketplace,V Marketplaceu se lahko registrirajo samo uporabniki z vlogo {0}
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}.","Skladišče {0} ni povezano z nobenim računom, prosimo, navedite račun v zapisu skladišča ali v podjetju {1} nastavite privzeti račun inventarja."
DocType: Inpatient Record,Admission,Sprejem
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py,This is based on the attendance of this Student,To temelji na prisotnosti tega študenta
DocType: SMS Center,Create Receiver List,Ustvarite seznam sprejemnikov
DocType: Leave Type,Max Leaves Allowed,Največ dovoljenih listov
DocType: Salary Detail,Component,Komponenta
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Leave and Attendance,Dopust in udeležba
DocType: Sales Invoice Timesheet,Billing Amount,Znesek obračunavanja
DocType: BOM Website Item,BOM Website Item,Postavka spletne strani BOM
DocType: Purchase Invoice,Rounded Total,Zaokroženo skupaj
DocType: Production Plan,Production Plan,Proizvodni načrt
DocType: Asset Maintenance Log,Actions performed,Izvedeni ukrepi
DocType: Purchase Invoice,Set Accepted Warehouse,Nastavite Sprejeto skladišče
apps/erpnext/erpnext/config/buying.py,Rules for applying pricing and discount.,Pravila za uporabo cen in popustov.
DocType: Supplier,Statutory info and other general information about your Supplier,Zakonske informacije in druge splošne informacije o vašem dobavitelju
DocType: Item Default,Default Selling Cost Center,Privzeto prodajno mesto za prodajo
DocType: Sales Partner,Address & Contacts,Naslov in stiki
DocType: Subscriber,Subscriber,Naročnik
apps/erpnext/erpnext/utilities/bot.py,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / Item / {0}) ni na zalogi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Please select Posting Date first,Najprej izberite Datum knjiženja
DocType: Supplier,Mention if non-standard payable account,"Navedite, če je nestandardni plačljivi račun"
DocType: Training Event,Advance,Vnaprej
DocType: Project,% Complete Method,% Dokončana metoda
DocType: Detected Disease,Tasks Created,"Naloge, ustvarjene"
apps/erpnext/erpnext/stock/doctype/item/item.py,Default BOM ({0}) must be active for this item or its template,Privzeta BOM ({0}) mora biti aktivna za to postavko ali njeno predlogo
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Commission Rate %,Stopnja Komisije%
DocType: Service Level Priority,Response Time,Odzivni čas
DocType: Woocommerce Settings,Woocommerce Settings,Nastavitve za Woocommerce
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Quantity must be positive,Količina mora biti pozitivna
DocType: Contract,CRM,CRM
DocType: Purchase Taxes and Charges,Parenttype,Starševski tip
DocType: Tax Rule,Billing State,Država plačevanja
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Quantity for Item {0} must be less than {1},Količina za element {0} mora biti manjša od {1}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Transfer Material,Prenosni material
DocType: Shipping Rule,Shipping Account,Ladijski račun
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Approval Notification in HR Settings.,Nastavite privzeto predlogo za obvestilo o dopustu v nastavitvah za HR.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Television,Televizija
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Debit ({0}),Bremenitev ({0})
DocType: Healthcare Practitioner,Inpatient Visit Charge,Stroški bolnišničnega obiska
DocType: Bank Statement Settings,Transaction Data Mapping,Preslikava podatkov o transakcijah
apps/erpnext/erpnext/crm/doctype/lead/lead.py,A Lead requires either a person's name or an organization's name,Voditelj zahteva ime osebe ali ime organizacije
DocType: Student,Guardians,Varuhi
apps/erpnext/erpnext/public/js/stock_analytics.js,Select Brand...,Izberite blagovno znamko ...
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Middle Income,Srednji dohodek
DocType: Shipping Rule,Calculate Based On,Izračunajte na podlagi
DocType: Company,Default warehouse for Sales Return,Privzeto skladišče za vrnitev prodaje
apps/erpnext/erpnext/stock/doctype/item/item.py,Barcode {0} already used in Item {1},Črtna koda {0} je že uporabljena v elementu {1}
DocType: Lead,Campaign Name,Ime oglaševalske akcije
DocType: Purchase Invoice,Rejected Warehouse,Zavrnjeno skladišče
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,Predložiti je treba {0} {1}
DocType: Expense Claim Advance,Expense Claim Advance,Vnaprejšnja odškodninska terjatev
DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Prilagoditev zaokroževanja (valuta podjetja)
DocType: Item,Publish in Hub,Objavi v središču
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,GSTIN,GSTIN
DocType: GSTR 3B Report,August,Avgust
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter Purchase Receipt first,Najprej vnesite potrdilo o nakupu
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Start Year,Začetek leta
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Target ({}),Cilj ({})
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set Default Payroll Payable Account in Company {0},"Prosimo, da v podjetju nastavite privzeti plačilni račun za plače {0}"
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html,Sales Summary,Povzetek prodaje
DocType: Purchase Invoice,In Words (Company Currency),V besedi (valuta podjetja)
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,V podjetju navedite valuto
DocType: Pricing Rule,Price,Cena
DocType: Material Request Item,Min Order Qty,Minimalna količina naročila
DocType: Agriculture Task,Holiday Management,Upravljanje počitnic
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 ustvarjanjem dnevne skupine povzetkov dela omogočite privzeti dohodni račun
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.,Iz seznama potrditvenih polj lahko izberete največ eno možnost.
DocType: Program Enrollment,Public Transport,Javni prevoz
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Največje število vzorcev - {0} je mogoče obdržati za paketne {1} in element {2}.
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Upload a statement,Prenesite izjavo
DocType: Item,Max Sample Quantity,Največja vzorčna količina
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Source and target warehouse must be different,Vir in ciljno skladišče morata biti različna
DocType: Employee Benefit Application,Benefits Applied,Uporabljene ugodnosti
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Against Journal Entry {0} does not have any unmatched {1} entry,Proti vnosu v dnevnik {0} ni nobenega neizravnanega vnosa {1}
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,"Special Characters except ""-"", ""#"", ""."", ""/"", ""{"" and ""}"" not allowed in naming series","Posebni znaki, razen &quot;-&quot;, &quot;#&quot;, &quot;.&quot;, &quot;/&quot;, &quot;{&quot; In &quot;}&quot; niso dovoljeni v poimenovanju nizov"
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Price or product discount slabs are required,Zahtevajo se plošče za cene ali izdelke
apps/erpnext/erpnext/utilities/user_progress.py,Set a Target,Nastavite cilj
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Attendance Record {0} exists against Student {1},Zapis o prisotnosti {0} obstaja proti študentu {1}
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Date of Transaction,Datum transakcije
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Cancel Subscription,Prekliči naročnino
apps/erpnext/erpnext/support/doctype/issue/issue.py,Couldn't Set Service Level Agreement {0}.,Ni mogoče določiti sporazuma o ravni storitve {0}.
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Net Salary Amount,Znesek neto plač
DocType: Account,Liability,Odgovornost
DocType: Employee,Bank A/C No.,Bančni A / C št.
DocType: Inpatient Record,Discharge Note,Opozorilo o raztovarjanju
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on MR,"Ukrep, če je skupni mesečni proračun presežen na podlagi MR"
DocType: Asset Movement,Asset Movement,Gibanje sredstev
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Samodejnega ustvarjanja bančnega računa ni bilo mogoče ustvariti, počistite potrditev »Opomba o izdaji« in jo ponovno pošljite"
DocType: Supplier Scorecard,Per Month,Na mesec
DocType: Routing,Routing Name,Ime poti
DocType: Disease,Common Name,Pogosto ime
DocType: Education Settings,LMS Title,Naslov LMS
apps/erpnext/erpnext/config/non_profit.py,Loan Management,Upravljanje posojil
DocType: Clinical Procedure,Consumable Total Amount,Celotni potrošni znesek
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Enable Template,Omogoči predlogo
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Customer LPO,LPO stranke
apps/erpnext/erpnext/stock/doctype/item/item.py,Website Image {0} attached to Item {1} cannot be found,"Slike spletnega mesta {0}, priložene elementu {1}, ni mogoče najti"
DocType: Asset Maintenance Log,Planned,Načrtovano
DocType: Asset,Custodian,Skrbnik
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, ki temelji na stroškovnem središču, je uporaben samo, če je izbrano »Proračun proti« kot »Stroškovno mesto«"
,Quoted Item Comparison,Citirana primerjava izdelkov
DocType: Journal Entry Account,Employee Advance,Predplačilo zaposlenih
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward supplies liable to reverse charge (other than 1 & 2 above),"Notranje dobave, ki so lahko obrnjene (razen zgoraj navedenih 1 in 2)"
DocType: Quotation,Shopping Cart,Nakupovalni voziček
apps/erpnext/erpnext/hr/doctype/employee/employee.py,User {0} does not exist,Uporabnik {0} ne obstaja
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Loans and Advances (Assets),Posojila in predplačila (sredstva)
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.,"Vrstica {0}: Prosimo, označite &#39;Ali je vnaprej&#39; proti računu {1}, če je to vnos vnaprej."
DocType: Leave Control Panel,Designation (optional),Oznaka (neobvezno)
DocType: Salary Slip,Total Principal Amount,Skupni glavni znesek
DocType: Opportunity,Customer / Lead Address,Naslov stranke / vodje
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Soap & Detergent,Milo in detergent
,Purchase Analytics,Kupite storitev Analytics
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Opportunity,Priložnost
DocType: Employee,Prefered Contact Email,Želena kontaktna e-pošta
apps/erpnext/erpnext/config/help.py,Opening Accounting Balance,Odpiranje računovodskega stanja
DocType: POS Profile,[Select],[Izberi]
DocType: Stock Reconciliation,MAT-RECO-.YYYY.-,MAT-RECO-.YYYY.-
DocType: Tally Migration,Master Data,Glavni podatki
DocType: Certification Application,Yet to appear,"Še, da se pojavi"
apps/erpnext/erpnext/public/js/pos/pos.html,Customers in Queue,Stranke v čakalni vrsti
DocType: Supplier,Supplier Details,Podrobnosti dobavitelja
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,No gain or loss in the exchange rate,Noben dobiček ali izguba menjalnega tečaja
,GSTR-1,GSTR-1
DocType: Timesheet,Total Billable Hours,Skupno število plačljivih ur
DocType: Supplier,Represents Company,Predstavlja podjetje
DocType: POS Profile,Company Address,naslov podjetja
,Lead Name,Ime svinca
apps/erpnext/erpnext/config/agriculture.py,Diseases & Fertilizers,Bolezni in gnojila
apps/erpnext/erpnext/stock/get_item_details.py,Item {0} must be a Sub-contracted Item,Postavka {0} mora biti podizvajalska postavka
DocType: Landed Cost Voucher,Purchase Receipt Items,Nakup Postavke prejemkov
DocType: Production Plan,Ignore Existing Projected Quantity,Prezri obstoječo predvideno količino
DocType: Assessment Plan,Supervisor,Nadzornik
DocType: Salary Detail,Salary Detail,Podrobnosti o plačah
DocType: Budget,Budget Against,Proračun proti
DocType: Student Report Generation Tool,Add Letterhead,Dodajte pisemsko glavo
apps/erpnext/erpnext/config/buying.py,Templates of supplier scorecard criteria.,Predloge meril za oceno dobavitelja.
DocType: Asset,Default Finance Book,Privzeta finančna knjiga
apps/erpnext/erpnext/stock/get_item_details.py,Please specify Company,Navedite podjetje
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Total contribution percentage should be equal to 100,Skupni odstotek prispevka mora biti enak 100
DocType: GoCardless Settings,Webhooks Secret,Spletna skrivnost
,Asset Depreciations and Balances,Amortizacije sredstev in stanja
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch Qty,Nova količina pakiranja
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of goods,Uvoz blaga
DocType: Purchase Order Item Supplied,Raw Material Item Code,Šifra postavke surovine
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Purchase Invoice {0} is already submitted,Račun za nakup {0} je že poslan
DocType: Fees,Student Email,E-naslov študenta
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Get Items from Healthcare Services,Pridobite izdelke iz zdravstvenih storitev
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Stock Entry {0} is not submitted,Vnos delnice {0} ni predložen
DocType: Item Attribute Value,Item Attribute Value,Vrednost atributa elementa
DocType: Volunteer,Volunteer Skills,Prostovoljne spretnosti
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Cannot enroll more than {0} students for this student group.,V to skupino študentov ni mogoče vpisati več kot {0} študentov.
DocType: Travel Request,Costing Details,Podrobnosti o kalkulaciji
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Sales Invoice {0} has already been submitted,Račun za prodajo {0} je že bil poslan
DocType: Journal Entry,Accounting Entries,Računovodski vnosi
DocType: Payment Entry,Internal Transfer,Notranji prenos
DocType: Sales Invoice Item,Stock Details,Zaloga Podrobnosti
DocType: Leave Type,Is Carry Forward,Prenaša naprej
DocType: Lead,Product Enquiry,Povpraševanje po izdelkih
DocType: Purchase Order,PUR-ORD-.YYYY.-,PUR-ORD-.YYYY.-
DocType: Supplier Scorecard,Evaluation Period,Obdobje vrednotenja
DocType: Volunteer Skill,Volunteer Skill,Spretnost prostovoljcev
DocType: Purchase Order,Order Confirmation No,Potrditev naročila št
,POS,POS
DocType: Training Event,Self-Study,Samoizobraževanje
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Above,Nad
DocType: Setup Progress Action,Action Doctype,Ukrep Doctype
DocType: POS Profile,Allow Print Before Pay,Dovoli tiskanje pred plačilom
DocType: Production Plan,Select Items to Manufacture,Izberite elemente za izdelavo
DocType: Leave Application,Leave Approver Name,Pusti ime odobritve
DocType: Shareholder,Shareholder,Delničar
apps/erpnext/erpnext/config/selling.py,Default settings for selling transactions.,Privzete nastavitve za prodajne transakcije.
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Please select Student Admission which is mandatory for the paid student applicant,"Prosimo, da izberete sprejem študentov, ki je obvezen za plačanega študenta"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select BOM,Izberite BOM
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Časovni razporedi za {0} prekrivanja, želite nadaljevati po preskoku prekrivanih slotov?"
DocType: Stock Entry,Customer or Supplier Details,Podatki o stranki ali dobavitelju
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Debit Account,Debetni račun
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Trial Period End Date Cannot be before Trial Period Start Date,Končni datum preskusnega obdobja Ne more biti pred začetnim datumom poskusnega obdobja
DocType: Employee,Rented,Najem
DocType: Employee Group Table,Employee Group Table,Skupinska tabela zaposlenih
DocType: Contract,HR Manager,HR menedžer
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 zunanjih dobavah in oskrbi, ki so lahko obrnjene"
DocType: Payment Entry,Cheque/Reference No,Št
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js,Assessment Result,Rezultat ocenjevanja
apps/erpnext/erpnext/public/js/templates/contact_list.html,New Contact,Nov kontakt
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Opportunities,Priložnosti
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Neto denar iz poslovanja
DocType: Leave Encashment,Leave Encashment,Zapusti invazijo
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Source warehouse is mandatory for row {0},Izvorno skladišče je obvezno za vrstico {0}
DocType: Amazon MWS Settings,After Date,Po datumu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Available (whether in full op part),ITC na voljo (v celoti)
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: Activity Type is mandatory.,Vrstica {0}: Vrsta dejavnosti je obvezna.
DocType: Lead,Consultant,Svetovalec
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Select an employee to get the employee advance.,"Izberite zaposlenega, s katerim bo zaposleni napredoval."
apps/erpnext/erpnext/assets/doctype/asset/asset.py,"Asset cannot be cancelled, as it is already {0}","Sredstva ni mogoče preklicati, ker je že {0}"
apps/erpnext/erpnext/setup/doctype/company/company.js,Wrong Password,Napačno geslo
DocType: Item,STO-ITEM-.YYYY.-,STO-ITEM-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Number / Name,Posodobi številko računa / ime
apps/erpnext/erpnext/hub_node/api.py,Unable to update remote activity,Nadaljnje dejavnosti ni mogoče posodobiti
DocType: Accounts Settings,Use Custom Cash Flow Format,Uporabite obliko prilagojenega denarnega toka
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices,Odpiranje računov
DocType: Stock Entry,Send to Warehouse,Pošlji v skladišče
DocType: Training Event,Event Status,Stanje dogodka
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Total completed qty must be greater than zero,Skupno zaključeno število mora biti večje od nič
DocType: Account,Chargeable,Obračunski
DocType: Volunteer,Anytime,Kadarkoli
,Student Batch-Wise Attendance,Udeležba študentov v seriji
DocType: Normal Test Template,Normal Test Template,Običajna testna predloga
apps/erpnext/erpnext/config/accounting.py,Tree of financial Cost Centers.,Drevo finančnih stroškovnih mest.
DocType: Work Order Operation,"in Minutes
Updated via 'Time Log'",v minutah posodobljeno prek »Dnevnika časa«
DocType: Bin,Bin,Bin
DocType: Call Log,Call Duration in seconds,Trajanje klica v sekundah
DocType: Payment Reconciliation Invoice,Invoice Number,Številka računa
DocType: Delivery Trip,Fulfillment User,Izpolnjeni uporabnik
DocType: Work Order Operation,Planned End Time,Načrtovani končni čas
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Section Code,Koda oddelka
DocType: Project,Monitor Progress,Monitor Progress
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select Batch No,Izberite Št
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Payroll Number,Številka plače
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Include UOM,Vključi 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,Vnosi v knjigo delnic in vpisi GL so ponovno objavljeni za izbrane potrdila o nakupu
apps/erpnext/erpnext/support/doctype/issue/issue.js,Resetting Service Level Agreement.,Ponastavitev sporazuma o ravni storitev.
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Update Print Format,Posodobi format tiskanja
DocType: Student,Siblings,Bratje in sestre
DocType: Purchase Invoice,Hold Invoice,Zadržite račun
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Invalid reference {1},Vrstica {0}: Neveljavna referenca {1}
,Profitability Analysis,Analiza donosnosti
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,New Account Name,Novo ime računa
DocType: Employee Benefit Claim,Expense Proof,Dokazilo o stroških
DocType: Restaurant Order Entry Item,Served,Služi
DocType: Loan,Member,Članica
DocType: Practitioner Service Unit Schedule,Practitioner Service Unit Schedule,Urnik storitvene enote zdravnika
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Wire Transfer,Bančno nakazilo
DocType: Quality Review Objective,Quality Review Objective,Cilj pregleda kakovosti
DocType: Bank Reconciliation Detail,Against Account,Proti računu
DocType: Projects Settings,Projects Settings,Nastavitve projektov
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html,Actual Qty {0} / Waiting Qty {1},Dejanska številka {0} / številka čakanja {1}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} cannot be a Group,{0} {1}: Račun {2} ne more biti skupina
DocType: Prescription Duration,Prescription Duration,Trajanje recepta
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Debit entry can not be linked with a {1},Vrstica {0}: debetnega vnosa ni mogoče povezati z {1}
DocType: Program,Intro Video,Uvodni video
DocType: Purchase Invoice,Is Paid,Je plačan
DocType: Account,Debit,Debit
,Item Balance (Simple),Stanje postavke (preprosto)
apps/erpnext/erpnext/utilities/activation.py,Purchase orders help you plan and follow up on your purchases,Naročilnice vam pomagajo pri načrtovanju in spremljanju nakupov
DocType: Project,Project Type,Vrsta projekta
DocType: Program Enrollment Tool Student,Student Batch Name,Ime študentskega paketa
,Qty to Receive,Količina za prejem
DocType: Agriculture Task,Previous Business Day,Prejšnji delovni dan
DocType: Travel Request Costing,Sponsored Amount,Sponzorirani znesek
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Please wait 3 days before resending the reminder.,Pred ponovnim pošiljanjem opomnika počakajte 3 dni.
DocType: Sales Invoice Item,Qty as per Stock UOM,Količina po skladišču UOM
DocType: Opening Invoice Creation Tool Item,Quantity,Količina
DocType: Delivery Stop,Estimated Arrival,Predvideni prihod
,Trial Balance for Party,Poskusna bilanca za stranko
DocType: Employee Separation,Employee Separation Template,Predloga za ločevanje zaposlenih
DocType: Quality Objective,Unit,Enota
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Maximum benefit amount of component {0} exceeds {1},Najvišji znesek komponente komponente {0} presega {1}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Venture Capital,Tveganega kapitala
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year End Date should be one year after Fiscal Year Start Date,Datum zaključka fiskalnega leta mora biti eno leto po začetnem fiskalnem letu
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Daily Reminders,Dnevni opomniki
DocType: Item,Default Sales Unit of Measure,Privzeta prodajna merska enota
apps/erpnext/erpnext/regional/report/gst_itemised_sales_register/gst_itemised_sales_register.js,Company GSTIN,Podjetje GSTIN
DocType: Asset Finance Book,Rate of Depreciation,Stopnja amortizacije
apps/erpnext/erpnext/regional/india/utils.py,Distance cannot be greater than 4000 kms,Razdalja ne sme biti večja od 4000 km
DocType: Support Search Source,Post Description Key,Ključ za opis po pošti
DocType: Loyalty Program Collection,Minimum Total Spent,Najmanjša skupna porabljena poraba
DocType: Supplier Scorecard Period,Period Score,Obdobje ocene
apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py,Can't create standard criteria. Please rename the criteria,"Standardnih meril ni mogoče ustvariti. Prosimo, preimenujte merila"
DocType: Travel Itinerary,Arrival Datetime,Prihod Datetime
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py,Student LMS Activity,Dejavnost LMS študentov
DocType: Stock Reconciliation Item,Quantity Difference,Količina Razlika
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Vrstica # {0}: Dodeljeni znesek ne sme biti višji od neporavnanega zneska.
DocType: Sales Invoice Timesheet,Timesheet Detail,Podrobnosti o časovnem listu
DocType: Employee Skill,Proficiency,Profesionalnost
DocType: SMS Log,Sent To,Poslano
DocType: Item,Hub Publishing Details,Podrobnosti objavljanja središča
apps/erpnext/erpnext/utilities/activation.py,"Student Batches help you track attendance, assessments and fees for students","Študentski paketi vam pomagajo spremljati prisotnost, ocene in honorarje za študente"
DocType: Employee Tax Exemption Declaration Category,Declared Amount,Deklarirani znesek
DocType: Selling Settings,Auto close Opportunity after 15 days,Samodejno zapiranje priložnosti po 15 dneh
DocType: Share Transfer,Issue,Težava
DocType: Volunteer,Availability Timeslot,Razpoložljivost Timeslot
DocType: Program,Program Abbreviation,Okrajšava programa
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Start Date,Datum začetka projekta
DocType: Purchase Invoice,Additional DIscount Amount,Dodatni znesek DIscount
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Element {0} ni na voljo v tabeli &quot;Dobavljeni surovine&quot; v naročilu za nakup {1}
DocType: BOM,Manage cost of operations,Upravljanje stroškov operacij
apps/erpnext/erpnext/accounts/doctype/account/account.py,You are not authorized to set Frozen value,Nimate dovoljenja za nastavitev vrednosti Frozen
DocType: Contract,Lapsed,Lapsed
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Investments,Naložbe
DocType: Inpatient Record,Date of Birth,Datum rojstva
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.,Za registracijo na Marketplace morate biti uporabnik s funkcijami Upravitelja sistema in Upravitelja izdelkov.
DocType: Item Attribute,Item Attribute Values,Vrednosti atributa postavke
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please save the patient first,Najprej shranite bolnika
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Half Day Date should be between From Date and To Date,Datum polovičnega dneva mora biti med datumom in datumom
DocType: Inpatient Record,Expected Discharge,Pričakovana razrešnica
DocType: Travel Request,Travel Type,Vrsta potovanja
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Customer is required,Stranka je potrebna
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Invalid quantity specified for item {0}. Quantity should be greater than 0.,"Neveljavna količina, določena za postavko {0}. Količina mora biti večja od 0."
apps/erpnext/erpnext/education/doctype/instructor/instructor.js,As Supervisor,Kot nadzornik
DocType: Payroll Entry,Employees,Zaposleni
DocType: Sales Order,Billing Status,Stanje obračunavanja
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Please select Category first,Najprej izberite kategorijo
apps/erpnext/erpnext/config/manufacturing.py,BOM Browser,Brskalnik BOM
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Create Student Groups,Ustvarite skupine študentov
DocType: Work Order Operation,In Minutes,V zapisnik
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Net Pay cannot be less than 0,Neto plačilo ne more biti manjše od 0
DocType: Maintenance Schedule,Schedules,Razporedi
DocType: Employee Training,Employee Training,Usposabljanje zaposlenih
DocType: Loan,Rate of Interest (%) / Year,Obrestna mera (%) / leto
DocType: Normal Test Items,Require Result Value,Zahtevajte vrednost rezultata
DocType: Loan,Loan Type,Vrsta posojila
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Item Code required at Row No {0},"Koda postavke, zahtevana v vrstici št. {0}"
DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikacija paketa za dostavo (za tisk)
DocType: Assessment Plan,Assessment Name,Ocenjevalno ime
DocType: Travel Itinerary,Departure Datetime,Odhod Datetime
DocType: Delivery Note Item,From Warehouse,Iz skladišča
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} against {2} {3},Znesek {0} {1} v primerjavi z {2} {3}
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variant,Ustvari različico
DocType: Contract Template,Fulfilment Terms and Conditions,Pogoji za izpolnitev
apps/erpnext/erpnext/setup/doctype/company/company.js,Date of Commencement should be greater than Date of Incorporation,Datum začetka bi moral biti večji od datuma ustanovitve
DocType: Pricing Rule,Price or Product Discount,Cena ali popust za izdelek
DocType: Quality Inspection Reading,Reading 1,Branje 1
DocType: Student Admission Program,Maximum Age,Najvišja starost
DocType: Payroll Period,Payroll Periods,Obdobja plač
apps/erpnext/erpnext/buying/report/subcontracted_raw_materials_to_be_transferred/subcontracted_raw_materials_to_be_transferred.py,Transferred Quantity,Prenesena količina
DocType: Marketplace Settings,Marketplace Settings,Nastavitve tržnice
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Naročila za nakup niso dovoljena za {0} zaradi stanja kazalnika rezultatov {1}.
apps/erpnext/erpnext/stock/get_item_details.py,Price List not selected,Cenik ni izbran
DocType: Exotel Settings,API Token,API Token
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,Workstation is closed on the following dates as per Holiday List: {0},Delovna postaja je zaprta na naslednje datume po seznamu praznikov: {0}
DocType: Customer,"Reselect, if the chosen address is edited after save","Ponovno izberite, če je izbrani naslov urejen po shranjevanju"
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.,"Privzeta merska enota za postavko {0} ni mogoče neposredno spremeniti, ker ste že opravili nekaj transakcij z drugo UOM. Za uporabo drugega privzetega UOM morate ustvariti nov element."
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dobavitelj&gt; Vrsta dobavitelja
apps/erpnext/erpnext/stock/doctype/item/item.js,Changing Customer Group for the selected Customer is not allowed.,Spreminjanje skupine strank za izbrano stranko ni dovoljeno.
DocType: Serial No,Creation Document Type,Vrsta dokumenta ustvarjanja
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Na voljo je količina paketa na skladišču
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Invoice Grand Total,Račun Grand Total
apps/erpnext/erpnext/setup/doctype/territory/territory.js,This is a root territory and cannot be edited.,To je korensko ozemlje in ga ni mogoče urejati.
DocType: Patient,Surgical History,Kirurška zgodovina
apps/erpnext/erpnext/config/quality_management.py,Tree of Quality Procedures.,Drevo postopkov kakovosti.
DocType: Bank Account,Contact HTML,Kontaktirajte HTML
,Employee Information,Informacije o zaposlenih
DocType: Assessment Plan,Examiner,Preizkuševalec
DocType: Employee Tax Exemption Proof Submission Detail,Actual Amount,Dejanski znesek
DocType: Contract,Fulfilled,Izpolnjeno
apps/erpnext/erpnext/controllers/buying_controller.py,Row {0}: Enter location for the asset item {1},Vrstica {0}: vnesite lokacijo za postavko sredstva {1}
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,The selected payment entry should be linked with a debtor bank transaction,Izbrana plačilna postavka mora biti povezana z bančno transakcijo dolžnika
DocType: Purchase Invoice,Taxes and Charges Calculation,Izračun davkov in dajatev
DocType: Setup Progress Action,Action Document,Akcijski dokument
DocType: Clinical Procedure,Procedure Prescription,Postopek na recept
DocType: Guardian,Guardian Name,Ime skrbnika
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Successfully Reconciled,Uspešno usklajeno
DocType: Accounting Period,Period Name,Ime obdobja
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,"Prosimo, potegnite predmete iz dobavnice"
DocType: Content Question,Content Question,Vprašanje o vsebini
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html,In Stock: ,Na zalogi:
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement tracking is not enabled.,Spremljanje sporazuma o ravni storitev ni omogočeno.
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Please save before assigning task.,Pred dodelitvijo naloge shranite.
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py,Company is manadatory for company account,Podjetje se uporablja za račun podjetja
DocType: Sales Order Item,Delivery Warehouse,Skladišče dostave
DocType: Shopify Settings,Enable Shopify,Omogoči Shopify
DocType: Patient,Additional information regarding the patient,Dodatne informacije o bolniku
DocType: Landed Cost Voucher,Purchase Receipts,Potrdilo o nakupu
apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js,New Employee,Novi zaposleni
DocType: Purchase Invoice,Update Auto Repeat Reference,Posodobi posodobitev samodejnega ponavljanja
DocType: Fees,Fees,Pristojbine
DocType: Student Group,Student Group Name,Ime skupine učencev
DocType: Supplier Scorecard Scoring Standing,Employee,Zaposleni
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available-for-use Date should be after purchase date,"Datum, ki je na voljo za uporabo, mora biti po datumu nakupa"
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Please define grade for Threshold 0%,Določite oceno za prag 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?","Aplikacije, ki uporabljajo trenutni ključ, ne bodo imele dostopa, ali ste prepričani?"
DocType: Quality Meeting,Minutes,Zapisnik
DocType: Quiz Result,Correct,Pravilno
DocType: Employee Tax Exemption Declaration,Total Declared Amount,Skupni prijavljeni znesek
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py,Material,Material
DocType: Appointment Type,Is Inpatient,Je bolnišnično
DocType: Leave Encashment,Encashment Amount,Zaračunavanje zneska
DocType: BOM,Conversion Rate,Stopnja konverzij
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,CEO,direktor
DocType: Bin,Reserved Qty for sub contract,Rezervirana količina za poddobavitev
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Create Payment Entry,Ustvari plačilni vnos
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js,Submit Proof,Predloži dokaz
DocType: Payment Term,Credit Months,Kreditni meseci
DocType: Bank Guarantee,Providing,Zagotavljanje
DocType: Sales Invoice,Total Billing Amount,Skupni znesek obračunavanja
DocType: Maintenance Visit,Maintenance Visit,Obiski za vzdrževanje
DocType: Item,Country of Origin,Država izvora
DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Merila za analizo kmetijstva
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Additional Salary Component Exists.,Obstaja dodatna komponenta plač.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Grocery,Živila
DocType: Restaurant Table,Minimum Seating,Najmanjše število sedežev
DocType: Vital Signs,Furry,Furry
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"Can not filter based on Account, if grouped by Account","Ni mogoče filtrirati na podlagi računa, če je združeno po računu"
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Bank Entries,Bančni vnosi
DocType: Soil Texture,Sandy Clay Loam,Sandy Clay Loam
DocType: Crop Cycle,LInked Analysis,LInked analiza
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Valid From Date must be lesser than Valid Upto Date.,Veljavni datum mora biti manjši od veljavnega datuma.
DocType: Additional Salary,Salary Component,Komponenta plač
DocType: Asset Maintenance Team,Maintenance Team Members,Člani vzdrževalnih ekip
DocType: Student Admission Program,Minimum Age,Minimalna starost
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Available Selling,Razpoložljiva prodaja
DocType: Purchase Invoice,Taxes and Charges Deducted,Odbitki davkov in dajatev
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Lab Test,Ustvarite laboratorijski test
DocType: Hotel Settings,Hotel Settings,Nastavitve hotela
DocType: Naming Series,Select Transaction,Izberite transakcijo
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Declare Lost,Izjavi Izgubljeno
DocType: Warranty Claim,If different than customer address,Če se razlikuje od naslova stranke
DocType: Chart of Accounts Importer,Chart Tree,Drevo grafikonov
DocType: Contract,Contract,Pogodba
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,Please select the Multiple Tier Program type for more than one collection rules.,Za vrsto pravil za zbiranje izberite vrsto programa za več stopenj.
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,{0} for {1},{0} za {1}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For Quantity (Manufactured Qty) is mandatory,Za količino (proizvedeno količino) je obvezno
apps/erpnext/erpnext/public/js/setup_wizard.js,"e.g. ""Primary School"" or ""University""",npr. &quot;osnovna šola&quot; ali &quot;univerza&quot;
DocType: Pricing Rule,Apply Multiple Pricing Rules,Uporabi več pravil za določanje cen
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py,Review Invitation Sent,Povabilo na pregled je poslano
DocType: Item,No of Months,Št. Mesecev
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Zahtevani serijski številki za serijsko postavko {0}
apps/erpnext/erpnext/config/manufacturing.py,Bill of Materials (BOM),Gradivo (BOM)
DocType: Accounts Settings,Allow Stale Exchange Rates,Dovoli stalni devizni tečaj
DocType: BOM,Website Description,Opis spletne strani
DocType: POS Closing Voucher,Expense Details,Podrobnosti o stroških
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,From Range has to be less than To Range,Iz razpona mora biti manjše od To Range
DocType: Homepage,Products to be shown on website homepage,"Izdelki, ki bodo prikazani na domači strani spletnega mesta"
DocType: Tally Migration,Is Master Data Processed,Je glavna podatkovna obdelava
DocType: Item Price,Quantity  that must be bought or sold per UOM,"Količina, ki jo je treba kupiti ali prodati na UOM"
DocType: Project,Total Sales Amount (via Sales Order),Skupni znesek prodaje (prek prodajnega naloga)
apps/erpnext/erpnext/utilities/user_progress.py,Box,Škatla
DocType: QuickBooks Migrator,Default Cost Center,Privzeto stroškovno mesto
DocType: Purchase Order Item,Billed Amt,Obračunano podjetje Amt
apps/erpnext/erpnext/accounts/utils.py,Please set default {0} in Company {1},V podjetju {1} nastavite privzeto {0}
DocType: Cheque Print Template,Distance from left edge,Razdalja od levega roba
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Točka 4
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}",Predplačilo za {0} {1} ne sme biti večje od skupne vsote {2}
DocType: Account,Income Account,Račun dohodka
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py,All Warehouses,Vsa skladišča
DocType: Contract,Signee Details,Podrobnosti o znaku
DocType: Shift Type,Allow check-out after shift end time (in minutes),Dovoli odjavo po končnem času izmene (v minutah)
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py,Procurement,Javna naročila
DocType: Item Group,Check this if you want to show in website,"Označite to možnost, če želite prikazati na spletnem mestu"
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Fiscal Year {0} not found,Fiskalno leto {0} ni bilo mogoče najti
DocType: Bank Statement Settings,Bank Statement Settings,Nastavitve bančnega izpiska
DocType: Quality Procedure Process,Link existing Quality Procedure.,Povezava obstoječega postopka kakovosti.
apps/erpnext/erpnext/config/getting_started.py,Import Chart Of Accounts from CSV / Excel files,Uvozi graf iz računa CSV / Excel
DocType: Appraisal Goal,Score (0-5),Ocena (0–5)
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute {0} selected multiple times in Attributes Table,Atribut {0} je bil izbran večkrat v tabeli atributov
DocType: Purchase Invoice,Debit Note Issued,Izdano bančno sporočilo
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","Prosimo, izberite element, kjer je &quot;Je postavka&quot; &quot;Ne&quot; in &quot;Je prodajna postavka&quot; je &quot;Da&quot; in ni drugega paketa izdelkov"
apps/erpnext/erpnext/hr/utils.py,Employee {0} of grade {1} have no default leave policy,Zaposleni {0} razreda {1} nima pravilnika o privzetem dopustu
DocType: Leave Policy Detail,Leave Policy Detail,Pustite podrobnosti o pravilniku
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Warehouse not found in the system,Skladišče ni bilo v sistemu
DocType: Healthcare Practitioner,OP Consulting Charge,OP Consulting Charge
DocType: Bank Statement Transaction Payment Item,Invoices,Računi
DocType: Currency Exchange,Currency Exchange,Menjalnica
DocType: Payroll Entry,Fortnightly,Štirinajst dni
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} not in stock,Serijska št. {0} ni na zalogi
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Material Request not created, as quantity for Raw Materials already available.","Zahteva za material ni ustvarjena, saj je količina za surovine že na voljo."
DocType: Woocommerce Settings,Creation User,Uporabnik ustvarjanja
apps/erpnext/erpnext/config/crm.py,"Record of all communications of type email, phone, chat, visit, etc.","Zapis vseh komunikacij vrste e-pošte, telefona, klepeta, obiska itd."
DocType: Asset Settings,Asset Settings,Nastavitve sredstva
DocType: Compensatory Leave Request,Worked On Holiday,Delal na počitnicah
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Either location or employee must be required,Potrebna sta lokacija ali zaposleni
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is cancelled,Element {0} je preklican
DocType: Course Scheduling Tool,Course End Date,Datum zaključka tečaja
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Warning: Leave application contains following block dates,Opozorilo: aplikacija Zapusti vsebuje naslednje datume blokov
DocType: Asset Maintenance Task,Preventive Maintenance,Preventivno vzdrževanje
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Abbreviation,Kratica inštituta
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","Račun razlike mora biti račun vrste sredstva / obveznosti, ker je ta uskladitev delnic začetni vnos"
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Contract End Date must be greater than Date of Joining,Datum konca pogodbe mora biti večji od datuma pridružitve
DocType: Employee Grade,Default Leave Policy,Privzeta politika dopusta
DocType: Daily Work Summary Group,Select Users,Izberite Uporabniki
DocType: Workstation,Net Hour Rate,Neto urna postavka
DocType: Clinical Procedure,Age,Starost
DocType: Travel Request,Event Details,Podrobnosti o dogodku
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Accumulated Monthly,Zbrano mesečno
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Update Cost,Strošek posodobitve
DocType: Sales Order,Fully Delivered,Popolnoma dostavljen
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter company first,Najprej vnesite podjetje
apps/erpnext/erpnext/config/selling.py,Confirmed orders from Customers.,Potrjena naročila strank.
DocType: Dosage Strength,Dosage Strength,Dozirna moč
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Fill the form and save it,Izpolnite obrazec in ga shranite
DocType: Program Enrollment Tool,Enrollment Details,Podrobnosti o vpisu
DocType: Subscription Invoice,Subscription Invoice,Račun naročnine
DocType: Leave Allocation,Total Leaves Encashed,Skupaj oluščenih listov
DocType: Quality Inspection,Verified By,Preveril
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invoices,Pridobite račune
DocType: Bank Transaction,Settled,Rešeno
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Re-open,Ponovno odprite
DocType: Period Closing Voucher,Closing Fiscal Year,Zaključno proračunsko leto
DocType: Purchase Invoice,Release Date,Datum izdaje
DocType: Purchase Invoice,Advances,Predujmi
DocType: Shipping Rule,Specify conditions to calculate shipping amount,Navedite pogoje za izračun zneska dostave
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Technology,Tehnologija
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',"Lahko se sklicuje na vrstico samo, če je vrsta bremenitve »Na prejšnji vrstici« ali »Predhodna vrstica«"
DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Če je izbrano, Št. Delovni dnevi bodo vključevali počitnice, kar bo zmanjšalo vrednost plače na dan"
DocType: Location,Location Name,Ime mesta
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: račun {2} ne pripada podjetju {3}
DocType: Employee Benefit Application,Remaining Benefits (Yearly),Preostale koristi (letno)
DocType: Asset Finance Book,Depreciation Start Date,Začetni datum amortizacije
DocType: Activity Cost,Billing Rate,Stopnja zaračunavanja
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Warning: Another {0} # {1} exists against stock entry {2},Opozorilo: še en {0} # {1} obstaja proti vnosu v zalogi {2}
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Please enable Google Maps Settings to estimate and optimize routes,"Omogočite nastavitve Google Zemljevidov, da ocenite in optimizirate poti"
DocType: Purchase Invoice Item,Page Break,Prelom strani
DocType: Supplier Scorecard Criteria,Max Score,Najvišji rezultat
DocType: Support Search Source,Support Search Source,Podpora viru iskanja
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Financial Services,Finančne storitve
DocType: Volunteer,Availability,Razpoložljivost
apps/erpnext/erpnext/config/quality_management.py,Tree of Procedures,Drevo postopkov
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,"Dovoli, da se element doda večkrat v transakciji"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} ni poslan
DocType: Work Order,Backflush raw materials from work-in-progress warehouse,Surovine za povratno splakovanje iz skladišča v teku
apps/erpnext/erpnext/stock/doctype/item/item.py,You have to enable auto re-order in Stock Settings to maintain re-order levels.,"Omogočiti morate samodejno preurejanje v nastavitvah zalog, da ohranite ravni ponovnega urejanja."
DocType: Maintenance Team Member,Maintenance Team Member,Član vzdrževalne ekipe
DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,Najmanjša razdalja med vrstami rastlin za optimalno rast
DocType: Employee Health Insurance,Health Insurance Name,Ime zdravstvenega zavarovanja
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Assets,Zaloge sredstev
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,"Nadaljnja stroškovna mesta se lahko izvedejo v skupinah, vendar se lahko vnosi izvedejo proti ne-skupinam"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Upper Income,Zgornji dohodek
DocType: Company,Discount Allowed Account,Račun z dovoljenjem za popust
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Restart Subscription,Znova zaženite naročnino
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,You can not change rate if BOM mentioned agianst any item,"Ne morete spremeniti stopnjo, če BOM omenjeno agianst koli predmet"
apps/erpnext/erpnext/hub_node/api.py,Please login as another user to register on Marketplace,"Prosimo, prijavite se kot drug uporabnik, da se registrirate na Marketplace"
DocType: Asset,Insurance Details,Podrobnosti zavarovanja
DocType: Subscription,Past Due Date,Datum zapadlosti
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,"You can only plan for upto {0} vacancies and budget {1} \
				for {2} as per staffing plan {3} for parent company {4}.",Za načrt moških {3} za matično podjetje {4} lahko načrtujete samo {0} prostih delovnih mest in proračuna {1} za {2}.
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,No GST No. found for the Company.,Za podjetje ni našel nobenega GST št.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Pin Code,Iz kode PIN
DocType: Contract,Signed On,Podpisan
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}: Računovodski vnos za {2} je lahko samo v valuti: {3}
DocType: Assessment Criteria,Assessment Criteria,Merila za ocenjevanje. \ T
DocType: Lab Test Template,Is Billable,Je zaračunljiv
DocType: Naming Series,User must always select,Uporabnik mora vedno izbrati
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Compensatory leave request days not in valid holidays,Zahteva za odškodninski dopust ni v veljavnih praznikih
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py,Sum of points for all goals should be 100. It is {0},Vsota točk za vse cilje mora biti 100. To je {0}
DocType: BOM,Scrap Items,Predmeti odpadkov
DocType: Special Test Template,Result Component,Komponenta rezultata
apps/erpnext/erpnext/regional/india/utils.py,Please mention Basic and HRA component in Company,Navedite osnovno in HRA komponento v podjetju
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,{0} does not belong to Company {1},{0} ne pripada podjetju {1}
DocType: Attendance Request,Half Day Date,Datum pol dneva
DocType: Delivery Note,Billing Address Name,Ime računa za obračun
,GST Itemised Purchase Register,GST Register po nabavni vrednosti
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Alternate Item,Nadomestni element
DocType: Certification Application,Name of Applicant,Ime prosilca
DocType: Leave Type,Earned Leave,Zaslužen dopust
DocType: GSTR 3B Report,June,Junij
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Row {0}: Cost center is required for an item {1},Vrstica {0}: Stroškovno mesto je potrebno za element {1}
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Can be approved by {0},Lahko ga odobri {0}
apps/erpnext/erpnext/stock/doctype/item/item.py,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Merska enota {0} je bila vnesena več kot enkrat v tabeli faktorja pretvorbe
DocType: Purchase Invoice Item,Net Rate (Company Currency),Neto stopnja (valuta podjetja)
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,All BOMs,Vse BOM
DocType: Department,Days for which Holidays are blocked for this department.,"Dnevi, za katere so prazniki blokirani za ta oddelek."
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,"Cannot Submit, Employees left to mark attendance","Ne morem poslati, Zaposleni morajo zapustiti obiskovalce"
DocType: BOM,Quality Inspection Template,Predloga za kontrolo kakovosti
DocType: Plant Analysis,Result Datetime,Rezultat Datetime
DocType: Purchase Taxes and Charges,Valuation,Vrednotenje
,Student Monthly Attendance Sheet,Študentski mesečni pregled
DocType: Academic Term,Term End Date,Datum konca obdobja
DocType: Pricing Rule Detail,Child Docname,Ime otroka
apps/erpnext/erpnext/public/js/setup_wizard.js,Services,Storitve
apps/erpnext/erpnext/controllers/accounts_controller.py,Cannot set quantity less than received quantity,"Ne morem določiti količine, manjše od prejete količine"
DocType: Purchase Order Item,Supplier Part Number,Številka dela dobavitelja
DocType: Lab Test Template,Standard Selling Rate,Standardna stopnja prodaje
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please set an active menu for Restaurant {0},Nastavite aktivni meni za restavracijo {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.,"Če želite dodati uporabnike v Marketplace, morate biti uporabniki z vlogami Upravitelja sistema in Upravitelja izdelkov."
DocType: Asset Finance Book,Asset Finance Book,Knjiga finančnih sredstev
DocType: Quality Goal Objective,Quality Goal Objective,Cilj cilja kakovosti
DocType: Employee Transfer,Employee Transfer,Prenos zaposlenih
,Sales Funnel,Potek prodaje
DocType: Agriculture Analysis Criteria,Water Analysis,Analiza vode
DocType: Shift Type,Begin check-in before shift start time (in minutes),Začnite prijavo pred začetkom časa premika (v minutah)
DocType: Accounts Settings,Accounts Frozen Upto,Računi zamrznjeni
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js,There is nothing to edit.,Ničesar ni za urejanje.
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","Delovanje {0}, ki je daljše od razpoložljivih delovnih ur v delovni postaji {1}, operacijo razčlenite na več operacij"
DocType: Item Variant Settings,Do not update variants on save,Ne posodabljajte variant pri shranjevanju
DocType: Grading Scale Interval,Threshold,Prag
DocType: Timesheet,% Amount Billed,% Znesek je zaračunan
DocType: Warranty Claim,Resolved By,Rešeno By
apps/erpnext/erpnext/utilities/user_progress.py,"Add users to your organization, other than yourself.","Dodajte uporabnike v svojo organizacijo, razen sebe."
DocType: Global Defaults,Default Company,Privzeto podjetje
DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Denarni račun se bo uporabljal za ustvarjanje računa
apps/erpnext/erpnext/controllers/selling_controller.py,Sales Order {0} is {1},Prodajno naročilo {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),Zamuda pri plačilu (dnevi)
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Enter depreciation details,Vnesite podrobnosti amortizacije
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Customer PO,Stranka naročnika
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Expected Delivery Date should be after Sales Order Date,Pričakovani datum dobave mora biti po datumu prodajnega naloga
apps/erpnext/erpnext/controllers/accounts_controller.py,Item quantity can not be zero,Količina elementa ne more biti nič
apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Neveljaven atribut
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},Izberite BOM pred postavko {0}
DocType: Bank Statement Transaction Invoice Item,Invoice Type,Vrsta računa
DocType: Price List,Price List Master,Cenik Master
,Lost Opportunity,Izgubljena priložnost
DocType: Maintenance Visit,Maintenance Date,Datum vzdrževanja
DocType: Volunteer,Afternoon,Popoldne
DocType: Vital Signs,Nutrition Values,Vrednosti hranilne vrednosti
DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Prisotnost zvišane telesne temperature (temp&gt; 38,5 ° C / 101,3 ° F ali stalna temperatura&gt; 38 ° C / 100,4 ° F)"
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Reversed,ITC obrnjen
DocType: Project,Collect Progress,Zberite napredek
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Energy,Energija
,Items To Be Requested,"Elementi, ki bodo zahtevani"
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,Delovni nalog je že ustvarjen za vse elemente s kosovnico
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Billed Amount,Obračunani znesek
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Vneseni trenutni odometer mora biti večji od začetnega števca kilometrov {0}
DocType: Employee Transfer Property,Employee Transfer Property,Premestitev zaposlenih
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Pending Activities,Dejavnosti v teku
apps/erpnext/erpnext/utilities/user_progress.py,List a few of your customers. They could be organizations or individuals.,Navedite nekaj svojih strank. Lahko so organizacije ali posamezniki.
DocType: Bank Guarantee,Bank Account Info,Podatki o bančnem računu
DocType: Quality Goal,Weekday,Dan v tednu
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Name,Ime skrbnika1
DocType: Salary Component,Variable Based On Taxable Salary,"Spremenljivka, ki temelji na obdavčljivi plači"
DocType: Accounting Period,Accounting Period,Računovodsko obdobje
DocType: Company,Standard Working Hours,Standardne delovne ure
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,In Stock,Na zalogi
DocType: Amazon MWS Settings,Market Place Account Group,Skupina računov za trg
DocType: Stock Reconciliation Item,Before reconciliation,Pred spravo
DocType: Fee Component,Fees Category,Kategorija pristojbin
DocType: Sales Order,%  Delivered,% Dostavljeno
DocType: Sales Invoice,Redemption Cost Center,Stroškovni center za unovčenje
DocType: Vital Signs,Respiratory rate,Stopnja dihanja
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Get Students From,Obvezno polje - Pridobi študente
DocType: Item Group,Item Classification,Razvrstitev postavke
DocType: Asset,Is Existing Asset,Je obstoječe sredstvo
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,Cancel Material Visits {0} before cancelling this Maintenance Visit,"Prekliči obisk materiala {0}, preden prekličete ta obisk za vzdrževanje"
DocType: Workstation,Workstation Name,Ime delovne postaje
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Vrstica # {0}: Stanje mora biti {1} za popust za račun {2}
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Material Transfer,Prenos materiala
DocType: Delivery Note,% Installed,% Nameščeno
DocType: Agriculture Task,Agriculture Task,Kmetijska naloga
DocType: Dosage Form,Dosage Form,Oblika odmerka
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Select the program first,Najprej izberite program
DocType: Project,Expected Start Date,Pričakovani začetni datum
DocType: Share Transfer,Share Transfer,Prenos v skupni rabi
apps/erpnext/erpnext/config/help.py,Leave Management,Zapusti upravljanje
DocType: Loan Application,Total Payable Interest,Skupna plačljiva obresti
DocType: Employee,Current Address,Trenutni naslov
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Cannot {0} {1} {2} without any negative outstanding invoice,Ni mogoče {0} {1} {2} brez negativnih neporavnanih računov
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Transaction not allowed against stopped Work Order {0},Transakcija ni dovoljena proti ustavljenemu delovnemu nalogu {0}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to ledger.,Skladišča z obstoječo transakcijo ni mogoče pretvoriti v knjigo.
DocType: Payroll Entry,Deduct Tax For Unsubmitted Tax Exemption Proof,Odbitni davek za neizkazano oprostitev davka
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date updated,Datum potrditve se posodobi
DocType: Delivery Trip,Delivery Stops,Ustavi dostave
DocType: Setup Progress,Setup Progress,Napredek namestitve
,Ordered Items To Be Billed,Naročene postavke za zaračunavanje
DocType: Taxable Salary Slab,To Amount,Na znesek
DocType: Purchase Invoice,Is Return (Debit Note),Je vrnitev (bremenitveno obvestilo)
apps/erpnext/erpnext/config/desktop.py,Getting Started,Kako začeti
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge,Spoji
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.,"Ni mogoče spremeniti začetnega datuma fiskalnega leta in končnega davčnega leta, potem ko je fiskalno leto shranjeno."
DocType: Production Plan,Get Material Request,Pridobite zahtevo za material
DocType: C-Form Invoice Detail,Invoice No,Račun št
DocType: Pricing Rule,Max Qty,Največja količina
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},Vrstica {0}: dodeljena vrednost {1} mora biti manjša ali enaka znesku vnosa plačilnega računa {2}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Delo
DocType: Sales Invoice Item,Drop Ship,Spusti ladjo
DocType: Hub User,Hub User,Uporabnik Hub
DocType: Lab Test Template,No Result,Ni rezultatov
DocType: Bank Statement Transaction Entry,Match Transaction to Invoices,Ujemanje transakcij z računi
DocType: Sales Invoice,Commission,provizija
DocType: Sales Invoice Item,Sales Order Item,Postavka prodajnega naloga
DocType: Maintenance Schedule Detail,Actual Date,Dejanski datum
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance start date can not be before delivery date for Serial No {0},Datum začetka vzdrževanja ne sme biti pred datumom dobave za serijsko številko {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Exchange Rate is mandatory,Vrstica {0}: menjalni tečaj je obvezen
DocType: Purchase Invoice,Select Supplier Address,Izberite naslov dobavitelja
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Available quantity is {0}, you need {1}","Razpoložljiva količina je {0}, potrebujete {1}"
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Secret,Vnesite Secret of Consumer API
DocType: Program Enrollment Fee,Program Enrollment Fee,Pristojbina za vpis programa
DocType: Employee Checkin,Shift Actual End,Shift Actual End
DocType: Serial No,Warranty Expiry Date,Datum veljavnosti garancije
DocType: Hotel Room Pricing,Hotel Room Pricing,Cene hotelskih sob
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Outward taxable supplies(other than zero rated, nil rated and exempted","Zunanje obdavčljive dobave (razen ničelnih, ničelnih in oproščenih)"
DocType: Issue,Resolution By,Resolucija Do
DocType: Loyalty Program,Customer Territory,Teritorij stranke
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication,Zadnje sporočilo
DocType: Timesheet,Total Billed Hours,Skupaj obračunane ure
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Current invoice {0} is missing,Trenutni račun {0} manjka
DocType: Healthcare Settings,Patient Registration,Registracija bolnika
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice No exists in Purchase Invoice {0},V računu za nakup {0} obstaja račun dobavitelja št.
DocType: Service Day,Workday,Delovni dan
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,No Items added to cart,V košarico ni dodanih elementov
DocType: Target Detail,Target Qty,Ciljna količina
apps/erpnext/erpnext/stock/doctype/item/item.py,"To merge, following properties must be same for both items",Za združitev morajo biti naslednje lastnosti enake za obe postavki
DocType: Drug Prescription,Drug Prescription,Zdravilo na recept
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Buildings,Zgradbe
DocType: Student Applicant,Application Date,Datum uporabe
DocType: Assessment Result,Result,Rezultat
DocType: Leave Block List,Leave Block List Allowed,Zapusti blokiran seznam
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Rate cannot be greater than the rate used in {1} {2},"Vrstica # {0}: Stopnja ne more biti višja od stopnje, uporabljene v {1} {2}"
DocType: Purchase Order Item,Blanket Order,Redna naročila
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance for employee {0} is already marked,Prisotnost zaposlenega {0} je že označena
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py,Assessment Result record {0} already exists.,Zapis rezultatov {0} že obstaja.
DocType: Purchase Invoice,Rounding Adjustment,Prilagoditev zaokroževanja
DocType: Quality Review Table,Quality Review Table,Tabela za pregled kakovosti
DocType: Member,Membership Expiry Date,Datum poteka članstva
DocType: Asset Finance Book,Expected Value After Useful Life,Pričakovana vrednost po uporabnem življenju
DocType: GSTR 3B Report,November,November
DocType: Loan Application,Rate of Interest,Obrestna mera
DocType: Bank Statement Transaction Payment Item,Bank Statement Transaction Payment Item,Postavka plačilnega prometa v bančnem izidu
DocType: Restaurant Reservation,Waitlisted,Na čakanju
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,You need to enable Shopping Cart,Omogočiti morate nakupovalno košarico
DocType: HR Settings,Leave Status Notification Template,Zapusti predlogo obvestila o stanju
DocType: Salary Slip,Leave Without Pay,Pustite brez plačila
DocType: Clinical Procedure Item,Actual Qty (at source/target),Dejanska količina (pri viru / cilju)
DocType: Purchase Invoice,Tax ID,Davčna številka
apps/erpnext/erpnext/templates/pages/cart.html,See past orders,Oglejte si pretekla naročila
DocType: Stock Reconciliation Item,Current Qty,Trenutna količina
apps/erpnext/erpnext/buying/utils.py,UOM Conversion factor is required in row {0},Konverzijski faktor UOM je potreben v vrstici {0}
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges","Podrobnosti o davčni tabeli, pridobljeni iz glavnega elementa kot niz in shranjene v tem polju. Uporablja se za davke in pristojbine"
DocType: Appraisal Goal,Key Responsibility Area,Področje ključne odgovornosti
DocType: Purchase Receipt Item,Sample Quantity,Vzorčna količina
DocType: Journal Entry Account,Expense Claim,Zahtevek za stroške
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date and Closing Date should be within same Fiscal Year,Datum začetka in datum zaključka morata biti v istem poslovnem letu
DocType: Soil Texture,Silt Composition (%),Siltova sestava (%)
DocType: Tax Withholding Rate,Tax Withholding Rate,Stopnja davčnega odtegljaja
DocType: Restaurant,Default Tax Template,Privzeta predloga za davek
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Transfer Asset,Prenos sredstev
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,Najprej prekličite račun za nakup {0}
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Complete Job,Popolno delo
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Select Possible Supplier,Izberite Možen dobavitelj
DocType: POS Profile,Customer Groups,Skupine strank
DocType: Hub Tracked Item,Hub Category,Kategorija vozlišča
apps/erpnext/erpnext/utilities/activation.py,"Quotations are proposals, bids you have sent to your customers","Ponudbe so predlogi, ki ste jih poslali svojim strankam"
DocType: Quality Inspection Reading,Reading 5,Branje 5
DocType: Shopping Cart Settings,Display Settings,Nastavitve zaslona
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please set Number of Depreciations Booked,Nastavite število knjiženih amortizacij
DocType: Shift Type,Consequence after,Posledica za
apps/erpnext/erpnext/templates/pages/help.html,What do you need help with?,Za kaj potrebujete pomoč?
DocType: Journal Entry,Printing Settings,Nastavitve tiskanja
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Banking,Bančništvo
DocType: Purchase Invoice Advance,Purchase Invoice Advance,Predračun za nakup računa
DocType: Student Applicant,EDU-APP-.YYYY.-,EDU-APP-.YYYY.-
DocType: Purchase Invoice Item,PR Detail,PR Podrobnosti
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Billing Address is same as Shipping Address,Naslov za obračun je enak naslovu za dostavo
DocType: Account,Cash,Gotovina
DocType: Employee,Leave Policy,Zapusti politiko
DocType: Shift Type,Consequence,Posledica
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Address,Naslov učenca
DocType: GST Account,CESS Account,Račun 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}: Stroškovno mesto je potrebno za račun »Dobiček in izguba« {2}. Za podjetje nastavite privzeto središče stroškov.
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 ustvarjanju računa za otroško podjetje {0} starševskega računa {1} ni mogoče najti. Ustvarite nadrejeni račun v ustreznem potrdilu o pristnosti
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js,General Ledger,Glavna knjiga
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Reminder to update GSTIN Sent,Opomnik za posodobitev poslane GSTIN
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Select Days,Izberite Dneve
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Next Contact By cannot be same as the Lead Email Address,Naslednji stik ne more biti enak glavnemu e-naslovu
DocType: Packing Slip,To Package No.,V številko paketa
DocType: Course,Course Name,Ime tečaja
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Serial no is required for the asset {0},Serijska številka je obvezna za sredstvo {0}
DocType: Asset,Maintenance,Vzdrževanje
DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Potrdite prodajno ceno za postavko v primerjavi s stopnjo nakupa ali stopnjo vrednotenja
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,The following Work Orders were created:,Naslednja delovna naročila so bila ustvarjena:
DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.LLLL.-
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,IFSC Code,Koda IFSC
DocType: Bank Statement Transaction Payment Item,Mode of Payment,Način plačila
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Znesek davka po znesku popusta
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Get Suppliers By,Pridobite dobavitelje
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}","Vrstica {0}: Če želite nastaviti {1} periodičnost, mora biti razlika med datumom in datumom večja ali enaka {2}"
DocType: Purchase Invoice Item,Valuation Rate,Stopnja vrednotenja
DocType: Shopping Cart Settings,Default settings for Shopping Cart,Privzete nastavitve za nakupovalno košarico
DocType: Quiz,Score out of 100,Ocena od 100
DocType: Manufacturing Settings,Capacity Planning,Načrtovanje zmogljivosti
apps/erpnext/erpnext/utilities/user_progress.py,Go to Instructors,Pojdi na inštruktorje
DocType: Activity Cost,Projects,Projekti
DocType: Item Barcode,Barcode Type,Vrsta črtne kode
DocType: Employee Incentive,Incentive Amount,Znesek spodbud
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js,"To set this Fiscal Year as Default, click on 'Set as Default'","Če želite to fiskalno leto nastaviti kot privzeto, kliknite »Nastavi kot privzeto«"
DocType: C-Form,II,II
DocType: Cashier Closing,From Time,Od časa
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant Details Report,Poročilo o podrobnostih različice
,BOM Explorer,BOM Explorer
DocType: Currency Exchange,For Buying,Za nakup
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Slots for {0} are not added to the schedule,Sloti za {0} niso dodani v urnik
DocType: Target Detail,Target Distribution,Ciljna distribucija
DocType: Staffing Plan,Staffing Plan Details,Podrobnosti o kadrovskem načrtu
apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Račun {0} ni veljaven. Valuta računa mora biti {1}
DocType: Pricing Rule,Rule Description,Opis pravila
DocType: Delivery Trip,Total Estimated Distance,Skupna ocenjena razdalja
DocType: Opportunity,Lost Reason,Izgubljeni razlog
DocType: Depreciation Schedule,Make Depreciation Entry,Vnesite amortizacijo
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Serial nos {0} does not belongs to the location {1},Serijski nos {0} ne pripada lokaciji {1}
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Vloga je dovoljena za nastavitev zamrznjenih računov in urejanje zamrznjenih vnosov
DocType: Employee,Health Concerns,Zdravstvene skrbi
DocType: Company,Company Info,Podatki o podjetju
DocType: Activity Cost,Activity Cost,Stroški dejavnosti
DocType: Journal Entry,Payment Order,Plačilni nalog
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Pricing,Cenitev
,Item Delivery Date,Datum dobave artikla
DocType: Quality Goal,January-April-July-October,Januar-april-julij-oktober
DocType: Purchase Order Item,Warehouse and Reference,Skladišče in referenca
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with child nodes cannot be converted to ledger,Račun z otrokovimi vozlišči ni mogoče pretvoriti v knjigo
DocType: Soil Texture,Clay Composition (%),Sestava gline (%)
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM št. Za končno dobro postavko
DocType: Journal Entry,User Remark,Opomba uporabnika
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Your order is out for delivery!,Vaše naročilo je izročeno!
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,"Payment Type must be one of Receive, Pay and Internal Transfer","Vrsta plačila mora biti ena od načinov prejemanja, plačila in notranjega prenosa"
DocType: HR Settings,Payroll Settings,Nastavitve plačne liste
DocType: GST HSN Code,GST HSN Code,Kodeks GST HSN
DocType: Period Closing Voucher,Period Closing Voucher,Dokončni bon
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Name,Ime skrbnika2
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please enter Expense Account,Vnesite Stroškovni račun
DocType: Issue,Resolution By Variance,Ločljivost po varianci
DocType: Employee,Resignation Letter Date,Datum odstopnega pisma
DocType: Soil Texture,Sandy Clay,Sandy Clay
DocType: Upload Attendance,Attendance To Date,Prisotnost na dan
DocType: Invoice Discounting,Loan Start Date,Datum začetka posojila
DocType: Workstation,Consumable Cost,Potrošni stroški
DocType: Leave Type,Encashment,Naklada
DocType: Employee Tax Exemption Declaration,Income From Other Sources,Prihodki od drugih virov
DocType: Crop,Produced Items,Proizvedeni izdelki
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Approval Status must be 'Approved' or 'Rejected',Stanje odobritve mora biti &quot;odobreno&quot; ali &quot;zavrnjeno&quot;
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,View Now,Prikaži zdaj
DocType: Item Price,Valid Upto,Velja do konca
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Reference Doctype must be one of {0},Referenčni dokument mora biti eden od {0}
DocType: Employee Checkin,Skip Auto Attendance,Preskoči avto
DocType: Payment Request,Transaction Currency,Valuta transakcije
DocType: Loan,Repayment Schedule,Urnik odplačevanja
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Create Sample Retention Stock Entry,Ustvarite vnos v zalogo vzorca
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Open,Nastavite kot Odpri
DocType: Job Card,Requested Qty,Zahtevana količina
DocType: POS Profile,Apply Discount On,Uporabi popust na
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sub contracting,Rezervirano za podizvajalce
apps/erpnext/erpnext/stock/doctype/item/item.py,Item variant {0} exists with same attributes,Varianta elementa {0} obstaja z enakimi atributi
DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Če ni dodeljenega časovnega niza, bo komunikacija obravnavala ta skupina"
DocType: Member,Membership Type,Vrsta članstva
DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Študentu bo pokazal prisotnost v mesečnem poročilu o študentih
apps/erpnext/erpnext/accounts/page/bank_reconciliation/linked_payment_header.html,Payment Name,Ime plačila
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Minimum Lead Age (Days),Minimalna starost za vodenje (dnevi)
DocType: Shopify Settings,Delivery Note Series,Serija dobavnih opomb
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Academic Year,Obvezno polje - akademsko leto
DocType: Vehicle Log,Fuel Price,Cena goriva
DocType: Travel Itinerary,Mode of Travel,Način potovanja
DocType: Special Test Items,Special Test Items,Posebne preskusne postavke
DocType: Purchase Invoice,Edit Posting Date and Time,Uredi datum in čas knjiženja
DocType: Sales Order,Not Billed,Ni zaračunano
DocType: Employee Transfer,Employee Transfer Detail,Podrobnosti prenosa zaposlenih
DocType: Project,Task Completion,Dokončanje naloge
DocType: Shopify Webhook Detail,Webhook ID,Webhook ID
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Travel Expenses,Potni stroški
apps/erpnext/erpnext/hr/utils.py,Future dates not allowed,Prihodnji datumi niso dovoljeni
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,Vrstica {0}: nastavite način plačila na urniku plačil
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Academic Term: ,Akademski izraz:
DocType: Quality Feedback Parameter,Quality Feedback Parameter,Parameter kakovosti povratnih informacij
apps/erpnext/erpnext/accounts/page/pos/pos.js,Please select Apply Discount On,Izberite Uporabi popust na vklop
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Row # {0}: ,Vrstica # {0}:
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Skupna plačila
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please enter Account for Change Amount,Vnesite račun za znesek spremembe
DocType: Tax Withholding Account,Tax Withholding Account,Račun za odtegljaje davkov
DocType: Account,Stock Received But Not Billed,"Stalež prejet, vendar ni zaračunan"
apps/erpnext/erpnext/accounts/doctype/account/account.py,Please add the account to root level Company - %s,Dodajte račun v korensko raven Podjetje -% s
DocType: Sample Collection,Collected By,Zbrani
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Obvesti po e-pošti o ustvarjanju samodejne zahteve za material
DocType: Asset Repair,Downtime,Čas nedelovanja
DocType: Cost Center,Cost Center Number,Številka mesta stroškov
DocType: Driver,Applicable for external driver,Velja za zunanjega voznika
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Start on,Začnite
DocType: Sales Invoice,Payment Due Date,Rok plačila
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Če ima ta postavka različice, je ni mogoče izbrati v prodajnih naročilih itd."
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Following course schedules were created,Izdelani so bili naslednji urniki
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Timesheet created:,Časovni razpored je ustvarjen:
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Odpri BOM {0}
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Transfered,Preneseno
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Payable account,Kredit za račun mora biti plačljiv račun
DocType: Item,Item Attribute,Atribut postavke
apps/erpnext/erpnext/config/quality_management.py,Goal and Procedure,Cilj in postopek
DocType: Asset,Frequency of Depreciation (Months),Pogostost amortizacije (meseci)
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Real Estate,Nepremičnina
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Parents Teacher Meeting Attendance,Udeležba na srečanju učiteljev staršev
DocType: Employee Grade,Employee Grade,Stopnja zaposlenih
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'","Skupno {0} za vse elemente je nič, morda bi morali spremeniti »Porazdelitev stroškov na podlagi«"
DocType: Sales Invoice Timesheet,Time Sheet,Časovni list
DocType: Hotel Room Reservation,Late Checkin,Pozna prijava
DocType: Company,Default Selling Terms,Privzeti pogoji prodaje
DocType: Project,Costing and Billing,Stroški in zaračunavanje
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Total Outgoing,Skupaj odhodni
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Privzeta pogodba o ravni storitev že obstaja.
DocType: Packing Slip,If more than one package of the same type (for print),Če je več paketov iste vrste (za tiskanje)
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Please select Company and Posting Date to getting entries,Za pridobitev vnosov izberite Podjetje in Datum knjiženja
DocType: Healthcare Practitioner,Default Currency,Privzeta valuta
DocType: Sales Invoice,Packing List,Seznam pakiranja
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Secretary,Sekretar
DocType: Travel Itinerary,Gluten Free,Brez glutena
DocType: Hub Tracked Item,Hub Node,Vozlišče vozlišča
apps/erpnext/erpnext/projects/report/billing_summary.py,Employee ID,ID zaposlenega
DocType: Salary Structure Assignment,Salary Structure Assignment,Dodelitev strukture plač
DocType: POS Closing Voucher Taxes,POS Closing Voucher Taxes,Davki za zaključevanje bonov POS
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,Action Initialised,Ukrep je začet
DocType: POS Profile,Applicable for Users,Uporabno za uporabnike
,Delayed Order Report,Poročilo o zakasnjenem naročilu
DocType: Training Event,Exam,Izpit
apps/erpnext/erpnext/accounts/general_ledger.py,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Nepravilno število najdenih vnosov glavne knjige. Morda ste v transakciji izbrali napačen račun.
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Sales Pipeline,Prodajni cevovod
,Leaderboard,Leaderboard
DocType: Account,Inter Company Account,Medpodjetniški račun
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Closed order cannot be cancelled. Unclose to cancel.,"Zaprtega naročila ni mogoče preklicati. Razveljavite, da prekličete."
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} does not exist,{0} {1} ne obstaja
DocType: Job Opening,Planned number of Positions,Načrtovano število položajev
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Maintenance Status has to be Cancelled or Completed to Submit,Stanje vzdrževanja mora biti preklicano ali končano za pošiljanje
apps/erpnext/erpnext/accounts/page/pos/pos.js,Please select customer,Izberite stranko
DocType: Account,Round Off,Zaokrožite
DocType: Pricing Rule,Conditions will be applied on all the selected items combined. ,Pogoji bodo uporabljeni za vse izbrane elemente skupaj.
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure,Konfiguriraj
DocType: Hotel Room,Capacity,Zmogljivost
DocType: Employee Checkin,Shift End,Shift End
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Greater Than Amount,Več kot znesek
DocType: Installation Note Item,Installed Qty,Nameščena količina
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Batch {0} of Item {1} is disabled.,Paket {0} elementa {1} je onemogočen.
DocType: Hotel Room Reservation,Hotel Reservation User,Uporabnik rezervacije hotelov
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Sporazum o ravni storitev z vrsto entitete {0} in entiteto {1} že obstaja.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Item Group not mentioned in item master for item {0},"Skupina postavke, ki ni navedena v glavnem elementu za element {0}"
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Name error: {0},Napaka imena: {0}
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Territory is Required in POS Profile,Teritorij je potreben v profilu POS
DocType: Purchase Invoice Item,Service End Date,Datum konca storitve
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Quotation,Ponudba
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Exchange Rate must be same as {0} {1} ({2}),Menjalni tečaj mora biti enak kot {0} {1} ({2})
DocType: Service Level,Holiday List (ignored during SLA calculation),Seznam praznikov (ignoriran med izračunom SLA)
DocType: Student Admission Program,Student Admission Program,Študentski sprejemni program
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} can not be a ledger,Račun {0}: nadrejeni račun {1} ne more biti knjiga
DocType: Sales Order,% of materials billed against this Sales Order,"% materialov, zaračunanih za ta prodajni nalog"
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,Račun plačilnega prehoda v načrtu {0} se razlikuje od računa plačilnega prehoda v tej zahtevi za plačilo
DocType: Stock Entry Detail,Subcontracted Item,Postavka podizvajalca
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.py,Loan Start Date and Loan Period are mandatory to save the Invoice Discounting,Začetni datum posojila in rok posojila sta obvezna za shranjevanje popusta na račun
DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Appointment charges.,"Privzeti računi terjatev, ki jih je mogoče uporabiti, če niso nastavljeni v polju Patient to book (Strošek za bolnika)."
DocType: Student Attendance Tool,Students HTML,Študentski HTML
DocType: Student Guardian,Student Guardian,Študentski skrbnik
DocType: GoCardless Settings,GoCardless Settings,Nastavitve GoCardless
DocType: Delivery Note,Transport Receipt Date,Datum prejema prometa
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js,Show Opening Entries,Pokaži začetne vnose
DocType: Vital Signs,Heart Rate / Pulse,Srčni utrip / utrip
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Assessment Groups,Vse ocenjevalne skupine
DocType: Asset,Asset Name,Ime sredstva
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""",Za &quot;To Value&quot; je lahko samo en pogoj Pravila pošiljanja z vrednostjo 0 ali prazno vrednost
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Optimizing routes.,Optimizacija poti.
DocType: Shopify Tax Account,Shopify Tax/Shipping Title,Shopify Naslov davka / dostave
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,To date can not be equal or less than from date,Do danes ne more biti enaka ali manjša od datuma
apps/erpnext/erpnext/utilities/user_progress.py,You added ,Dodali ste
DocType: Assessment Result,Total Score,Skupni rezultat
DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Če ste ustvarili standardno predlogo v predlogu za prometne dajatve in stroške, izberite eno in kliknite spodnji gumb."
DocType: Budget,Cost Center,Mesto stroškov
apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Skupni dodeljeni odstotek za prodajno ekipo mora biti 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}","Serijske številke {0} elementa {1} ni mogoče dostaviti, ker je rezervirano za popolno prodajno naročilo {2}"
apps/erpnext/erpnext/accounts/utils.py,Payment Entry has been modified after you pulled it. Please pull it again.,"Vnos plačila je bil spremenjen, ko ste ga povlekli. Prosim, ponovno ga povlecite."
DocType: Employee,Bio / Cover Letter,Bio / spremno pismo
DocType: Stock Ledger Entry,Stock Value Difference,Razlika vrednosti zalog
DocType: Academic Year,Academic Year Name,Ime akademskega leta
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Bank Accounts,Bančni računi
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,The Payment Term at row {0} is possibly a duplicate.,Termin plačila v vrstici {0} je morda podvojen.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Unblock Invoice,Odblokiraj račun
DocType: Pricing Rule,Percentage,Odstotek
DocType: Sensitivity Test Items,Sensitivity Test Items,Preskusne postavke občutljivosti
apps/erpnext/erpnext/config/retail.py,To make Customer based incentive schemes.,Izdelati spodbujevalne sheme na podlagi strank.
,Purchase Register,Register nabave
DocType: Depreciation Schedule,Schedule Date,Datum razporeda
DocType: Packing Slip,Package Weight Details,Podrobnosti teže paketa
DocType: Job Applicant,Job Opening,Odpiranje dela
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.,"Zadnja znana uspešna sinhronizacija zaposlenega Checkin. To ponastavite samo, če ste prepričani, da so vsi dnevniki sinhronizirani z vseh lokacij. Prosim, ne spreminjajte tega, če niste prepričani."
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Dejanska cena
apps/erpnext/erpnext/controllers/accounts_controller.py,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Skupni predujem ({0}) proti naročilu {1} ne more biti večji od skupnega zneska ({2})
apps/erpnext/erpnext/stock/doctype/item/item.py,Item Variants updated,Različice artiklov so posodobljene
DocType: Item,Batch Number Series,Serijska številka serije
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Projects,Odpri projekte
DocType: Shopify Settings,Import Delivery Notes from Shopify on Shipment,Uvozi dobavnice iz Shopify o pošiljki
DocType: QuickBooks Migrator,Token Endpoint,Končna točka žetonov
apps/erpnext/erpnext/utilities/user_progress.py,List a few of your suppliers. They could be organizations or individuals.,Navedite nekaj vaših dobaviteljev. Lahko so organizacije ali posamezniki.
DocType: Amazon MWS Settings,MWS Credentials,Pooblastila MWS
DocType: Shopping Cart Settings,Shopping Cart Settings,Nastavitve nakupovalne košarice
DocType: Sales Invoice Item,Enable Deferred Revenue,Omogoči odloženi prihodek
apps/erpnext/erpnext/config/help.py,Managing Projects,Upravljanje projektov
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Message Sent,Sporočilo poslano
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Same item has been entered multiple times. {0},Isti element je bil vnesen večkrat. {0}
DocType: Pricing Rule,Margin,Margina
apps/erpnext/erpnext/accounts/utils.py,{0} '{1}' not in Fiscal Year {2},{0} &#39;{1}&#39; ni v proračunskem letu {2}
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,This bank account is already synchronized,Ta bančni račun je že sinhroniziran
DocType: Fee Schedule,Fee Structure,Struktura pristojbin
apps/erpnext/erpnext/public/js/templates/item_quick_entry.html,Variant Attributes,Atributi variant
DocType: Employee,Confirmation Date,Datum potrditve
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please set a default Holiday List for Employee {0} or Company {1},Nastavite privzeti seznam praznikov za zaposlenega {0} ali podjetje {1}
DocType: Job Applicant Source,Job Applicant Source,Vir kandidata za delo
DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Odpiranje orodja za ustvarjanje računa
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0} does not exist,Račun {0} ne obstaja
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Ignore Existing Ordered Qty,Prezri obstoječo naročeno količino
DocType: Material Request Item,Lead Time Date,Datum vodilnega časa
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Accounts Receivable Summary,Povzetek terjatev
DocType: Asset,Available-for-use Date,"Datum, ki je na voljo za uporabo"
DocType: HR Settings,Employee record is created using selected field. ,Zapis zaposlenih se ustvari z izbranim poljem.
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","Vrstica # {0}: Vrsta referenčnega dokumenta mora biti ena od naročilnice, fakture nabave ali vnosa v dnevnik"
DocType: Payment Entry,Type of Payment,Vrsta plačila
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Leave the field empty to make purchase orders for all suppliers,"Pustite polje prazno, da lahko naročite naročila za vse dobavitelje"
apps/erpnext/erpnext/stock/utils.py,Item {0} ignored since it is not a stock item,"Element {0} se ne upošteva, ker ni postavka staleža"
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot have Valuation Rate","&quot;Postavka, ki jo je podal uporabnik&quot; ne more imeti stopnje vrednotenja"
DocType: Soil Texture,Clay,Glina
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} ima trenutno {1} Stanje kazalnika dobavitelja, naročila za nakup tega dobavitelja pa morajo biti izdana previdno."
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","Če je postavka različica drugega elementa, bodo opis, slika, cene, davki itd. Nastavljeni iz predloge, razen če je to izrecno določeno"
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Total Target,Skupni cilj
DocType: Location,Longitude,Zemljepisna dolžina
DocType: Accounts Settings,Determine Address Tax Category From,Določite kategorijo davka naslova od
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,"Upload a bank statement, link or reconcile a bank account","Naložite bančni izpisek, povežite ali uskladite bančni račun"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Identifying Decision Makers,Prepoznavanje odločevalcev
DocType: Stock Entry Detail,Reference Purchase Receipt,Referenčni potrdilo o nakupu
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invocies,Pridobite račune
DocType: Tally Migration,Is Day Book Data Imported,Je dan podatkov o knjigi uvožen
,Sales Partners Commission,Komisija za prodajne partnerje
DocType: Shift Type,Enable Different Consequence for Early Exit,Omogoči drugačno posledico za zgodnji izhod
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Legal,Pravno
DocType: Loan Application,Required by Date,Zahteva po datumu
DocType: Quiz Result,Quiz Result,Rezultat kviza
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Close Loan,Zapri posojilo
DocType: Lead,From Customer,Od stranke
DocType: Payment Reconciliation,Minimum Invoice Amount,Najmanjši znesek računa
apps/erpnext/erpnext/stock/doctype/material_request/material_request_dashboard.py,Related,Povezano
DocType: Drug Prescription,Description/Strength,Opis / moč
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work Order cannot be raised against a Item Template,Delovnega naloga ni mogoče uveljaviti za predlogo postavke
DocType: Employee External Work History,Salary,Plača
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Nastavi stanje
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward supplies from ISD,Notranja dobava iz ISD
,Vehicle Expenses,Stroški vozil
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set 'Apply Additional Discount On',Nastavite »Uporabi dodaten popust na«
DocType: Closed Document,Closed Document,Zaprti dokument
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py,Please select weekly off day,Izberite tedenski dan
DocType: Leave Type,Applicable After (Working Days),Velja po (delovnih dneh)
DocType: Timesheet Detail,Hrs,Hrs
DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Merila za oceno dobavitelja
DocType: Amazon MWS Settings,FR,FR
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Error: {0} is mandatory field,Napaka: {0} je obvezno polje
DocType: Quality Feedback Template Parameter,Quality Feedback Template Parameter,Parameter predloge predlog kakovosti povratnih informacij
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date of Joining must be greater than Date of Birth,Datum pridružitve mora biti večji od datuma rojstva
DocType: Bank Statement Transaction Invoice Item,Invoice Date,Datum računa
DocType: Healthcare Settings,Create Lab Test(s) on Sales Invoice Submit,Ustvarite laboratorijske teste na dostavnem računu za prodajo
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"No active BOM found for item {0}. Delivery by \
						Serial No cannot be ensured",Za element {0} ni na voljo nobena aktivna specifikacija. Dostava po serijski številki ni zagotovljena
DocType: Employee Education,Post Graduate,Podiplomski
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Račun {0} je bil vnesen večkrat
DocType: Employee Benefit Application Detail,Pay Against Benefit Claim,Plačajte zahtevek za nadomestilo
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Principal Amount,Glavni znesek
apps/erpnext/erpnext/setup/doctype/company/company.py,Main,Main
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,Serial No {0} does not exist,Serijska številka {0} ne obstaja
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Program,Izberite Program
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Discharge,Urnik izpraznitve
apps/erpnext/erpnext/stock/doctype/batch/batch.py,"Set items shelf life in days, to set expiry based on manufacturing_date plus self life","Nastavite rok uporabnosti izdelkov v dnevih, da nastavite rok veljavnosti na podlagi datuma izdelave in lastnega življenja"
DocType: Bank Reconciliation,Get Payment Entries,Pridobite plačilne vnose
DocType: Amazon MWS Settings,Max Retry Limit,Največja omejitev ponavljanja
DocType: Woocommerce Settings,Endpoint,Končna točka
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Cost Center is required in row {0} in Taxes table for type {1},Mesto stroškov je v vrstici {0} v tabeli Davki za vrsto {1}.
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,Currency Exchange must be applicable for Buying or for Selling.,Menjalnica mora veljati za nakup ali prodajo.
DocType: Cheque Print Template,Cheque Width,Preverite širino
DocType: Woocommerce Settings,Secret,Skrivnost
DocType: Restaurant Order Entry,Current Order,Trenutni nalog
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Item must be added using 'Get Items from Purchase Receipts' button,Element je treba dodati z gumbom »Pridobivanje elementov iz potrdil o nakupu«
,Delay Days,Delay Days
DocType: Company,Default Income Account,Privzeti račun dohodka
DocType: Patient Appointment,Get prescribed procedures,Pridobite predpisane postopke
DocType: Lead,Market Segment,Tržni segment
apps/erpnext/erpnext/projects/doctype/task/task_list.js,Set as Completed,Nastavite kot končano
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Completed Qty can not be greater than 'Qty to Manufacture',Dokončana količina ne more biti večja od &#39;Količina za izdelavo&#39;
apps/erpnext/erpnext/config/support.py,Service Level.,Raven storitve.
DocType: Stock Entry,MAT-STE-.YYYY.-,MAT-STE-.YYYY.-
DocType: Fiscal Year,Year Start Date,Datum začetka leta
DocType: Work Order Operation,(Hour Rate / 60) * Actual Operation Time,(Urni čas / 60) * dejanski čas delovanja
DocType: C-Form,Received Date,Datum prejema
apps/erpnext/erpnext/config/accounting.py,Financial / accounting year.,Finančno / obračunsko leto. \ T
DocType: Pricing Rule,Pricing Rule,Pravilo o določanju cen
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Optional Holiday List not set for leave period {0},Neobvezni seznam praznikov ni nastavljen za obdobje dopusta {0}
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please set User ID field in an Employee record to set Employee Role,"Vnesite polje ID uporabnika v zapisu zaposlenega, da nastavite vlogo uslužbenca"
apps/erpnext/erpnext/support/doctype/issue/issue.py,Allow Resetting Service Level Agreement from Support Settings.,Omogočite ponastavitev pogodbe o ravni storitev iz nastavitev podpore.
DocType: Training Event,Training Event,Usposabljanje
DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Normalni krvni tlak v mirovanju pri odraslem je približno 120 mmHg sistolični in 80 mmHg diastolični, skrajšano &quot;120/80 mmHg&quot;."
DocType: Payment Reconciliation,System will fetch all the entries if limit value is zero.,"Če bo mejna vrednost nič, bo sistem vnesel vse vnose."
DocType: Item,Copy From Item Group,Kopiraj iz skupine elementov
,Bank Remittance,Bančno nakazilo
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","Stopnja vrednotenja ni bila najdena za element {0}, ki je obvezen opraviti računovodske vnose za {1} {2}. Če se postavka obravnava kot postavka ničelne stopnje vrednotenja v {1}, to navedite v tabeli {1} postavk. V nasprotnem primeru ustvarite dohodne transakcije delnic za postavko ali navedite stopnjo vrednotenja v zapisu postavke in poskusite predložiti / preklicati ta vnos"
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Half day date should be in between from date and to date,Datum poldneva mora biti med datumom in datumom
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Accrual Journal Entry for salaries from {0} to {1},Vnos dnevnika časovnega razmejevanja za plače od {0} do {1}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Material Receipt,Prejem materiala
DocType: Employee Transfer,Re-allocate Leaves,Prerazporedite liste
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,To Date should be within the Fiscal Year. Assuming To Date = {0},Do datuma naj bi bilo v proračunskem letu. Ob predpostavki datuma = {0}
DocType: Employee Promotion,Employee Promotion Details,Podrobnosti o promociji zaposlenih
DocType: Project User,Project Status,Stanje projekta
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction can not be deleted,Računa z obstoječo transakcijo ni mogoče izbrisati
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js,This is a root supplier group and cannot be edited.,To je korenska skupina dobaviteljev in je ni mogoče urejati.
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py,Could not find path for ,Ne morem najti poti za
DocType: Item Customer Detail,Item Customer Detail,Podrobnosti kupca izdelka
DocType: Grant Application,Assessment  Mark (Out of 10),Ocenjevalni znak (od 10)
DocType: Shareholder,ACC-SH-.YYYY.-,ACC-SH-.YYYY.-
DocType: Lab Test,LabTest Approver,LabTest Approver
DocType: Task,Is Milestone,Je mejnik
DocType: Program Enrollment Tool,Get Students,Pridobite študente
DocType: Program Enrollment,Self-Driving Vehicle,Vozilo za samodejno vožnjo
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} must be a Fixed Asset Item,Postavka {0} mora biti fiksna postavka sredstva
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Rent,Pisarniški najem
DocType: Asset,In Maintenance,V vzdrževanju
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.,Lastnosti različice ni mogoče spremeniti po transakciji s stanjem. Za to boste morali narediti nov element.
DocType: Purchase Invoice,Unpaid,Neplačani
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Name / Number,Posodobi ime / številko računa
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Intern,Pripravnik
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show only POS,Prikaži samo POS
DocType: Cashier Closing,Custody,Skrbništvo
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,From Date cannot be greater than To Date,Od datuma ne more biti večje od datuma
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,As per your assigned Salary Structure you cannot apply for benefits,Glede na dodeljeno strukturo plač ne morete zaprositi za ugodnosti
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup defaults,Nastavitev privzetih nastavitev ni uspela
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account Number {0} already used in account {1},Številka računa {0} je že uporabljena v računu {1}
DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,"Sporočilo o plačilu e-poštnega sporočila zaposlenemu na podlagi želenega e-poštnega sporočila, izbranega v Zaposleni"
DocType: Company,Asset Depreciation Cost Center,Središče stroškov amortizacije sredstva
DocType: Lead,Address Desc,Naslov Desc
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Exception occurred while reconciling {0},Med usklajevanjem {0} je prišlo do izjeme
DocType: Woocommerce Settings,Enable Sync,Omogoči sinhronizacijo
DocType: Student Applicant,Approved,Odobreno
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,From Date should be within the Fiscal Year. Assuming From Date = {0},Od datuma mora biti v proračunskem letu. Ob predpostavki od datuma = {0}
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please Set Supplier Group in Buying Settings.,Nastavite skupino dobaviteljev v nastavitvah nakupa.
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,{} is an invalid Attendance Status.,{} je neveljaven status obiska.
DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Začasni račun za začetek
DocType: Purchase Invoice,Cash/Bank Account,Denarni / bančni račun
DocType: Quality Meeting Table,Quality Meeting Table,Tabela kakovosti sestanka
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.,"Datum začetka izvajanja ne sme biti prej kot datum začetka leta akademskega leta, na katerega je izraz povezan (akademsko leto {}). Popravite datume in poskusite znova."
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 1,Območje staranja 1
DocType: Employee Tax Exemption Proof Submission,Tax Exemption Proofs,Dokazila o oprostitvi davkov
DocType: Purchase Invoice,Price List Currency,Valuta za cenik
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Batch: ,Serija:
DocType: Purchase Invoice,Total Advance,Skupni predujem
DocType: Employee,Emergency Phone,Telefon v sili
DocType: Inpatient Occupancy,Check Out,Preveri
DocType: Loyalty Program,Conversion Factor,Konverzijski faktor
DocType: BOM Operation,Operating Cost(Company Currency),Obratovalni stroški (valuta podjetja)
apps/erpnext/erpnext/config/website.py,"Settings for online shopping cart such as shipping rules, price list etc.","Nastavitve za spletni nakupovalni voziček, kot so pravila za pošiljanje, cenik itd."
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Edit Publishing Details,Uredi podrobnosti objave
DocType: Soil Texture,Soil Texture Criteria,Merila teksture tal
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Compare List function takes on list arguments,Funkcija Primerjaj seznam prevzame argumente seznama
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Department...,Izberite oddelek ...
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Currency should be same as Price List Currency: {0},Valuta mora biti enaka kot cenik: {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row #{0}: Please specify Serial No for Item {1},Vrstica # {0}: navedite zaporedno številko elementa {1}
DocType: Plant Analysis Criteria,Minimum Permissible Value,Najmanjša dovoljena vrednost
DocType: Stock Entry,Source Warehouse Address,Naslov skladišča vira
DocType: Compensatory Leave Request,Compensatory Leave Request,Zahteva za nadomestni dopust
DocType: Lead,Mobile No.,Številka za mobilne naprave
DocType: GSTR 3B Report,July,Julij
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Eligible ITC,Upravičeni ITC
DocType: Fertilizer,Density (if liquid),Gostota (če je tekočina)
DocType: Employee,External Work History,Zunanja delovna zgodovina
DocType: Quality Inspection,Outgoing,Odhodni
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill JSON cannot be generated for Sales Return as of now,E-Way Bill JSON za zdaj ni mogoče ustvariti za vrnitev prodaje
DocType: Email Digest,Add Quote,Dodaj ponudbo
DocType: Inpatient Record,Discharge,praznjenje
DocType: Amazon MWS Settings,MWS Auth Token,Oznaka MWS Auth
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,"Food, Beverage & Tobacco","Hrana, pijača in tobak"
apps/erpnext/erpnext/education/doctype/course/course.js,Course Schedule,Razpored tečajev
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Postavka Wise Davčna Podrobnosti
DocType: Shift Type,Attendance will be marked automatically only after this date.,Prisotnost bo samodejno označena šele po tem datumu.
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to UIN holders,Dobave za imetnike UIN
apps/erpnext/erpnext/hooks.py,Request for Quotations,Zahtevek za ponudbo
apps/erpnext/erpnext/accounts/doctype/account/account.py,Currency can not be changed after making entries using some other currency,Valute ni mogoče spremeniti po vnosu z drugo valuto
apps/erpnext/erpnext/controllers/accounts_controller.py,Cannot set quantity less than delivered quantity,"Ni mogoče določiti količine, manjše od dobavljene količine"
apps/erpnext/erpnext/config/accounting.py,Bank/Cash transactions against party or for internal transfer,Bančne / gotovinske transakcije proti stranki ali za notranji prenos
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py,Disabled template must not be default template,Onemogočena predloga ne sme biti privzeta predloga
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Absent,Mark Absent
DocType: Salary Component,Statistical Component,Statistična komponenta
DocType: Bin,Reserved Quantity,Rezervirana količina
DocType: Vehicle,Insurance Company,Zavarovalnica
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Note: Item {0} entered multiple times,Opomba: Postavka {0} je vnesena večkrat
DocType: Plant Analysis,Collection Datetime,Zbirka Datetime
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Total Achieved,Doseženo skupaj
DocType: Course Topic,Topic,Tema
DocType: Employee Promotion,Promotion Date,Datum promocije
DocType: Bank Account,Account Details,podrobnosti računa
DocType: POS Profile,Allow user to edit Rate,Dovoli uporabniku urejanje stopnje
DocType: Healthcare Settings,Result Emailed,Rezultat je bil poslan po e-pošti
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js,View Leads,Ogled vodnikov
DocType: Fee Validity,Visited yet,Obiskali še
DocType: Purchase Invoice,Terms,Pogoji
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Disbursed Amount cannot be greater than Loan Amount {0},Izplačana vrednost ne sme biti večja od zneska posojila {0}
DocType: Share Balance,Issued,Izdala
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Admission,Urnik za sprejem
apps/erpnext/erpnext/public/js/templates/contact_list.html,No contacts added yet.,Stiki še niso dodani.
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Create Print Format,Ustvari format tiskanja
DocType: Asset,Policy number,Številka politike
DocType: GL Entry,Against Voucher,Proti bonu
DocType: Bank Statement Transaction Payment Item,Payment Reference,Referenca plačila
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Student Mobile No.,Študentska mobilna številka št.
DocType: Cheque Print Template,Cheque Print Template,Preverite predlogo za tiskanje
DocType: Loyalty Program Collection,For how much spent = 1 Loyalty Point,Za koliko porabljenega = 1 Točka zvestobe
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,Email Digest: ,E-poštni povzetek:
DocType: Accounts Settings,Show Inclusive Tax In Print,Prikaži vključujoč davek v tiskani obliki
DocType: Student Report Generation Tool,Include All Assessment Group,Vključi vse ocenjevalne skupine
DocType: Employee Benefit Application,Employee Benefits,Zaslužki zaposlencev
DocType: Leave Type,Is Optional Leave,Je neobvezen dopust
DocType: Cash Flow Mapping,Is Finance Cost,Je strošek financiranja
DocType: Vehicle,Doors,Vrata
DocType: Shopify Settings,Customer Settings,Nastavitve stranke
DocType: Purchase Invoice Item,Include Exploded Items,Vključi eksplodirane elemente
DocType: Assessment Plan,Evaluate,Ocenite
DocType: Purchase Invoice Item,Is Free Item,Je brezplačna postavka
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Present,Celotna prisotnost
DocType: Call Log,Recording URL,URL snemanja
DocType: Item,Is Item from Hub,Je element iz vozlišča
apps/erpnext/erpnext/config/quality_management.py,Quality Procedure.,Postopek kakovosti.
DocType: Share Balance,No of Shares,Št. Delnic
DocType: Quality Action,Preventive,Preventivno
DocType: Support Settings,Forum URL,URL foruma
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Vital Signs,Življenjski znaki
DocType: Academic Term,Academics User,Uporabnik akademikov
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Get Items from BOM,Prenesite predmete iz BOM-a
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Serial No is mandatory for Item {0},Serijska številka je obvezna za element {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Get Items from Prescriptions,Pridobite elemente iz 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},"Ne morem preklicati {0} {1}, ker zaporedna številka {2} ne pripada skladišču {3}"
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,View Orders,Ogled naročil
DocType: Staffing Plan Detail,Number Of Positions,Število položajev
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Walk In,Vstopiti
DocType: Shopify Settings,Import Sales Invoice from Shopify if Payment is marked,"Uvozi račun za prodajo iz storitve Shopify, če je plačilo označeno"
DocType: Certification Application,Certification Status,Status certifikacije
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Source Location is required for the asset {0},Lokacija sredstva je potrebna za sredstvo {0}
DocType: Employee,Encashment Date,Datum vložitve
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Please select Completion Date for Completed Asset Maintenance Log,"Prosimo, izberite Datum dokončanja za dokončani dnevnik vzdrževanja premoženja"
DocType: Quiz,Latest Attempt,Najnovejši poskus
DocType: Leave Block List,Allow Users,Dovoli uporabnikom
apps/erpnext/erpnext/accounts/doctype/account/account.js,Chart Of Accounts,Kontni načrt
DocType: Customer,Primary Address,Primarni naslov
DocType: Room,Room Name,Ime sobe
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,No outstanding invoices found for the {0} <b>{1}</b>.,Za {0} <b>{1} ni</b> bilo ugotovljenih neplačanih računov.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Tax Id: ,Davčna številka:
DocType: Serial No,Creation Document No,Št
apps/erpnext/erpnext/stock/doctype/item/item.js,Projected,Predvideno
DocType: Purchase Invoice Item,Rejected Qty,Zavrnjena količina
DocType: Pricing Rule,Free Item,Brezplačna postavka
DocType: Salary Component,Is Payable,Je plačljivo
DocType: Clinical Procedure Template,Allow Stock Consumption,Dovoli porabo zalog
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.,Akademski izraz s tem &quot;akademskim letom&quot; {0} in &quot;Ime izraza&quot; {1} že obstaja. Spremenite te vnose in poskusite znova.
DocType: Payment Entry,Initiated,Začeto
apps/erpnext/erpnext/config/selling.py,Blanket Orders from Costumers.,Blazinice iz kupcev.
DocType: Sales Order Item,Used for Production Plan,Uporablja se za proizvodni načrt
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 2,Območje staranja 2
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Time logs are required for job card {0},Dnevniki časa so potrebni za kartico z opravilom {0}
DocType: Expense Claim,Vehicle Log,Dnevnik vozil
DocType: Grading Scale,Grading Scale Intervals,Intervali merilne lestvice
DocType: Accounts Settings,Report Settings,Nastavitve poročila
apps/erpnext/erpnext/config/retail.py,Point-of-Sale Profile,Profil prodajnega mesta
DocType: Lab Test Groups,Lab Test Groups,Skupine laboratorijskih testov
DocType: Stock Settings,Default Valuation Method,Privzeta metoda vrednotenja
DocType: Item,Safety Stock,Varnostna zaloga
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Print settings updated in respective print format,Nastavitve tiskanja posodobljene v ustreznem formatu tiskanja
DocType: Support Settings,Issues,Vprašanja
apps/erpnext/erpnext/utilities/user_progress.py,Student Application,Prijava za študente
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Extra Large,Extra Large
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.js,Please add valid Plaid api keys in site_config.json first,"Prosimo, najprej dodajte veljavne Plaid api ključe v site_config.json"
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Remaining Balance,Ostati v ravnotežju
DocType: Lead,Industry,Industrija
DocType: Payment Entry,Cheque/Reference Date,Datum preverjanja / sklicevanja
DocType: Asset Movement,Stock Manager,Stock Manager
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,No items to be received are overdue,"Nobena postavka, ki jo je treba prejeti, ni zapadla"
apps/erpnext/erpnext/config/non_profit.py,Grant information.,Podeli informacije.
apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',"Če je skupina »Podjetje«, nastavite filter podjetja prazen."
DocType: Stock Settings,Action if Quality inspection is not submitted,"Ukrep, če nadzor kakovosti ni predložen"
apps/erpnext/erpnext/erpnext_integrations/doctype/amazon_mws_settings/amazon_methods.py,Sync has been temporarily disabled because maximum retries have been exceeded,"Sinhronizacija je bila začasno onemogočena, ker je bilo preseženih največje število poskusov"
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled or stopped,{0} {1} je preklican ali ustavljen
DocType: Asset Maintenance Log,Has Certificate,Ima potrdilo
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,"Search by item code, serial number, batch no or barcode","Iskanje po kodi izdelka, serijski številki, serijskem številu ali črtni kodi"
DocType: Item Price,Multiple Item prices.,Več cenovnih postavk.
DocType: Request for Quotation,Request for Quotation,Zahteva za ponudbo
DocType: Stock Reconciliation Item,Current Valuation Rate,Trenutna stopnja vrednotenja
DocType: Tax Rule,Shipping County,Shipping County
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Perception Analysis,Analiza zaznavanja
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item {0} is not active or end of life has been reached,Element {0} ni aktiven ali je bil dosežen konec življenja
apps/erpnext/erpnext/stock/doctype/item/item.js,Single Variant,Posamezna 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,Vrstica # {0}: Vrsta referenčnega dokumenta mora biti ena od zahtevkov za povračilo stroškov ali vnosa dnevnika
DocType: Purchase Invoice,Print Language,Jezik tiskanja
DocType: Pricing Rule,Pricing Rule Help,Pomoč za pravila za določanje cen
DocType: Shareholder,Contact List,Seznam kontaktov
DocType: Employee,Better Prospects,Boljše možnosti
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Urnik vzdrževanja ni ustvarjen za vse postavke. Prosimo, kliknite &#39;Ustvari razpored&#39;"
DocType: Authorization Rule,Itemwise Discount,Popust po pogodbi
DocType: Inpatient Record,Patient Encounter,Srečanje s pacientom
apps/erpnext/erpnext/config/non_profit.py,Define various loan types,Določite različne vrste posojil
DocType: Supplier,Supplier Type,Vrsta dobavitelja
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Collected: {0},Skupaj zbranih: {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Credit Card,Kreditna kartica
DocType: Warranty Claim,SER-WRN-.YYYY.-,SER-WRN-.YYYY.-
DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Nastavitev kazalnika dobaviteljev
DocType: Amazon MWS Settings,Amazon MWS Settings,Nastavitve za Amazon MWS
DocType: Program Enrollment,Walking,Hoditi
DocType: SMS Log,Requested Numbers,Zahtevane številke
DocType: Woocommerce Settings,Freight and Forwarding Account,Račun za tovorni in špediterski račun
apps/erpnext/erpnext/accounts/party.py,Please select a Company,Izberite podjetje
apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py,Row {0}: {1} must be greater than 0,Vrstica {0}: {1} mora biti večja od 0
apps/erpnext/erpnext/public/js/setup_wizard.js,Upload your letter head and logo. (you can edit them later).,Prenesite glavo in logotip pisma. (pozneje jih lahko urejate).
DocType: Salary Component,Create Separate Payment Entry Against Benefit Claim,Ustvarite ločen vnos plačil proti zahtevku za ugodnost
apps/erpnext/erpnext/utilities/bot.py,Did not find any item called {0},"Ni mogoče najti nobene postavke, imenovane {0}"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Koda izdelka&gt; Skupina izdelkov&gt; Blagovna znamka
DocType: Student,Nationality,Državljanstvo
DocType: BOM Item,Scrap %,Zapis%
DocType: Item,Inspection Criteria,Merila za inšpekcijske preglede
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup company,Nastavitev podjetja ni uspela
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To account must be a Balance Sheet account,Bremenitev Račun mora biti račun stanja
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Number of Order,Številka naročila
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} je povezano z {2}, vendar je račun stranke {3}"
DocType: Purchase Invoice,Items,Postavke
DocType: C-Form,I,jaz
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Work-in-Progress Warehouse is required before Submit,Pred pošiljanjem je potrebno skladišče za delo v teku
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","Prodajno naročilo {0} ima rezervacijo za element {1}, lahko dostavi le rezervirano {1} za {0}. Serijske številke {2} ni mogoče dostaviti"
DocType: Quality Goal,Monitoring Frequency,Frekvenca spremljanja
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,Closing Balance,Zaključna bilanca
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Sold Asset,Stroški prodanega sredstva
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Qty can not be entered in Purchase Return,Vrstica # {0}: Zavrnjene količine ni mogoče vnesti v Vrnitev nakupa
DocType: Asset Maintenance Log,ACC-AML-.YYYY.-,ACC-AML-.LLLL.-
DocType: GSTR 3B Report,JSON Output,Izhod JSON
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Increment cannot be 0,Povečanje ne more biti 0
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} must be submitted,Predložiti je treba BOM {0}
DocType: Amazon MWS Settings,Synch Orders,Sinhroniziraj naročila
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Disburse Loan,Izplačilo posojila
DocType: Item,Delivered by Supplier (Drop Ship),Dobavljeno s strani dobavitelja (Drop Ship)
apps/erpnext/erpnext/templates/pages/cart.html,Place Order,Naročiti
DocType: Employee,Place of Issue,Kraj izdaje
DocType: Purchase Receipt,Transporter Details,Transporter Podrobnosti
,Gross and Net Profit Report,Poročilo o bruto in neto dobičku
DocType: Appraisal Template,Appraisal Template Title,Naslov predloge ocene
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Orders Created: {0},Ustvarjeni nalogi za delo: {0}
DocType: Packed Item,To Warehouse (Optional),V skladišče (izbirno)
DocType: Appointment Type,Physician,Zdravnik
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Until,Do
DocType: Leave Policy,Leave Policy Details,Zapusti podrobnosti o pravilniku
DocType: HR Settings,<b>Example:</b> SAL-{first_name}-{date_of_birth.year} <br>This will generate a password like SAL-Jane-1972,"<b>Primer:</b> SAL- {first_name} - {date_of_birth.year} <br> To bo ustvarilo geslo, kot je 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,Posodobi številko serije
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,"Pustite nepreverjeno, če ne želite razmisliti o seriji, medtem ko izdelujete skupine, ki temeljijo na tečaju."
DocType: Assessment Plan Criteria,Maximum Score,Najvišja ocena
DocType: Website Filter Field,Website Filter Field,Polje filtra spletnega mesta
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Probationary Period,Poskusna doba
DocType: Travel Request,Require Full Funding,Zahtevajte polno financiranje
DocType: Batch,Manufacturing Date,Datum izdelave
apps/erpnext/erpnext/utilities/activation.py,Group your students in batches,Združite svoje učence v paketih
DocType: Payroll Entry,Bimonthly,Vsak mesec
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Eliminated due to disposal of assets,Amortizacija se odpravi zaradi odtujitve sredstev
DocType: Maintenance Visit,Purposes,Namen
apps/erpnext/erpnext/hooks.py,Shipments,Pošiljke
DocType: Program Enrollment Tool,New Academic Term,Novi akademski mandat
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Nothing is included in gross,Nič ni vključeno v bruto
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,New Warehouse Name,Novo ime skladišča
apps/erpnext/erpnext/selling/report/sales_partner_transaction_summary/sales_partner_transaction_summary.js,Show Return Entries,Prikaži vnose za vrnitev
DocType: Soil Texture,Soil Type,Vrsta tal
DocType: Loyalty Program,Multiple Tier Program,Večstopenjski program
DocType: BOM Update Tool,The BOM which will be replaced,"BOM, ki bo zamenjan"
DocType: Patient,Risk Factors,Dejavniki tveganja
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sale,Rezervirano za prodajo
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Prescriptions,Predpisi
apps/erpnext/erpnext/config/accounting.py,Bills raised to Customers.,"Računi, zbrani za stranke."
apps/erpnext/erpnext/config/hr.py,Performance,Izvedba
DocType: Training Event,Seminar,Seminar
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Credit ({0}),Kredit ({0})
DocType: Payment Request,Subscription Plans,Naročniški načrti
DocType: GSTR 3B Report,March,Marec
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split Batch,Razdelite serijo
DocType: School House,House Name,Ime hiše
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Outstanding for {0} cannot be less than zero ({1}),Neporavnano za {0} ne sme biti manjše od nič ({1})
DocType: Vehicle,Petrol,Petrol
DocType: Customer,Bypass credit limit check at Sales Order,Prekličite preverjanje kreditnega limita na prodajnem nalogu
DocType: Employee External Work History,Employee External Work History,Zunanja delovna zgodovina zaposlenih
DocType: HR Settings,Expense Approver Mandatory In Expense Claim,Odobrilec stroškov je obvezen v odškodninskem zahtevku
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Optional. Sets company's default currency, if not specified.","Neobvezno. Nastavi privzeto valuto podjetja, če ni določena."
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Monthly Repayment Amount cannot be greater than Loan Amount,Mesečni znesek odplačila ne sme biti višji od zneska posojila
DocType: Leave Allocation,Allocation,Dodelitev
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid attachment {0},Opozorilo: Neveljavna priloga {0}
DocType: Vehicle,License Plate,Registrska tablica
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Paid Amount cannot be greater than total negative outstanding amount {0},Plačani znesek ne sme biti višji od skupnega negativnega neporavnanega zneska {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,Količina zalog za začetek postopka v skladišču ni na voljo. Želite posneti prenos zalog
DocType: Bank Guarantee,Clauses and Conditions,Določbe in pogoji
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please select correct account,Izberite pravilen račun
DocType: Content Activity,Content Activity,Dejavnost vsebine
DocType: Pricing Rule Detail,Pricing Rule Detail,Podrobnosti o določanju cen
DocType: Loan,Monthly Repayment Amount,Mesečni znesek odplačila
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Predložen nakupni račun
DocType: Leave Control Panel,Employment Type (optional),Vrsta zaposlitve (neobvezno)
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid {0} for Inter Company Transaction.,Neveljavna {0} za transakcijo med podjetji.
DocType: Asset Movement,From Employee,Od zaposlenega
DocType: Attendance,Attendance Date,Datum udeležbe
apps/erpnext/erpnext/setup/doctype/company/company.js,There were errors.,Prišlo je do napak.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consumer Products,Potrošniški izdelki
DocType: Email Digest,Add/Remove Recipients,Dodaj / odstrani prejemnike
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Znesek davka po znesku popusta (valuta podjetja)
DocType: Account,Capital Work in Progress,Kapitalsko delo v teku
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Prebrskajte BOM
DocType: Cash Flow Mapping,Select Maximum Of 1,Izberite Največ 1
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Disbursement Date cannot be after Loan Repayment Start Date,Datum izplačila ne more biti po datumu začetka odplačevanja posojila
DocType: Stock Settings,Batch Identification,Identifikacija serije
DocType: Pricing Rule Brand,Pricing Rule Brand,Znamka za določanje cen
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js,This is a root sales person and cannot be edited.,"To je oseba, ki prodaja korenine in je ni mogoče urejati."
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Payroll date can not be less than employee's joining date,"Datum izplačil ne more biti krajši od datuma, ko se zaposleni pridruži"
DocType: Fee Validity,Max number of visit,Največje število obiskov
DocType: Item,Serial Nos and Batches,Serijske številke in paketi
DocType: HR Settings,Password Policy,Pravilnik o geslih
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,There were errors creating Course Schedule,Pri oblikovanju urnika tečaja je prišlo do napak
DocType: Student Attendance Tool,Batch,Serija
DocType: Amazon MWS Settings,ERPNext Integrations,ERPNaslednje integracije
DocType: Batch,Source Document Name,Ime izvornega dokumenta
DocType: Restaurant,Invoice Series Prefix,Predpona serije računov
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,90-Above,90-zgoraj
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Summary,Povzetek klica
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Currency for {0} must be {1},Valuta za {0} mora biti {1}
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,From Date must be before To Date,Od datuma mora biti pred datumom
DocType: Delivery Settings,Dispatch Notification Attachment,Priloga za pošiljanje obvestil
apps/erpnext/erpnext/controllers/accounts_controller.py,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Skupni znesek plačila na urniku plačil mora biti enak Grand / Rounded Total
,Itemwise Recommended Reorder Level,Priporočena stopnja ponovnega naročanja
DocType: Course Activity,Video,Video
DocType: Salary Slip Loan,Salary Slip Loan,Posojilo za izplačilo plač
DocType: Account,Balance Sheet,Bilanca stanja
DocType: Email Digest,Payables,Obveznosti
apps/erpnext/erpnext/controllers/stock_controller.py,Create Quality Inspection for Item {0},Ustvarite pregled kakovosti za element {0}
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Created,Ustvarjena pristojbina
,Customer Acquisition and Loyalty,Pridobivanje in zvestoba strank
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Student Group Name is mandatory in row {0},Ime skupine učencev je obvezno v vrstici {0}
apps/erpnext/erpnext/config/accounting.py,Exchange Rate Revaluation master.,Poveljnik prevrednotenja deviznega tečaja.
apps/erpnext/erpnext/controllers/status_updater.py,Status must be one of {0},Stanje mora biti eno od {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",Za kartico z opravilom {0} lahko vnesete samo vnos &quot;Stanje prenosa materiala za izdelavo&quot;
DocType: Asset,Insurance Start Date,Datum začetka zavarovanja
DocType: Target Detail,Target Detail,Ciljna podrobnost
DocType: Packing Slip,Net Weight UOM,Neto teža UOM
DocType: Purchase Invoice Item,Net Amount (Company Currency),Neto znesek (valuta podjetja)
DocType: Bank Statement Transaction Settings Item,Mapped Data,Kartirani podatki
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Securities and Deposits,Vrednostnih papirjev in depozitov
DocType: Promotional Scheme Price Discount,Discount Type,Vrsta popustov
DocType: Hotel Settings,Default Taxes and Charges,Privzeti davki in pristojbine
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py,This is based on transactions against this Supplier. See timeline below for details,To temelji na transakcijah s tem dobaviteljem. Za podrobnosti si oglejte časovni pas spodaj
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum benefit amount of employee {0} exceeds {1},Najvišji znesek za zaposlene {0} presega {1}
DocType: Delivery Note Item,Against Sales Invoice,Proti računu za prodajo
DocType: Loyalty Point Entry,Purchase Amount,Znesek nakupa
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Cannot set as Lost as Sales Order is made.,Ni mogoče nastaviti kot izgubljeno kot prodajno naročilo.
DocType: Salary Structure,Salary Component for timesheet based payroll.,Komponenta plač za obračun plač na podlagi urnika.
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py,Suplier Name,Ime dodatka
DocType: Account Subtype,Account Subtype,Podtip računa
DocType: Manufacturing Settings,Allow multiple Material Consumption against a Work Order,Dovoli večjo porabo materiala glede na delovni nalog
apps/erpnext/erpnext/templates/pages/help.html,Open a new ticket,Odpri novo karto
apps/erpnext/erpnext/public/js/conf.js,Report an Issue,Prijavite težavo
DocType: Support Search Source,Link Options,Možnosti povezave
DocType: Selling Settings,Sales Update Frequency,Pogostost posodobitve prodaje
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Pin Code,Za kodo Pin
apps/erpnext/erpnext/config/crm.py,Newsletters,Glasila
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,License,Licenca
DocType: Employee Tax Exemption Declaration,Other Incomes,Drugi dohodki
DocType: Job Card,Job Started,Začelo se je delo
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set recurring after saving,Nastavite ponavljanje po shranjevanju
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Atleast one item should be entered with negative quantity in return document,Vsaj eno postavko je treba vnesti z negativno količino v povratnem dokumentu
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for Hold,Razlog za zadržanje
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""",URL za »Vsi izdelki«
DocType: Lead,Organization Name,ime organizacije
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from and valid upto fields are mandatory for the cumulative,Veljavna polja in veljavna polja za dopolnitev so obvezna za kumulativno
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Batch No must be same as {1} {2},Vrstica # {0}: serijska št. Mora biti enaka kot {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,Zamrznejo se transakcije z vrednostnimi papirji pred {0}
DocType: Driver,Issuing Date,Datum izdaje
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requestor,Prosilec
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Mesto stroškov {2} ne pripada podjetju {3}
DocType: Certification Application,Not Certified,Ni potrjeno
DocType: Work Order,Check if material transfer entry is not required,"Preverite, ali vnos materiala ni potreben"
DocType: BOM,Raw Material Cost,Stroški surovin
DocType: Project,Second Email,Druga e-pošta
DocType: Vehicle Log,Service Detail,Podrobnosti storitve
DocType: Manufacturing Settings,Default 10 mins,Privzeto 10 min
DocType: Subscription Plan,Billing Interval,Interval obračunavanja
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Total Debit must be equal to Total Credit. The difference is {0},Skupna obremenitev mora biti enaka skupnemu kreditu. Razlika je {0}
DocType: Supplier,Name and Type,Ime in vrsta
DocType: Cheque Print Template,Cheque Height,Preverite višino
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please enter relieving date.,Vnesite datum za sprostitev.
DocType: Loyalty Program,Loyalty Program Help,Pomoč za program zvestobe
DocType: Journal Entry,Inter Company Journal Entry Reference,Referenca vnosa medpodjetniškega dnevnika
DocType: Quality Meeting,Agenda,Dnevni red
apps/erpnext/erpnext/config/hr.py,Shift Management,Upravljanje premika
DocType: Quality Action,Corrective,Popravek
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js,Group By,Skupina do
DocType: Bank Account,Address and Contact,Naslov in stik
DocType: Payment Term,Day(s) after invoice date,Dnevi po datumu računa
DocType: Woocommerce Settings,API consumer secret,Skrivnost potrošnikov API
DocType: Shift Assignment,Shift Assignment,Dodelitev premika
DocType: Maintenance Visit,MAT-MVS-.YYYY.-,MAT-MVS-.YYYY.-
DocType: Issue,First Responded On,Prvi odgovor je bil vklopljen
DocType: Work Order Operation,Estimated Time and Cost,Ocenjeni čas in stroški
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Stranka&gt; Skupina kupcev&gt; Ozemlje
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Return / Credit Note,Vračilo / kreditna opomba
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Select Default Supplier,Izberite Privzeti dobavitelj
DocType: Water Analysis,Appearance,Videz
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Voucher #,Voucher #
DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Nastavitev vrste računa pomaga pri izbiri računa v transakcijah.
apps/erpnext/erpnext/config/projects.py,Define Project type.,Definiraj tip projekta.
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to install presets,Prednastavitev ni bilo mogoče namestiti
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},Privzeti strošek dejavnosti obstaja za vrsto dejavnosti - {0}
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Target Location,Ciljna lokacija
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Count,Število naročil
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Invoice Patient Registration,Registracija pacienta na računu
DocType: Training Event Employee,Training Event Employee,Usposabljanje delavca
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?,"Izgubili boste zapise predhodno ustvarjenih računov. Ali ste prepričani, da želite znova zagnati to naročnino?"
DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Podrobnosti predloge za preslikavo denarnega toka
DocType: Drug Prescription,Interval UOM,Interval UOM
DocType: Shift Type,Grace Period Settings For Auto Attendance,Nastavitve obdobja počitka za samodejno prisotnost
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Iz valute in valute ne moreta biti enaka
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Pharmaceuticals,Farmacevtski izdelki
DocType: Employee,HR-EMP-,HR-EMP-
DocType: Service Level,Support Hours,Čas podpore
apps/erpnext/erpnext/controllers/selling_controller.py,{0} {1} is cancelled or closed,{0} {1} je preklican ali zaprt
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Vrstica {0}: Predplačilo za stranko mora biti dobroimetje
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Voucher (Consolidated),Združi po kuponu (konsolidirano)
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Please set default account in Expense Claim Type {0},Nastavite privzeti račun v vrsti zahtevka za stroške {0}
,BOM Search,Iskanje BOM
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Dispatch State,Država odpreme
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Continue Configuration,Nadaljuj konfiguracijo
DocType: Item Alternative,Item Alternative,Alternativa postavke
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Healthcare Practitioner...,Izberite zdravniško osebje ...
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Employee {0} already submited an apllication {1} for the payroll period {2},Zaposleni {0} je že predložil prilogo {1} za plačilno obdobje {2}
apps/erpnext/erpnext/controllers/accounts_controller.py,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Opomba: plačilni vnos ne bo ustvarjen, ker »Gotovina ali bančni račun« ni bil določen"
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non GST Inward Supplies,Notranje dobave GST
DocType: Detected Disease,Disease,Bolezen
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Less Than Amount,Manj kot znesek
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,'To Date' is required,&quot;Datum&quot; je obvezen
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Capital Equipments,Kapitalska oprema
DocType: Bank Statement Settings,Statement Headers,Glave izjave
DocType: Packing Slip,Gross Weight UOM,Bruto teža UOM
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please check Multi Currency option to allow accounts with other currency,"Preverite možnost Multi Valuta, da dovolite račune z drugo valuto"
DocType: Loan,Repay Fixed Amount per Period,Vrni fiksni znesek na obdobje
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Show Variant Attributes,Pokaži atribute variant
DocType: GL Entry,Credit Amount,Znesek kredita
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Total Amount Credited,"Celotni znesek, odobren"
DocType: Support Search Source,Post Route Key List,Seznam ključnih besed poti
apps/erpnext/erpnext/accounts/utils.py,{0} {1} not in any active Fiscal Year.,{0} {1} ne v nobenem aktivnem poslovnem letu.
DocType: Quality Action Resolution,Problem,Težava
DocType: Training Event,Conference,Konferenca
DocType: Mode of Payment Account,Mode of Payment Account,Način plačila račun
DocType: Leave Encashment,Encashable days,"Dnev, ki jih je mogoče vnovčiti"
DocType: Healthcare Settings,Collect Fee for Patient Registration,Zberite pristojbino za registracijo bolnika
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Disable Template,Onemogoči predlogo
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Filter Employees By (Optional),Filter zaposlenih po (neobvezno)
apps/erpnext/erpnext/setup/default_success_action.py,{0} has been submitted successfully,{0} je bilo uspešno poslano
DocType: Workstation,Wages per hour,Plače na uro
DocType: Item,Max Discount (%),Najvišji popust (%)
DocType: Employee,Salary Mode,Način plač
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.,"Znesek {0}, nastavljen v tem zahtevku za plačilo, se razlikuje od izračunanega zneska vseh plačilnih načrtov: {1}. Prepričajte se, da je to pravilno, preden oddate dokument."
DocType: Opportunity,Contact Info,Kontaktne informacije
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Transaction reference no {0} dated {1},Sklicna številka transakcije {0} z dne {1}
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Currency is required for Price List {0},Valuta je potrebna za cenik {0}
DocType: Program,Program Name,Ime programa
apps/erpnext/erpnext/accounts/doctype/account/account.js,This is a root account and cannot be edited.,To je korenski račun in ga ni mogoče urejati.
apps/erpnext/erpnext/projects/doctype/task/task.py,'Expected Start Date' can not be greater than 'Expected End Date',»Pričakovani začetni datum« ne sme biti večji od »Pričakovani končni datum«
DocType: Employee Tax Exemption Declaration Category,Employee Tax Exemption Declaration Category,Kategorija Izjava o oprostitvi davka na zaposlene
DocType: Work Order,Item To Manufacture,Postavka za izdelavo
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,In Qty,V št
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; ni mogoče preklicati, ker je zapis sredstva prisoten proti elementu"
DocType: Salary Component,Flexible Benefits,Prilagodljive prednosti
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Approval Notification,Pusti obvestilo o odobritvi
DocType: Employee Tax Exemption Proof Submission,Total Actual Amount,Skupaj dejanski znesek
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party is mandatory,Stranka je obvezna
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Check all,Preveri vse
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.",V primeru neomejenega poteka veljavnosti za točke zvestobe ohranite prazno trajanje izteka veljavnosti ali 0.
DocType: Attendance Request,Explanation,Razlaga
DocType: Journal Entry Account,Exchange Rate,Menjalni tečaj
DocType: Task,Total Costing Amount (via Time Sheet),Skupni znesek obračunavanja stroškov (prek časovnega lista)
DocType: Tax Rule,Billing County,Billing County
DocType: Lead Source,Lead Source,Vodilni vir
DocType: Email Digest,Next email will be sent on:,Naslednja e-pošta bo poslana:
DocType: Batch,Source Document Type,Vrsta izvirnega dokumenta
DocType: Project,Frequency To Collect Progress,Pogostost zbiranja napredka
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Head of Marketing and Sales,Vodja marketinga in prodaje
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Supplier Quotation {0} created,Ustvarjena je bila ponudba ponudnika {0}
apps/erpnext/erpnext/setup/doctype/company/company.js,Successfully deleted all transactions related to this company!,"Vse transakcije, povezane s tem podjetjem, so bile uspešno izbrisane!"
DocType: Purchase Taxes and Charges,On Net Total,V skupnem znesku
DocType: Bank Transaction Mapping,Column in Bank File,Stolpec v bančni datoteki
DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Hold,Zadrži
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,You can not enter current voucher in 'Against Journal Entry' column,Trenutni stolpec ne morete vnesti v stolpec »Vnos v dnevnik«
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid authentication error,Napaka pri preverjanju pristnosti šopov
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Please select Company and Party Type first,Najprej izberite podjetje in tip stranke
apps/erpnext/erpnext/utilities/user_progress.py,Go to ,Pojdi do
,Work Orders in Progress,Delovni nalogi v teku
DocType: Payment Reconciliation,To Invoice Date,Na datum računa
DocType: Staffing Plan Detail,Vacancies,Prosta delovna mesta
DocType: Purchase Order Item,Last Purchase Rate,Zadnja cena nakupa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Sales Expenses,Stroški prodaje
DocType: Healthcare Settings,Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,"Računi za dohodek po privzetku, ki jih je treba uporabiti, če niso določeni v zdravstvenem delavcu za knjiženje stroškov imenovanja."
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Student Group is already updated.,Študentska skupina je že posodobljena.
DocType: Driver,Fleet Manager,Upravitelj voznega parka
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,You are not authorized to approve leaves on Block Dates,Nimate dovoljenja za odobritev listov na datumih bloka
,Purchase Invoice Trends,Trendi nakupa računa
DocType: Purchase Taxes and Charges,On Previous Row Amount,Pri prejšnjem številu vrstic
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py,No Tax Withholding data found for the current Fiscal Year.,Ni podatkov o zadržanju davka za tekoče poslovno leto.
DocType: Travel Itinerary,Taxi,Taxi
DocType: Contract,Inactive,Neaktivno
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Actual qty in stock,Dejanska količina na zalogi
DocType: Student Sibling,Student Sibling,Študentski moški
apps/erpnext/erpnext/utilities/user_progress.py,Go to Rooms,Pojdite v sobe
apps/erpnext/erpnext/utilities/activation.py,Create Employee Records,Ustvarite zapise zaposlenih
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Ordered Qty: Quantity ordered for purchase, but not received.","Naročena količina: Količina, naročena za nakup, vendar ne prejeta."
DocType: Patient,Patient ID,ID bolnika
DocType: Employee,Permanent Address Is,Stalni naslov je
DocType: Hotel Room Reservation,Guest Name,Ime gosta
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Accumulated Values in Group Company,Zbrane vrednosti v podjetju v skupini
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Resume,Nadaljuj
,BOM Stock Calculated,BOM Stock izračunano
DocType: Employee Transfer,New Employee ID,ID novega zaposlenega
apps/erpnext/erpnext/config/accounting.py,Tax template for selling transactions.,Davčna predloga za prodajne transakcije.
DocType: Currency Exchange,To Currency,V valuto
DocType: Course Schedule,Instructor Name,Ime inštruktorja
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Research,Raziskave
DocType: Additional Salary,Employee Name,ime zaposlenega
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance can not be marked for future dates,Udeleženci ne morejo biti označeni za prihodnje datume
DocType: Supplier Scorecard Scoring Standing,Min Grade,Min
DocType: Work Order,Manufactured Qty,Proizvedena količina
DocType: Patient,Alcohol Current Use,Trenutna uporaba alkohola
DocType: Leave Application,Total Leave Days,Skupni dnevi dopusta
DocType: Asset Repair,Repair Status,Stanje popravila
DocType: Territory,Territory Manager,Upravitelj ozemlja
DocType: Lab Test,Sample ID,ID vzorca
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html,Cart is Empty,Košarica je prazna
apps/erpnext/erpnext/hr/doctype/shift_type/shift_type.js,Attendance has been marked as per employee check-ins,Udeležba je bila označena kot prijavljena na zaposlenega
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset {0} must be submitted,Predložiti je treba sredstvo {0}
,Absent Student Report,Odsotno študentsko poročilo
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Included in Gross Profit,Vključen v bruto dobiček
apps/erpnext/erpnext/accounts/page/pos/pos.js,Price List not found or disabled,Cenika ni mogoče najti ali onemogočiti
DocType: Travel Request Costing,Funded Amount,Finančni znesek
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} has not been submitted so the action cannot be completed,"{0} {1} ni bila poslana, zato dejanja ni mogoče dokončati"
DocType: Subscription,Trial Period End Date,Preskusni končni datum
DocType: Shift Type,Alternating entries as IN and OUT during the same shift,Izmenični vnosi kot IN in OUT med istim premikom
DocType: BOM Update Tool,The new BOM after replacement,Nova BOM po zamenjavi
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 5,Točka 5
DocType: Employee,Passport Number,Številka potnega lista
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Opening,Začasno odpiranje
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Pricing Rules are further filtered based on quantity.,Pravila za določanje cen so nadalje filtrirana glede na količino.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Appraisal {0} created for Employee {1} in the given date range,Ocena {0} je bila ustvarjena za zaposlenega {1} v danem časovnem obdobju
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Variance,Varianca
DocType: Sales Order,Partly Delivered,Delno dobavljeno
DocType: Item,Maintain Stock,Vzdržujte zalogo
DocType: Job Card,Started Time,Začetni čas
DocType: Item,Average time taken by the supplier to deliver,"Povprečen čas, ki ga je dobavitelj potreboval za dobavo"
DocType: Stock Entry,Per Transferred,Na preneseno
DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),"Označuje, da je paket del te dostave (samo osnutek)"
DocType: Upload Attendance,Get Template,Pridobite predlogo
DocType: Agriculture Task,Next Business Day,Naslednji delovni dan
DocType: Payment Reconciliation,Receivable / Payable Account,Račun terjatev / obveznosti
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,You cannot credit and debit same account at the same time,Hkrati ne morete kreditirati in bremeniti istega računa
DocType: Agriculture Analysis Criteria,Weather,Vreme
,Welcome to ERPNext,Dobrodošli v ERPNext
DocType: Payment Reconciliation,Maximum Invoice Amount,Najvišji znesek računa
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Expense Claim for Vehicle Log {0},Zahtevek za stroške za dnevnik vozil {0}
DocType: Healthcare Settings,Patient Encounters in valid days,Srečanja pacientov v veljavnih dneh
,Student Fee Collection,Zbiranje študentskih pristojbin
DocType: Selling Settings,Sales Order Required,Zahtevan prodajni nalog
DocType: Stock Entry Detail,Serial No / Batch,Serijska št. / Serija
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Statement of Account,Izjava o računu
DocType: Job Offer Term,Offer Term,Trajanje ponudbe
apps/erpnext/erpnext/setup/doctype/company/company.py,Account {0} does not belong to company: {1},Račun {0} ne pripada podjetju: {1}
DocType: Tally Migration,Tally Migration,Tally Migration
DocType: Item,"Purchase, Replenishment Details","Nakup, Podrobnosti o obnavljanju"
DocType: Purchase Invoice,"Once set, this invoice will be on hold till the set date","Ko je ta račun nastavljen, bo zadržan do določenega datuma"
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock cannot exist for Item {0} since has variants,"Stanja ne more obstajati za element {0}, ker ima različice"
DocType: Lab Test Template,Grouped,Združeni
DocType: GSTR 3B Report,January,Januar
DocType: Course Assessment Criteria,Course Assessment Criteria,Merila za ocenjevanje predmeta
DocType: Certification Application,INR,INR
apps/erpnext/erpnext/config/accounting.py,Profitability,Dobičkonosnost
DocType: Job Card Time Log,Completed Qty,Dokončano število
DocType: Agriculture Task,Start Day,Začetni dan
apps/erpnext/erpnext/config/integrations.py,GoCardless payment gateway settings,Nastavitve plačilnega prehoda GoCardless
DocType: Asset Category Account,Depreciation Expense Account,Račun stroškov amortizacije
DocType: Production Plan Sales Order,Production Plan Sales Order,Proizvodni načrt Prodajni nalog
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,Količina končnega izdelka <b>{0}</b> in količina <b>{1}</b> ne moreta biti drugačna
apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js,View Lab Tests,Ogled laboratorijskih testov
DocType: Article,Instructor,Inštruktor
DocType: Shopping Cart Settings,Show Public Attachments,Prikaži javne priloge
DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Polja bodo kopirana le v času nastanka.
DocType: Delivery Note,Vehicle No,Št
DocType: Lead,CRM-LEAD-.YYYY.-,CRM-LEAD-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry is already created,Vnos plačila je že ustvarjen
apps/erpnext/erpnext/stock/doctype/item/item.js,Multiple Variants,Več različic
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please select a csv file,Izberite datoteko csv
DocType: Serial No,Serial No Details,Serijska št. Podrobnosti
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Source and Target Location cannot be same,Lokacija izvora in cilja ne moreta biti ista
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Show Employee,Pokaži zaposlenega
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.py,Bank account {0} already exists and could not be created again,Bančni račun {0} že obstaja in ga ni bilo mogoče ponovno ustvariti
DocType: Payment Entry,Writeoff,Odpisati
DocType: Issue,ISS-.YYYY.-,ISS-.YYYY.-
DocType: Payment Order,Payment Request,Zahteva za plačilo
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Selected Price List should have buying and selling fields checked.,Izbrani cenik naj ima preverjena odkupna in prodajna polja.
apps/erpnext/erpnext/accounts/doctype/account/account.py,Cannot covert to Group because Account Type is selected.,"Ni mogoče preklopiti v skupino, ker je izbrana vrsta računa."
DocType: Company,Exchange Gain / Loss Account,Račun menjalniških dobičkov / izgub
DocType: Project Template,Project Template,Predloga projekta
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Reorder Qty,Reorder Qty
apps/erpnext/erpnext/accounts/report/financial_statements.html,Too many columns. Export the report and print it using a spreadsheet application.,Preveč stolpcev. Izvozi poročilo in ga natisnite z uporabo preglednice.
DocType: Payroll Entry,Salary Slips Submitted,Poslani plačni vložki
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,For Supplier,Za dobavitelja
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}.,Računovodski vnosi so že bili opravljeni v valuti {0} za podjetje {1}. Izberite račun terjatev ali obveznosti s valuto {0}.
DocType: Asset Value Adjustment,New Asset Value,Nova vrednost sredstva
DocType: Volunteer,Volunteer Type,Vrsta prostovoljca
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Printed On,Natisnjeno Vklopljeno
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js,Grant Leaves,Odobri listje
DocType: Vehicle,Vehicle Value,Vrednost vozila
,Project Billing Summary,Povzetek obračuna projekta
DocType: Asset,Receipt,Prejem
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule' to get schedule,"Kliknite »Ustvari urnik«, da dobite urnik"
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,TDS Rate %,Stopnja TDS%
DocType: Training Event,Contact Number,Kontaktna številka
DocType: POS Closing Voucher,POS Closing Voucher,POS zaključni bon
DocType: Quality Inspection Template,Quality Inspection Template Name,Ime predloge za pregled kakovosti
apps/erpnext/erpnext/public/js/hub/marketplace.js,Added {0} users,Dodano {0} uporabnikov
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to Non-Group,Pretvori v ne-skupino
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Set as Lost,Nastavi kot Izgubljeno
DocType: Journal Entry Account,Payroll Entry,Vnos plač
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je obvezen. Morda zapis za izmenjavo valute ni ustvarjen za {1} do {2}.
DocType: Delivery Note,Transporter Name,Ime prevoznika
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.","Predvidena količina: količina, za katero je bil delovni nalog postavljen, vendar še ni izdelan."
DocType: Item,Has Variants,Ima različice
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Securities & Commodity Exchanges,Vrednostni papirji in blagovne borze
DocType: Purchase Invoice Item,Deferred Expense,Odloženi stroški
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py,Salary Slip ID,ID plačilne listice
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Membership ID,ID članstva
,Sales Register,Prodajni register
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Namestite sistem za imenovanje zaposlenih v človeških virih&gt; Nastavitve za HR
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Please specify a valid 'From Case No.',Navedite veljavno &quot;Iz zadeve št.&quot;
DocType: Customer,Primary Address and Contact Detail,Osnovni naslov in podrobnosti stika
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,This is based on transactions against this Customer. See timeline below for details,To temelji na transakcijah s to stranko. Za podrobnosti si oglejte časovni pas spodaj
DocType: Hotel Room,Hotels,Hoteli
apps/erpnext/erpnext/regional/india/utils.py,You must be a registered supplier to generate e-Way Bill,Za ustvarjanje e-Way Bill morate biti registrirani dobavitelj
DocType: Shipping Rule,Valid for Countries,Velja za države
,Territory Target Variance Based On Item Group,Teritorialna ciljna odstopanja na podlagi skupine izdelkov
DocType: Rename Tool,Rename Tool,Preimenuj orodje
DocType: Loan Application,Total Payable Amount,Skupni znesek za plačilo
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Dodaj vse dobavitelje
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Vrstica {0}: valuta BOM # {1} mora biti enaka izbrani valuti {2}
DocType: Pricing Rule,Product,Izdelek
apps/erpnext/erpnext/utilities/bot.py,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} enot [{1}] (# Form / Item / {1}) najdenih v [{2}] (# Oblika / Skladišče / {2})
DocType: Vital Signs,Weight (In Kilogram),Teža (v kilogramih)
DocType: Department,Leave Approver,Pusti odobritev
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Transakcije
DocType: Issue,Resolution Details,Podrobnosti o ločljivosti
DocType: Sales Invoice Item,Delivery Note Item,Postavka dobavnice
DocType: QuickBooks Migrator,Connected to QuickBooks,Povezan s storitvijo QuickBooks
DocType: Item,Shelf Life In Days,Rok trajanja v dnevih
apps/erpnext/erpnext/config/buying.py,Key Reports,Ključna poročila
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Possible Supplier,Možen dobavitelj
,Issued Items Against Work Order,Izdane postavke za delovni nalog
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.py,Please enter GSTIN and state for the Company Address {0},Vnesite GSTIN in navedite naslov podjetja {0}
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Creating {0} Invoice,Ustvarjanje računa {0} Račun
DocType: Student,Joining Date,Datum pridružitve
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.,Navedite akademsko leto in nastavite datum začetka in konca.
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requesting Site,Zahtevano mesto
DocType: Purchase Invoice,Against Expense Account,Proti računu stroškov
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Cannot create a Delivery Trip from Draft documents.,Izhodnega dokumenta za dostavo ni mogoče ustvariti iz osnutkov dokumentov.
apps/erpnext/erpnext/config/crm.py,Lead to Quotation,Privedite do ponudbe
DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,"To preverite, če študent prebiva v zavodu."
apps/erpnext/erpnext/education/utils.py,Student {0} - {1} appears Multiple times in row {2} & {3},Študent {0} - {1} se prikaže večkrat v vrstici {2} &amp; {3}
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Creating Payment Entries......,Ustvarjanje plačilnih vnosov ......
DocType: Production Plan,Total Planned Qty,Skupna načrtovana količina
DocType: Subscription Plan,Cost,Stroški
DocType: Healthcare Service Unit Type,Healthcare Service Unit Type,Vrsta enote za zdravstveno oskrbo
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,Please enter atleast 1 invoice in the table,V tabelo vnesite vsaj 1 račun
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Sales Order {0} is not submitted,Prodajno naročilo {0} ni poslano
apps/erpnext/erpnext/education/api.py,Attendance has been marked successfully.,Udeležba je bila uspešno označena.
apps/erpnext/erpnext/accounts/doctype/tax_category/tax_category_dashboard.py,Pre Sales,Pred prodajo
apps/erpnext/erpnext/config/projects.py,Project master.,Vodja projekta.
DocType: Daily Work Summary,Daily Work Summary,Povzetek dnevnega dela
DocType: Asset,Partially Depreciated,Delno amortizirana
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,'Days Since Last Order' must be greater than or equal to zero,&#39;Dani od zadnjega naročila&#39; morajo biti večji ali enaki nič
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,For Default Supplier (optional),Za privzetega dobavitelja (izbirno)
DocType: Employee,Leave Encashed?,Zapusti reševanje?
DocType: Certified Consultant,Discuss ID,Pogovorite se o ID-ju
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Please set GST Accounts in GST Settings,Nastavite račune GST v nastavitvah GST
DocType: Quiz,Latest Highest Score,Najnovejši najvišji rezultat
DocType: Supplier,Billing Currency,Valuta za obračun
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Student Activity,Dejavnost študentov
apps/erpnext/erpnext/setup/doctype/territory/territory.py,Either target qty or target amount is mandatory,Ciljna ali ciljna količina je obvezna
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 zdaj privzeto fiskalno leto. Osvežite brskalnik, da bo sprememba začela veljati."
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Address 2,Iz naslova 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","Od blaga, prikazanega v 3.1 (a) zgoraj, podrobnosti o meddržavnih dobavah za neregistrirane osebe, davčne zavezance za sestavo in imetnike UIN"
DocType: Company,Default Inventory Account,Privzeti račun inventarja
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Datum konca leta ne sme biti prej kot datum začetka leta. Popravite datume in poskusite znova.
DocType: Target Detail,Target  Amount,Ciljni znesek
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Hotel Rooms of type {0} are unavailable on {1},Hotelske sobe tipa {0} niso na voljo v {1}
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,New Customer Revenue,Novi prihodki strank
DocType: Landed Cost Item,Applicable Charges,Veljavni stroški
,Point of Sale,Prodajno mesto
DocType: Authorization Rule,Approving User  (above authorized value),Odobritev uporabnika (nad dovoljeno vrednostjo)
DocType: Service Level Agreement,Entity,Entiteta
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} transferred from {2} to {3},Znesek {0} {1} prenesen iz {2} v {3}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Customer {0} does not belong to project {1},Stranka {0} ne pripada projektu {1}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Party Name,Iz imena stranke
DocType: Asset Maintenance Log,Maintenance Status,Stanje vzdrževanja
DocType: Production Plan Item,Pending Qty,Število čakajočih
apps/erpnext/erpnext/controllers/accounts_controller.py, or ,ali
DocType: Sales Order,Not Delivered,Ni dostavljeno
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leave Type {0} cannot be allocated since it is leave without pay,"Tipa dopusta {0} ni mogoče dodeliti, ker gre za dopust brez plačila"
DocType: GL Entry,Debit Amount,Znesek bremenitve
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Already record exists for the item {0},Za element {0} že obstaja zapis.
DocType: Video,Vimeo,Vimeo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Sub Assemblies,Podsklopi
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.","Če še vedno prevladujejo številna pravila za določanje cen, uporabnike prosimo, da ročno določijo prioriteto za reševanje sporov."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Ne morem odbiti, če je kategorija za »Vrednotenje« ali »Vrednotenje in Skupaj«"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,BOM and Manufacturing Quantity are required,Potrebne so BOM in proizvodna količina
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} has reached its end of life on {1},Element {0} je prenehal veljati na {1}
DocType: Quality Inspection Reading,Reading 6,Branje 6
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Company field is required,Polje podjetja je obvezno
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Material Consumption is not set in Manufacturing Settings.,Poraba materiala ni nastavljena v nastavitvah proizvodnje.
DocType: Assessment Group,Assessment Group Name,Ime ocenjevalne skupine
DocType: Purchase Invoice Item,Manufacturer Part Number,Številka dela proizvajalca
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Payroll Payable,Plače plačljive
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Row #{0}: {1} can not be negative for item {2},Vrstica # {0}: {1} ne more biti negativna za element {2}
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Balance Qty,Kol
DocType: Question,Multiple Correct Answer,Več pravilen odgovor
DocType: Loyalty Program,1 Loyalty Points = How much base currency?,1 Točke zvestobe = Koliko osnovne valute?
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Opomba: Za vrsto izstopa {0} ni dovolj ravnovesja.
DocType: Clinical Procedure,Inpatient Record,Zapis v bolnišnici
DocType: Sales Invoice Item,Customer's Item Code,Koda izdelka stranke
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Item Code,Spremeni kodo postavke
DocType: Student Group Instructor,Student Group Instructor,Inštruktor študentske skupine
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Transaction Type,Vrsta transakcije
apps/erpnext/erpnext/regional/india/utils.py,House rented dates should be atleast 15 days apart,Datumi najema hiše morajo biti vsaj 15 dni narazen
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,View Form,Obrazec za ogled
apps/erpnext/erpnext/stock/doctype/item/item.py,Valuation Rate is mandatory if Opening Stock entered,"Stopnja vrednotenja je obvezna, če je vstopna zaloga vnesena"
DocType: Employee,Exit Interview Details,Zaprite podrobnosti pogovorov
DocType: Sales Invoice,Accounting Details,Računovodski podatki
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,"Urnik vzdrževanja {0} je treba preklicati, preden prekličete ta prodajni nalog"
DocType: Driver,HR-DRI-.YYYY.-,HR-DRI-.YYYY.-
DocType: Customer,Mention if non-standard receivable account,"Navedite, če je račun nestandardne terjatve"
DocType: Lab Test,Prescription,Recept
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Closed,Nastavi kot zaprto
DocType: Asset,Opening Accumulated Depreciation,Odpiranje akumulirane amortizacije
DocType: Soil Texture,Sand Composition (%),Sestava peska (%)
DocType: Communication Medium,Communication Medium Type,Vrsta komunikacijskega medija
DocType: Production Plan,MFG-PP-.YYYY.-,MFG-PP-.YYYY.-
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Day Book Data,Podatki o knjigi dneva uvoza
DocType: Asset,Asset Owner Company,Družba lastnik premoženja
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Cost center is required to book an expense claim,Stroškovno mesto je potrebno za knjiženje odškodninskega zahtevka
apps/erpnext/erpnext/stock/utils.py,{0} valid serial nos for Item {1},{0} veljavnih serijskih številk za element {1}
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Cannot promote Employee with status Left,Zaposlenega ni mogoče promovirati s statusom levo
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expiry (In Days),Iztek (v dnevih)
DocType: Supplier Scorecard Standing,Notify Other,Obvesti drugo
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Please select Company,Izberite podjetje
,Item-wise Purchase Register,Poimensko nabavni register
DocType: Employee,Reason For Leaving,Razlog za odhod
DocType: Salary Slip,Earning & Deduction,Zaslužek in odbitek
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Employee Referral,Napotitev zaposlenih
,Qty to Order,Količina za naročilo
apps/erpnext/erpnext/config/buying.py,Request for purchase.,Zahteva za nakup.
DocType: Bin,Moving Average Rate,Gibljiva povprečna cena
apps/erpnext/erpnext/config/buying.py,Tax template for buying transactions.,Davčna predloga za nakupne transakcije.
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Send SMS,Pošlji SMS
apps/erpnext/erpnext/erpnext_integrations/utils.py,Unverified Webhook Data,Nepreverjeni podatki Webhook
apps/erpnext/erpnext/config/help.py,Human Resource,Človeški viri
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} has been modified. Please refresh.,{0} {1} je spremenjeno. Osvežite.
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},Stanje zalog v paketu {0} bo postalo negativno {1} za element {2} v skladišču {3}
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Creating Accounts...,Ustvarjanje računov ...
,Asset Depreciation Ledger,Sredstvo za obračun amortizacije
DocType: Location,Tree Details,Podrobnosti o drevesu
DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Ustvarite manjkajočo stranko ali dobavitelja.
DocType: Vital Signs,Blood Pressure (diastolic),Krvni tlak (diastolični)
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per rules 42 & 43 of CGST Rules,V skladu s pravili 42 in 43 Pravilnika CGST
DocType: Item,Show in Website (Variant),Prikaži na spletnem mestu (različica)
apps/erpnext/erpnext/education/doctype/fees/fees.js,Please set the Email ID for the Student to send the Payment Request,"Nastavite e-poštni ID, da bo študent poslal zahtevo za plačilo"
DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Ustvarite pakirne liste za pakete, ki jih želite dostaviti. Uporablja se za sporočanje številke paketa, vsebine paketa in njegove teže."
DocType: SMS Log,No of Requested SMS,Št. Zahtevanih SMS
apps/erpnext/erpnext/config/accounting.py,Banking and Payments,Bančništvo in plačila
DocType: Instructor,Instructor Log,Dnevnik inštruktorja
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",Najvišja ugodnost zaposlenega {0} presega {1} za vsoto {2} vloge za dajatev sorazmerne sestavine in prejšnji zahtevani znesek
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Please enter valid email address,Vnesite veljaven e-poštni naslov
apps/erpnext/erpnext/config/retail.py,Retail Operations,Maloprodajne dejavnosti
DocType: Company,Phone No,Telefon št
,Reqd By Date,Zahteva po datumu
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Uncheck all,Počistite vse
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Place,Na mestu
DocType: Manufacturing Settings,Default Work In Progress Warehouse,Privzeto skladišče dela v teku
DocType: Fees,Include Payment,Vključi plačilo
DocType: Crop,Byproducts,Stranski proizvodi
DocType: Assessment Result,Student,Študent
apps/erpnext/erpnext/config/crm.py,Manage Customer Group Tree.,Upravljanje drevesa skupine uporabnikov.
DocType: Payment Entry,Payment From / To,Plačilo od / do
apps/erpnext/erpnext/stock/utils.py,Serial number {0} entered more than once,Serijska številka {0} je vnesena več kot enkrat
DocType: Website Item Group,Website Item Group,Skupina elementov spletne strani
DocType: Amazon MWS Settings,CA,CA
DocType: Serial No,Under Warranty,Pod garancijo
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,Invoice Posting Date,Datum knjiženja računa
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Delivery Note,Poročilo o dostavi
DocType: Education Settings,Attendance Freeze Date,Datum zamrznitve obiska
DocType: Warranty Claim,Item and Warranty Details,Podrobnosti izdelka in garancije
DocType: Job Card,Time Logs,Dnevniki časa
DocType: Hotel Room,Extra Bed Capacity,Kapaciteta dodatnega ležišča
DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,"Neto plačilo (z besedami) bo vidno, ko shranite izplačilo plač."
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Could not solve weighted score function. Make sure the formula is valid.,"Funkcije uteženega rezultata ni bilo mogoče rešiti. Prepričajte se, da je formula veljavna."
DocType: Asset,Asset Owner,Lastnik premoženja
apps/erpnext/erpnext/buying/utils.py,Warehouse is mandatory for stock Item {0} in row {1},Skladišče je obvezno za element {0} v vrstici {1}
DocType: Stock Entry,Total Additional Costs,Skupni dodatni stroški
apps/erpnext/erpnext/regional/italy/utils.py,Please set at least one row in the Taxes and Charges Table,V tabeli Davki in stroški nastavite vsaj eno vrstico
DocType: Asset Maintenance Team,Maintenance Team Name,Ime vzdrževalne ekipe
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Chart of Cost Centers,Grafikon stroškovnih mest
apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Pojdi na uporabnike
DocType: Pricing Rule,Item Code,Šifra artikla
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,'Opening',»Odpiranje«
DocType: Payment Entry,Set Exchange Gain / Loss,Set Exchange Gain / Loss
DocType: Accounts Settings,Make Payment via Journal Entry,Izvedite plačilo preko vnosa v dnevnik
DocType: Bank,Bank Transaction Mapping,Kartiranje bančnih transakcij
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,User has not applied rule on the invoice {0},Uporabnik ni uporabil pravila na računu {0}
apps/erpnext/erpnext/config/accounting.py,Payment Terms based on conditions,Plačilni pogoji na podlagi pogojev
DocType: Purchase Order,% Received,% Prejetih
DocType: Sales Order Item,Work Order Qty,Število delovnih nalogov
DocType: Job Card,WIP Warehouse,WIP skladišče
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 uporabnika ni nastavljen za zaposlenega {0}
apps/erpnext/erpnext/education/doctype/guardian/guardian.py,User {0} created,Uporabnik {0} je ustvarjen
DocType: Stock Settings,Item Naming By,Postavka poimenovanja
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js,Ordered,Naročeno
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,No communication found.,Ni sporočil.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/regional/india_list.js,Generate e-Way Bill JSON,Ustvari e-Way Bill JSON
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js,This is a root customer group and cannot be edited.,To je glavna skupina odjemalcev in je ni mogoče urejati.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Material Request {0} is cancelled or stopped,Zahteva za material {0} je preklicana ali ustavljena
DocType: Shift Type,Strictly based on Log Type in Employee Checkin,Strogo temelji na Log Type v službi Checkin
DocType: Purchase Order Item Supplied,Supplied Qty,Priložena količina
DocType: Cash Flow Mapper,Cash Flow Mapper,Kartiranje denarnih tokov
DocType: Soil Texture,Sand,Pesek
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Employee cannot report to himself.,Zaposleni se ne more prijaviti sam.
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_log/shopify_log.js,Order rescheduled for sync,Naročilo je preloženo za sinhronizacijo
apps/erpnext/erpnext/stock/doctype/item/item.py,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Privzeta merska enota za varianto &#39;{0}&#39; mora biti enaka kot v predlogi &#39;{1}&#39;
DocType: Blanket Order,Purchasing,Nakup
DocType: Driver,Cellphone Number,številka mobilnega telefona
DocType: Salary Slip,Gross Pay,Bruto plača
DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Paket cen hotelskih sob
DocType: Pricing Rule,Is Cumulative,Je kumulativno
apps/erpnext/erpnext/templates/pages/cart.html,Your cart is Empty,Vaš nakupovalni voziček je prazen
,Daily Timesheet Summary,Dnevni povzetek časovnega načrta
apps/erpnext/erpnext/quality_management/doctype/quality_procedure/quality_procedure_tree.js,New Quality Procedure,Novi postopek kakovosti
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Podizvajanje
DocType: Fee Schedule Program,Total Students,Skupaj študentov
apps/erpnext/erpnext/utilities/user_progress_utils.py,Local,Lokalno
DocType: Chapter Member,Leave Reason,Pusti razlog
DocType: Salary Component,Condition and Formula,Stanje in formula
DocType: Quality Goal,Objectives,Cilji
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.","Plača, ki je že obdelana za obdobje med {0} in {1}, obdobje zapustitve aplikacije ne more biti med tem časovnim obdobjem."
DocType: BOM Item,Basic Rate (Company Currency),Osnovna cena (valuta podjetja)
DocType: BOM Scrap Item,BOM Scrap Item,Postavka BOM Scrap
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Serial #,Serijska številka #
DocType: Activity Type,Default Billing Rate,Privzeta stopnja zaračunavanja
DocType: Vital Signs,Coated,Coated
DocType: Patient Appointment,More Info,Več informacij
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Bill of Materials,Račun za materiale
DocType: Purchase Invoice,Inter Company Invoice Reference,Referenca računa med podjetji
DocType: Crop Cycle,Cycle Type,Vrsta cikla
DocType: Employee Separation,Exit Interview Summary,Povzetek povzetka pogovora
,Item Variant Details,Postavka Varianta Podrobnosti
DocType: Contract,Partially Fulfilled,Delno izpolnjeno
DocType: Journal Entry,ACC-JV-.YYYY.-,ACC-JV-.YYYY.-
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,To {0},V {0}
DocType: GST Settings,GST Accounts,Računi GST
DocType: C-Form,Total Invoiced Amount,Skupni fakturirani znesek
DocType: Manufacturing Settings,Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order,Onemogoči izdelavo dnevnikov časa za delovne naloge. Operacije se ne smejo slediti delovnemu nalogu
apps/erpnext/erpnext/stock/utils.py,Group node warehouse is not allowed to select for transactions,Skladišče vozlišč skupine ni dovoljeno izbrati za transakcije
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Klic prekinjena
DocType: Subscriber,Subscriber Name,Ime naročnika
DocType: Purchase Order,Customer Mobile No,Mobilni telefon za stranke št
DocType: Bank Guarantee,Receiving,Sprejem
DocType: Account,Is Group,Je skupina
DocType: Healthcare Practitioner,Contacts and Address,Imenik in naslov
DocType: Warehouse,Warehouse Name,Ime skladišča
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as it is a Holiday.,"Prisotnost ni bila predložena za {0}, ker je praznik."
DocType: Leave Type,Rounding,Zaokroževanje
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Ineligible ITC,Neupravičen ITC
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,{0} created,Ustvarjeno je {0}
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,"Izberite vodjo banke, kjer je bil vplačan ček."
DocType: Service Level,Support and Resolution,Podpora in resolucija
DocType: Account,Bank,Banke
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Receive at Warehouse Entry,Prejemanje pri vstopu v skladišče
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Send Supplier Emails,Pošlji e-poštne naslove dobaviteljev
DocType: Lab Test Groups,Add new line,Dodaj novo vrstico
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate item group found in the item group table,Podvojena skupina postavk najdete v tabeli skupine postavk
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Annual Salary,Letna plača
DocType: Supplier Scorecard,Weighting Function,Funkcija uteževanja
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py,Error evaluating the criteria formula,Napaka pri ocenjevanju formule meril
,Lab Test Report,Poročilo o laboratorijskih testih
DocType: BOM,With Operations,Z operacijami
apps/erpnext/erpnext/utilities/user_progress.py,People who teach at your organisation,"Ljudje, ki poučujejo v vaši organizaciji"
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} does not belongs to company {1},Račun {0} ne pripada podjetju {1}
DocType: Item,Has Expiry Date,Ima datum poteka
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,Sum of Scores of Assessment Criteria needs to be {0}.,Vsota ocen meril za ocenjevanje mora biti {0}.
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Property already added,Lastnost je že dodana
DocType: Supplier,SUP-.YYYY.-,SUP-.YYYY.-
DocType: Expense Claim Account,Expense Claim Account,Račun zahtevkov za stroške
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments available for Journal Entry,Za vnos v dnevnik ni na voljo povračil
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} je neaktivna študentka
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Izdelava zaloge
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM recursion: {0} cannot be parent or child of {1},Ponovitev BOM: {0} ne more biti staršev ali otrok {1}
DocType: Employee Onboarding,Activities,Dejavnosti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Atleast one warehouse is mandatory,Vsaj eno skladišče je obvezno
,Customer Credit Balance,Stanje posojila strank
DocType: BOM,Operations,Operacije
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Create Salary Slips,Ustvarite vložke plač
,Monthly Attendance Sheet,Mesečni pregled udeležencev
DocType: Vital Signs,Reflexes,Refleksi
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,"Service Item,Type,frequency and expense amount are required","Postavka storitve, vrsta, pogostost in znesek stroškov so potrebni"
DocType: Supplier Scorecard Period,Variables,Spremenljivke
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Multiple Loyalty Program found for the Customer. Please select manually.,Na voljo je večkratni program zvestobe za naročnika. Izberite ročno.
DocType: Patient,Medication,Zdravila
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Select Loyalty Program,Izberite Program zvestobe
DocType: Employee Checkin,Attendance Marked,Udeleženci so bili označeni
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Raw Materials,Surovine
DocType: Sales Order,Fully Billed,Popolnoma zaračunan
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Please set Hotel Room Rate on {},"Prosimo, nastavite ceno hotelske sobe na {}"
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Select only one Priority as Default.,Izberite samo eno prioriteto kot privzeto.
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please identify/create Account (Ledger) for type - {0},Prepoznajte / ustvarite račun (Ledger) za vrsto - {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Total Credit/ Debit Amount should be same as linked Journal Entry,Skupni znesek kreditov / bremenitev mora biti enak kot povezava v dnevnik
DocType: Purchase Invoice Item,Is Fixed Asset,Je fiksno sredstvo
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Party Name,Ime stranke
apps/erpnext/erpnext/stock/doctype/item/item.js,This Item is a Variant of {0} (Template).,Ta postavka je različica {0} (Predloga).
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.,"To orodje vam pomaga posodobiti ali popraviti količino in vrednotenje zalog v sistemu. Običajno se uporablja za sinhronizacijo sistemskih vrednosti in tistega, kar dejansko obstaja v vaših skladiščih."
DocType: Cashier Closing,Net Amount,Neto znesek
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Selling Price List,Prodajni cenik
DocType: Amazon MWS Settings,IT,IT
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,{0} must be negative in return document,{0} mora biti negativen v povratnem dokumentu
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please select a valid Date,Izberite veljavni datum
DocType: Agriculture Task,End Day,Končni dan
apps/erpnext/erpnext/templates/emails/training_event.html,Please confirm once you have completed your training,"Potrdite, ko končate usposabljanje"
apps/erpnext/erpnext/utilities/user_progress.py,Go to Letterheads,Pojdite na pisma
DocType: Leave Block List Allow,Allow User,Dovoli uporabnika
DocType: Sales Order,% of materials delivered against this Sales Order,"% materialov, dostavljenih na podlagi tega prodajnega naloga"
DocType: Purpose of Travel,Purpose of Travel,Namen potovanja
DocType: Healthcare Settings,Appointment Confirmation,Potrditev dogovora
DocType: Shopping Cart Settings,Orders,Naročila
DocType: HR Settings,Retirement Age,Starost upokojitve
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Projected Qty,Predvidena količina
apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Brisanje ni dovoljeno za državo {0}
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} is already {2},Vrstica # {0}: Sredstvo {1} je že {2}
DocType: Delivery Note,Installation Status,Stanje namestitve
DocType: Item Attribute Value,Attribute Value,Vrednost atributa
DocType: Sales Invoice,Base Change Amount (Company Currency),Osnovni znesek spremembe (valuta podjetja)
DocType: Leave Allocation,Unused leaves,Neuporabljeni listi
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Finished Item {0} must be entered for Manufacture type entry,Končana postavka {0} mora biti vnesena za vnos vrste Izdelava
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,'Entries' cannot be empty,Vnosi ne smejo biti prazni
apps/erpnext/erpnext/utilities/user_progress.py,Go to Courses,Pojdi na Tečaje
DocType: Fee Schedule,Fee Breakup for each student,Fee Breakup za vsakega študenta
DocType: Item,Will also apply for variants,Velja tudi za variante
DocType: Shopify Settings,Shared secret,Skupno skrivnost
DocType: POS Profile,Write Off Cost Center,Napiši center stroškov
DocType: Soil Texture,Silty Clay,Silty Clay
DocType: Loyalty Point Entry Redemption,Redeemed Points,Unovčene točke
DocType: GoCardless Mandate,Mandate,Mandat
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Multiple,Ustvari več
DocType: Supplier Scorecard,Scoring Standings,Lestvica točkovanja
DocType: Support Search Source,Result Title Field,Polje z naslovom rezultata
DocType: Leave Allocation,New Leaves Allocated,Dodeljeni novi listi
DocType: Homepage,Homepage,Domača stran
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Compensatory Off,Kompenzacijski izklop
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices Summary,Odpiranje povzetka računov
DocType: Vehicle Service,Engine Oil,Motorno olje
DocType: Job Applicant,Applicant Name,Ime prijavitelja
DocType: Bank Transaction,Unreconciled,Neusklajeno
DocType: Serial No,Delivery Document No,Dokument o dostavi št
DocType: Hub Users,Hub Users,Uporabniki Hub
DocType: Bin,Actual Quantity,Dejanska količina
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Debit Note {0} has been created automatically,Debit Note {0} je ustvarjeno samodejno
DocType: Payment Term,Credit Days,Kreditni dnevi
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Id,ID projekta
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Electronics,Elektronika
apps/erpnext/erpnext/controllers/accounts_controller.py,Due Date is mandatory,Rok je obvezen
DocType: BOM Explosion Item,Qty Consumed Per Unit,Količina porabljene na enoto
,Completed Work Orders,Dokončana delovna naročila
DocType: Loyalty Program,Help Section,Oddelek za pomoč
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance date can not be less than employee's joining date,"Datum udeležbe ne sme biti krajši od datuma, ko se zaposleni pridruži"
DocType: BOM,Total Cost(Company Currency),Skupna cena (valuta podjetja)
DocType: Subscription,Net Total,Skupaj neto
DocType: Procedure Prescription,Referral,Napotitev
DocType: Vehicle,Model,Model
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Please specify from/to range,Navedite od / do območja
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Quantity to Manufacture must be greater than 0.,Količina za izdelavo mora biti večja od 0.
DocType: Maintenance Visit,Maintenance Time,Čas vzdrževanja
DocType: Asset,Naming Series,Naming Series
DocType: Contract,Contract Terms,Pogoji pogodbe
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,Either target qty or target amount is mandatory.,Ciljna ali ciljna količina je obvezna.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,Invalid {0},Neveljaven {0}
DocType: Item,FIFO,FIFO
DocType: Inpatient Record,HLC-INP-.YYYY.-,HLC-INP-.LLLL.-
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation cannot have more than 5 characters,Okrajšava ne sme imeti več kot 5 znakov
DocType: Employee Benefit Application,Max Benefits (Yearly),Največje ugodnosti (letno)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Create Material Request,Ustvari zahtevo za material
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js,Primary Address Details,Podrobnosti o primarnem naslovu
DocType: Project Template Task,Duration (Days),Trajanje (dnevi)
DocType: Customer Feedback Template Table,Customer Feedback Template Table,Tabela predlog za povratne informacije strank
DocType: Purchase Invoice Item,Price List Rate,Cenovni tečaj
DocType: Budget,Action if Annual Budget Exceeded on PO,Ukrep če letni proračun presega PO
DocType: POS Profile,Campaign,Kampanja
DocType: POS Profile,Accounting,Računovodstvo
DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Na tem območju določite proračune za skupino postavk. Sezonsko lahko vključite tudi z nastavitvijo Distribucije.
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Insurance Start date should be less than Insurance End date,Zavarovanje Začetni datum mora biti manjši od datuma zaključka zavarovanja
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items in progress,V teku je {0} elementov
DocType: Item,Foreign Trade Details,Podrobnosti zunanje trgovine
DocType: Quality Review Table,Yes/No,Da / Ne
DocType: Tally Migration,Is Master Data Imported,Ali so glavni podatki uvoženi
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,Vrstica davka na postavko {0} mora imeti račun vrste davka ali dohodka ali stroškov ali bremenitve
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} ni veljavna serijska številka za element {1}
apps/erpnext/erpnext/utilities/user_progress.py,Learn More,Nauči se več
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Credit Note {0} has been created automatically,Kreditna opomba {0} je ustvarjena samodejno
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,V čakalni vrsti za zamenjavo BOM. To lahko traja nekaj minut.
DocType: Lab Test,Result Date,Datum rezultata
apps/erpnext/erpnext/config/accounting.py,Currency exchange rate master.,Poveljnik menjalnega tečaja.
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js,Latest price updated in all BOMs,Najnovejša cena je posodobljena v vseh kosovnicah
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Series Updated Successfully,Serija je bila uspešno posodobljena
DocType: Soil Texture,Clay Loam,Clay Loam
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select item code,Izberite kodo postavke
apps/erpnext/erpnext/accounts/page/pos/pos.js,Default warehouse is required for selected item,Za izbrani element je potrebno privzeto skladišče
apps/erpnext/erpnext/stock/get_item_details.py,No Item with Serial No {0},Ni elementa s serijsko številko {0}
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,Party Type and Party is mandatory for {0} account,Vrsta stranke in stranka je obvezna za račun {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Accountant,Računovodja
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/pos_closing_voucher.py,POS Closing Voucher alreday exists for {0} between date {1} and {2},Vnaprejšnje potrdilo o zaključku bonusa POS obstaja za {0} med datumom {1} in {2}
apps/erpnext/erpnext/config/help.py,Navigating,Navigacija
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,No outstanding invoices require exchange rate revaluation,Nobeni odprti računi ne zahtevajo prevrednotenja deviznega tečaja
DocType: Authorization Rule,Customer / Item Name,Ime stranke / postavke
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,Nova serijska številka ne more imeti skladišča. Skladišče mora biti nastavljeno z vnosom delnic ali potrdilom o nakupu
DocType: Issue,Via Customer Portal,Preko portala za stranke
DocType: Work Order Operation,Planned Start Time,Načrtovani čas začetka
apps/erpnext/erpnext/controllers/buying_controller.py,{0} {1} is {2},{0} {1} je {2}
DocType: Service Level Priority,Service Level Priority,Prednostna raven storitve
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Število knjiženih amortizacij ne sme biti večje od skupnega števila amortizacij
apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js,Share Ledger,Skupna raba Ledger
DocType: Journal Entry,Accounts Payable,Obveznosti do dobaviteljev
DocType: Job Offer,Select Terms and Conditions,Izberite pogoje in pogoje
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Ends On date cannot be before Next Contact Date.,Konec na datum ne more biti pred naslednjim datumom stika.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Goods are already received against the outward entry {0},Blago je že prejeto proti izhodu {0}
DocType: Employee Tax Exemption Sub Category,Tax Exemption Category,Kategorija davčne oprostitve
DocType: Sales Invoice,Debit To,Debit To
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,"Selling must be checked, if Applicable For is selected as {0}","Prodaja mora biti preverjena, če je izbrana možnost Uporabljena za {0}"
DocType: Company,Date of Establishment,Datum ustanovitve
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Leave Type is madatory,Tip dopusta je ponosen
DocType: Sales Invoice,Sales Taxes and Charges Template,Predloga prodajnih davkov in pristojbin
DocType: Purchase Receipt,Return Against Purchase Receipt,Vrnitev proti potrdilu o nakupu
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Student Group: ,Študentska skupina:
DocType: Cheque Print Template,Cheque Size,Preverite velikost
,Consolidated Financial Statement,Konsolidirani računovodski izkazi
DocType: Cheque Print Template,Scanned Cheque,Skenirano preverjanje
DocType: Restaurant Reservation,Reservation End Time,Čas zaključka rezervacije
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,In Value,V vrednosti
DocType: Job Opening,Staffing Plan,Kadrovski načrt
DocType: Manufacturing Settings,Material Transferred for Manufacture,Preneseni material za proizvodnjo
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for manufacturing,Rezervirano za proizvodnjo
DocType: QuickBooks Migrator,Undeposited Funds Account,Račun nedodeljenih sredstev
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Material Request No,Zahteva za material št
DocType: Payment Reconciliation,Unreconciled Payment Details,Neusklajeni podatki o plačilu
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},Zahtevki za povpraševanje (RFQ) niso dovoljeni za {0} zaradi stanja kazalnikov rezultatov {1}
DocType: Bank Guarantee,Validity in Days,Veljavnost v dneh
DocType: Price List,Applicable for Countries,Velja za države
DocType: Supplier,Individual,Posameznik
DocType: Clinical Procedure Template,Clinical Procedure Template,Predloga kliničnega postopka
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Net Asset value as on,Neto vrednost sredstev kot na
DocType: Employee Group Table,ERPNext User ID,ID uporabnika ERPNext
DocType: Sales Invoice,Redemption Account,Račun za odkup
apps/erpnext/erpnext/config/buying.py,Tree of Item Groups.,Drevo skupin postavk.
DocType: BOM,Show Items,Prikaži elemente
DocType: Journal Entry,Paid Loan,Plačano posojilo
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Do you really want to scrap this asset?,Ali res želite zapisati to sredstvo?
DocType: Production Plan Sales Order,Sales Order Date,Datum prodajnega naloga
DocType: Workstation,Operating Costs,Stroški operacije
DocType: Supplier Quotation Item,Lead Time in days,Čas vodenja v dneh
DocType: Loan,Repay from Salary,Vračilo iz plače
DocType: Discounted Invoice,Discounted Invoice,Diskontirani račun
DocType: Leave Block List Allow,Leave Block List Allow,Pusti blokirani seznam Dovoli
DocType: Serial No,AMC Expiry Date,Datum izteka AMC
DocType: Asset,Number of Depreciations Booked,Število knjiženih amortizacij
DocType: Student Group Creation Tool,Student Group Creation Tool,Orodje za ustvarjanje študentskih skupin
,Purchase Order Items To Be Billed,"Postavke naročilnice, ki jih je treba zaračunati"
DocType: Leave Period,Holiday List for Optional Leave,Seznam dopustov za dopust
DocType: Purchase Invoice,Scan Barcode,Skeniraj črtno kodo
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Update Cost Center Number,Posodobi številko stroškovnega središča
DocType: Purchase Invoice Item,Service Start Date,Datum začetka storitve
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Furnitures and Fixtures,Pohištva in napeljave
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Criteria weights must add up to 100%,Uteži meril morajo biti do 100%
DocType: Authorization Rule,Average Discount,Povprečni popust
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Discount must be less than 100,Popust mora biti manjši od 100
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Accumulated Depreciation as on,Akumulirana amortizacija kot na
DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Ocena točkovanja dobavitelja Različica
DocType: Cheque Print Template,Message to show,Sporočilo za prikaz
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,No Students in,Št
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Accounts,Začasni računi
DocType: Invoice Discounting,Bank Charges,Bančne pristojbine
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods Transferred,Preneseno blago
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js,Primary Contact Details,Osnovni podatki za stik
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Incoming call from {0},Dohodni klic 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.","Če ni potrjeno, bo treba seznam dodati vsakemu oddelku, kjer ga je treba uporabiti."
DocType: Item Group,Show this slideshow at the top of the page,Prikaži to diaprojekcijo na vrhu strani
apps/erpnext/erpnext/support/doctype/issue/issue.py,{0} parameter is invalid,Parameter {0} ni veljaven
apps/erpnext/erpnext/templates/generators/bom.html,No description given,Ni opisa
DocType: Accounting Period,Closed Documents,Zaprti dokumenti
DocType: Project,Gross Margin,Bruto marža
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation Account,Račun prevrednotenja deviznega tečaja
DocType: Quotation,Quotation To,Ponudba Za
DocType: Bank Statement Settings Item,Bank Statement Settings Item,Postavka za nastavitev bančnega izpiska
DocType: Naming Series,Setup Series,Nastavitvena serija
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js,Reload Linked Analysis,Osveži povezano analizo
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Količina mora biti manjša ali enaka {0}
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Out Qty,Out Kol
DocType: Payment Request,Outward,Navzven
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Sales Orders in the above table,V zgornjo tabelo vnesite prodajne naročila
DocType: Invoice Discounting,Bank Charges Account,Račun bančnih stroškov
DocType: Journal Entry,Get Outstanding Invoices,Pridobite neporavnane račune
DocType: Opportunity,Opportunity From,Priložnost Od
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Target Details,Podrobnosti o cilju
DocType: Item,Customer Code,Koda stranke
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Please enter Item first,Najprej vnesite element
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Website Listing,Seznam spletnih mest
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! The input you've entered doesn't match the format of GSTIN.,Neveljaven GSTIN! Vneseni vnos se ne ujema z obliko GSTIN.
DocType: Item Reorder,Re-order Qty,Kol. Re-reda
DocType: Asset,Maintenance Required,Potrebno vzdrževanje
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Name,Ime dokumenta
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Lead Owner cannot be same as the Lead,Glavni lastnik ne more biti isti kot vodja
apps/erpnext/erpnext/config/accounting.py,"e.g. Bank, Cash, Credit Card","npr. Bank, Cash, Credit Card"
DocType: Item,Serial Number Series,Serijska številka
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Postal Expenses,Poštni stroški
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Management,Upravljanje
apps/erpnext/erpnext/config/retail.py,To view logs of Loyalty Points assigned to a Customer.,"Za ogled dnevnikov točk zvestobe, dodeljenih stranki."
DocType: Item,If subcontracted to a vendor,Če je pogodba oddana podizvajalcu
apps/erpnext/erpnext/templates/pages/help.html,Visit the forums,Obiščite forume
DocType: C-Form,C-Form,C-obrazec
DocType: Asset Maintenance,Maintenance Team,Ekipa za vzdrževanje
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Half day Leave on {1},{0} ob pol dnevu zapusti {1}
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,Combined invoice portion must equal 100%,Del kombiniranega računa mora biti enak 100%
DocType: Patient,Occupational Hazards and Environmental Factors,Delovne nevarnosti in okoljski dejavniki
DocType: Volunteer,Volunteer,Prostovoljec
DocType: Lab Test,Custom Result,Rezultat po meri
DocType: Issue,Opening Date,Datum odprtja
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,The selected BOMs are not for the same item,Izbrane BOM-i niso za isto postavko
DocType: Delivery Note,Delivery To,Dostava v
DocType: Communication Medium,Timeslots,Timeslots
DocType: Bank Statement Transaction Settings Item,Bank Data,Bančni podatki
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js,Scheduled Upto,Načrtovano Upto
apps/erpnext/erpnext/config/crm.py,Track Leads by Lead Source.,Pot vodi po vodilnem viru.
DocType: Clinical Procedure,Nursing User,Uporabnik zdravstvene nege
DocType: Support Settings,Response Key List,Seznam ključnih odgovorov
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Based On,Staranje na osnovi
apps/erpnext/erpnext/stock/doctype/item/item.js,Balance,Ravnovesje
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,"Skladišče, kjer vzdržujete zaloge zavrnjenih predmetov"
apps/erpnext/erpnext/public/js/setup_wizard.js,Retail,Maloprodaja
DocType: Call Log,Missed,Pogrešano
,Maintenance Schedules,Načrti vzdrževanja
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cannot convert Cost Center to ledger as it has child nodes,"Stroškovnega središča ni mogoče pretvoriti v knjigo knjig, saj ima otroška vozlišča"
apps/erpnext/erpnext/controllers/item_variant.py,Please specify at least one attribute in the Attributes table,V tabeli Atributi navedite vsaj en atribut
DocType: Company,Create Chart Of Accounts Based On,Ustvarite grafikon računov na podlagi
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Pred preklicem tega prodajnega naloga morate preklicati račun za prodajo {0}
DocType: Item,Default Purchase Unit of Measure,Privzeta merska enota za nakup
DocType: Location,Location Details,Podrobnosti o lokaciji
DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Osnovna stopnja (glede na zalogo UOM)
DocType: Travel Request Costing,Travel Request Costing,Strošek zahteve za potovanje
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Sales Invoice,Ustvarite račun za prodajo
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py,From Time cannot be greater than To Time.,Iz časa ne more biti več kot čas.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js,To Date cannot be less than From Date,Datum ne more biti krajši od datuma
apps/erpnext/erpnext/config/crm.py,Manage Territory Tree.,Upravljanje drevesa ozemlja.
DocType: GL Entry,Voucher Type,Vrsta bonov
,Serial No Service Contract Expiry,Zaporedna št
DocType: Certification Application,Certified,Certified
DocType: Purchase Invoice Item,Manufacture,Izdelava
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items produced,Izdelanih je bilo {0} elementov
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Request for {0},Zahteva za plačilo za {0}
apps/erpnext/erpnext/accounts/report/inactive_sales_items/inactive_sales_items.js,Days Since Last Order,Dnevi od zadnjega naročila
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please set default Cash or Bank account in Mode of Payment {0},Nastavite privzeti račun za gotovino ali bančni račun v načinu plačila {0}
DocType: Student Group,Instructors,Inštruktorji
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","Za uporabnike lahko te kode uporabljate v tiskanih oblikah, kot so računi in dobavnice"
DocType: Amazon MWS Settings,Enable Amazon,Omogoči Amazon
DocType: Loan,Total Interest Payable,Celotna zapadla obresti
DocType: Topic,Topic Content,Vsebina teme
DocType: Bank Account,Integration ID,ID integracije
DocType: Sales Invoice,Company Address Name,Ime naslova podjetja
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods In Transit,Blago v tranzitu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,You can only redeem max {0} points in this order.,V tem vrstnem redu lahko unovčite največ {0} točk.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please set account in Warehouse {0},Nastavite račun v skladišču {0}
DocType: Quality Action,Resolution,Resolucija
DocType: Sales Invoice,Loyalty Points Redemption,Odkup točk zvestobe
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Total Taxable Value,Skupna davčna vrednost
DocType: Patient Appointment,Scheduled,Načrtovano
DocType: Sales Partner,Partner Type,Vrsta partnerja
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of services,Uvoz storitev
DocType: Employee Education,School/University,Šola / univerza
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}: UOM Conversion Factor is mandatory,Vrstica {0}: faktor konverzije UOM je obvezen
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Reference No.,Referenčna številka
DocType: Work Order,Additional Operating Cost,Dodatni obratovalni stroški
DocType: Loyalty Program Collection,Collection Factor (=1 LP),Faktor zbiranja (= 1 LP)
DocType: Serial No,Delivery Document Type,Vrsta dokumenta dostave
DocType: Products Settings,Attributes,Lastnosti
DocType: Bank Guarantee,Bank Guarantee,Bančna garancija
DocType: Territory,Territory Name,Ime ozemlja
DocType: Item Price,Minimum Qty ,Najmanjša količina
DocType: Supplier Scorecard,Per Week,Tedensko
DocType: Supplier Scorecard,Warn for new Request for Quotations,Opozori na novo zahtevo za ponudbo
DocType: Account,Tax,Davek
DocType: Delivery Stop,Visited,Obiskano
DocType: Loyalty Program,Auto Opt In (For all customers),Samodejna izbira (za vse stranke)
DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,"Stopnja, pri kateri se valuta stranke pretvori v osnovno valuto stranke"
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is an Individual or a Proprietorship,"Velja, če je podjetje posameznik ali lastnik"
DocType: Restaurant,Restaurant,Restavracija
DocType: Delivery Stop,Address Name,Ime naslova
DocType: Employee Promotion,Employee Promotion,Promocija zaposlenih
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments selected for Journal Entry,Za vnos v dnevnik ni izbranih vračil
DocType: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,"Nastavi vrednost fakture za B2C. B2CL in B2CS, izračunani na podlagi te fakturne vrednosti."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',"Ne morem odbiti, če je kategorija za »Vrednotenje« ali »Vaulation in Total«"
DocType: Quality Goal,Revised On,Revidirano On
apps/erpnext/erpnext/healthcare/utils.py,The item referenced by {0} - {1} is already invoiced,"Element, na katerega se sklicuje {0} - {1}, je že zaračunan"
DocType: Driver,Suspended,Odloženo
DocType: Asset Category Account,Accumulated Depreciation Account,Račun akumulirane amortizacije
DocType: Journal Entry Account,Credit in Company Currency,Kredit v valuti podjetja
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Entertainment & Leisure,Zabava in prosti čas
DocType: Email Digest,New Sales Invoice,Nov račun za prodajo
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Net Profit,Čisti dobiček
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,Another Sales Person {0} exists with the same Employee id,Druga prodajna oseba {0} obstaja z istim ID-jem zaposlenega
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Closing (Dr),Zapiranje (Dr)
DocType: Loyalty Point Entry,Loyalty Program Tier,Program zvestobe Raven
DocType: Purchase Invoice,Total Taxes and Charges,Skupni davki in pristojbine
DocType: Amazon MWS Settings,JP,JP
DocType: Work Order Operation,Operation Description,Opis delovanja
DocType: Bank Statement Transaction Entry,Bank Transaction Entries,Vpisi bančnih transakcij
DocType: HR Settings,Leave Approval Notification Template,Zapusti predlogo obvestila o odobritvi
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Vrsta dokumenta
DocType: Email Digest,New Purchase Invoice,Novi račun za nakup
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Requested Qty: Quantity requested for purchase, but not ordered.","Zahtevana količina: Količina, zahtevana za nakup, vendar ne naročena."
DocType: Purchase Invoice,Supplier Name,ime dobavitelja
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Kliknite »Ustvari razpored«, če želite prenesti serijsko številko, ki je dodana za element {0}"
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Delivered Items,Stroški dobavljenih postavk
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Consumed,Potrošen
DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Pravna oseba / hčerinska družba z ločenim kontnim načrtom organizacije.
DocType: BOM,Show In Website,Prikaži na spletni strani
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.","Nato se pravila za določanje cen filtrirajo na podlagi stranke, skupine strank, ozemlja, dobavitelja, vrste dobavitelja, oglaševalske akcije, prodajnega partnerja itd."
DocType: Payment Request,Payment Request Type,Vrsta zahtevka za plačilo
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field To Shareholder cannot be blank,Polje Za delničarja ne sme biti prazno
DocType: QuickBooks Migrator,QuickBooks Migrator,Migrator QuickBooks
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,POS Profile is required to use Point-of-Sale,Za uporabo Point-of-Sale je potreben profil POS
DocType: Purchase Order,Purchase Order Pricing Rule,Pravilo o določanju cen naročil
DocType: Expense Claim,Expenses,Stroški
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.js,Bank accounts added,Dodani bančni računi
DocType: Employee,Cheque,Preveri
DocType: Purchase Invoice,Currency and Price List,Valuta in cenik
DocType: Shopify Settings,Shop URL,Trgovina URL
DocType: Asset Movement,Source Location,Lokacija vira
apps/erpnext/erpnext/accounts/page/pos/pos.js,Enter value must be positive,Vnesite vrednost mora biti pozitivna
DocType: Accounts Settings,Allow Cost Center In Entry of Balance Sheet Account,Dovoli stroškovno mesto v vnosu računa bilance stanja
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js,Attendance,Prisotnost
DocType: Training Event,Internet,Internet
DocType: Monthly Distribution,Monthly Distribution Percentages,Odstotki mesečne porazdelitve
DocType: Delivery Settings,Dispatch Notification Template,Predloga za pošiljanje obvestil
apps/erpnext/erpnext/templates/print_formats/includes/total.html,Total (Without Tax),Skupaj (brez davka)
DocType: Cash Flow Mapping,Cash Flow Mapping,Kartiranje denarnega toka
DocType: Patient Encounter,HLC-ENC-.YYYY.-,HLC-ENC-.LLLL.-
DocType: Cash Flow Mapper,Section Leader,Vodja oddelka
,Budget Variance Report,Poročilo o varianci proračuna
DocType: Asset,Gross Purchase Amount,Bruto znesek nakupa
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date is mandatory,Pol dneva je obvezen
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Removed items with no change in quantity or value.,Odstranjeni predmeti brez spremembe količine ali vrednosti.
DocType: Loan,Applicant Type,Tip prijavitelja
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 2,V naslov 2
DocType: Purchase Receipt,Range,Območje
DocType: Budget,BUDGET,PRORAČUN
DocType: Journal Entry,Depreciation Entry,Vnos amortizacije
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Cenovni tečaj (Valuta podjetja)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Not Paid and Not Delivered,Ni plačano in ni dostavljeno
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Sales Invoice {0} created,Ustvarjen je bil račun za prodajo {0}
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() failed for empty IBAN,BankAccount.validate_iban () ni uspel za prazen IBAN
DocType: Quality Review Table,Objective,Cilj
DocType: Inpatient Record,Admission Scheduled,Vstop je načrtovan
DocType: Purchase Order Item,To be delivered to customer,Za dostavo kupcu
DocType: Attendance Request,On Duty,Na dolžnosti
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Variable,Spremenljivka
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Row {0}: Depreciation Start Date is required,Vrstica {0}: potreben je začetni datum amortizacije
DocType: Options,Option,Možnost
DocType: Healthcare Settings,Out Patient SMS Alerts,Opozorila o bolnikovih SMS sporočilih
apps/erpnext/erpnext/setup/doctype/company/company.py,Sales Account,Prodajni račun
DocType: Weather,Weather Parameter,Vremenski parameter
DocType: Leave Control Panel,Allocate,Dodeli
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Podroben načrt vzdrževanja
DocType: BOM Update Tool,BOM Update Tool,Orodje za posodobitev BOM-a
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Notice Period,Obdobje obvestil
,Lead Owner Efficiency,Učinkovitost vodilnega podjetja
DocType: SMS Center,Total Characters,Skupno število znakov
DocType: Patient,Alcohol Past Use,Alkohol v preteklosti
DocType: Patient,Divorced,Ločen
DocType: Sales Invoice,Allocate Advances Automatically (FIFO),Samodejno dodeljevanje predplačil (FIFO)
DocType: Leave Type,Is Compensatory,Je kompenzacijska
,Employees working on a holiday,Zaposleni na počitnicah
DocType: Healthcare Practitioner,Mobile,Mobile
apps/erpnext/erpnext/utilities/activation.py,"Timesheets help keep track of time, cost and billing for activites done by your team","Časovni listi pomagajo spremljati čas, stroške in zaračunavanje storitev, ki jih opravi vaša ekipa"
DocType: Delivery Stop,Order Information,Informacije o naročilu
apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Vmesni seštevek
DocType: Invoice Discounting,Invoice Discounting,Račun za popust
apps/erpnext/erpnext/regional/italy/utils.py,Nos,Št
DocType: Stock Settings,Freeze Stock Entries,Vnosi za zamrznitev zaloge
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Item {0} not found,Element {0} ni bil najden
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,You have entered duplicate items. Please rectify and try again.,Vnesli ste podvojene elemente. Popravite in poskusite znova.
DocType: Purchase Invoice Item,Rate,Oceniti
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.py,Saving {0},Shranjevanje {0}
DocType: SMS Center,Total Message(s),Skupno število sporočil:
DocType: Purchase Invoice,Accounting Dimensions,Računovodske dimenzije
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Account,Združi po računu
DocType: Quotation,In Words will be visible once you save the Quotation.,"V besedi bo viden, ko shranite ponudbo."
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js,Quantity to Produce,Količina za proizvodnjo
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,"Vrstica # {0}: Ni mogoče nastaviti stopnje, če je znesek višji od obračunanega zneska za element {1}."
DocType: Work Order Operation,Actual Start Time,Dejanski čas začetka
DocType: Antibiotic,Laboratory User,Uporabnik laboratorija
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Online Auctions,Spletne dražbe
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Priority {0} has been repeated.,Prednost {0} je bila ponovljena.
DocType: Fee Schedule,Fee Creation Status,Stanje ustvarjanja pristojbin
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Softwares,Programska oprema
apps/erpnext/erpnext/config/help.py,Sales Order to Payment,Prodajni nalog za plačilo
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,This is based on transactions against this Healthcare Practitioner.,To temelji na transakcijah z zdravstvenim delavcem.
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Assigning Structures...,Dodeljevanje struktur ...
apps/erpnext/erpnext/config/manufacturing.py,Details of the operations carried out.,Podrobnosti o izvedenih operacijah.
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Transactions already retreived from the statement,"Transakcije, ki so bile že izvzete iz izjave"
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Operation Time must be greater than 0 for Operation {0},Čas delovanja mora biti večji od 0 za delovanje {0}
apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Preizkus mora imeti vsaj eno pravilno možnost
DocType: Shareholder,Folio no.,Folio no.
DocType: Inpatient Record,A Negative,Negativen
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} is mandatory for Item {1},{0} je obvezna za element {1}
,Production Analytics,Analytics proizvodnje
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Set Supplier for item {1},Vrstica # {0}: nastavite dobavitelja za element {1}
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter_dashboard.py,Records,Zapisi
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Automatic Reconciliation,Samodejno usklajevanje
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Case No(s) already in use. Try from Case No {0},"Št. Primerov, ki se že uporabljajo. Poskusite z zadevo št. {0}"
DocType: Chapter Member,Website URL,naslov spletne strani
apps/erpnext/erpnext/accounts/doctype/account/account.py,Report Type is mandatory,Vrsta poročila je obvezna
DocType: Vehicle,Policy No,Politika št
apps/erpnext/erpnext/hr/report/daily_work_summary_replies/daily_work_summary_replies.py,Replies,Odgovorov
DocType: Supplier Scorecard Scoring Variable,Variable Name,Ime spremenljivke
DocType: Rename Tool,Utilities,Pripomočki
DocType: Job Card,Total Completed Qty,Skupno dopolnjeno število
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials to Manufacture,Ni elementov z gradivom za izdelavo
DocType: Purchase Order Item,Blanket Order Rate,Splošna stopnja naročila
DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Spremljajte ločene prihodke in izdatke za vertikale ali delitve izdelkov.
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid SSL certificate on attachment {0},Opozorilo: neveljavno potrdilo SSL o prilogi {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,Kot izpraševalec
DocType: Company,Default Expense Claim Payable Account,Račun plačila terjatev za privzete stroške
DocType: Additional Salary,HR-ADS-.YY.-.MM.-,HR-ADS-.YY .-. MM.-
apps/erpnext/erpnext/templates/pages/search_help.py,Docs Search,Iskanje dokumentov
apps/erpnext/erpnext/hr/doctype/payroll_period/payroll_period.py,End Date can not be less than Start Date,Datum konca ne sme biti krajši od začetnega datuma
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials.,Ni elementov z gradivom.
apps/erpnext/erpnext/config/support.py,Single unit of an Item.,Posamezna enota postavke.
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Quotations,Ponudbe
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Could not generate Secret,Secreta ni bilo mogoče ustvariti
DocType: Purchase Taxes and Charges,Valuation and Total,Vrednotenje in Skupaj
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Member Activity,Dejavnost članov
DocType: Upload Attendance,Import Attendance,Prisotnost pri uvozu
DocType: POS Profile,Account for Change Amount,Račun za znesek spremembe
,Item Price Stock,Cena na zalogi
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.",Zahteva za ponudbo je onemogočena za dostop do portala za več nastavitev portala.
DocType: Bank Statement Settings Item,Mapped Header,Kartirano glavo
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,"Item Code, warehouse, quantity are required on row","Šifra artikla, skladišče, količina je potrebna v vrstici"
DocType: Payment Order Reference,Bank Account Details,Podrobnosti bančnega računa
DocType: Homepage,Homepage Slideshow,Domača stran Slideshow
apps/erpnext/erpnext/templates/includes/product_page.js,Cannot find a matching Item. Please select some other value for {0}.,Ne najdem ujemajočega elementa. Izberite drugo vrednost za {0}.
DocType: Travel Request,"Partially Sponsored, Require Partial Funding","Delno sponzorirane, zahtevati delno financiranje"
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Payment of {0} from {1} to {2},Plačilo v višini {0} od {1} do {2}
,Serial No Status,Stanje brez zaporedne številke
DocType: Donor,Donor,Darovalec
DocType: BOM,Item UOM,Postavka UOM
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Vrstica {0}: izberite delovno postajo proti operaciji {1}
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py,{0} must be submitted,Predložiti je treba {0}
DocType: Project,Estimated Cost,Ocenjeni stroški
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot/Lead %,Quot / Lead%
DocType: Bank Account,Last Integration Date,Zadnji datum integracije
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Search for a payment,Poiščite plačilo
apps/erpnext/erpnext/config/non_profit.py,Member information.,Informacije o članih.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Vnos reverznega dnevnika
apps/erpnext/erpnext/utilities/user_progress.py,Set a sales goal you'd like to achieve for your company.,"Nastavite cilj prodaje, ki ga želite doseči za vaše podjetje."
DocType: Lab Test Template,Special,Poseben
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Subcontract: Raw materials quantity to make subcotracted items.,Rezervirana količina za podizvajalce: količina surovin za izdelavo subkupiranih postavk.
DocType: Patient Encounter,In print,V tisku
apps/erpnext/erpnext/accounts/report/financial_statements.py,Could not retrieve information for {0}.,Podatkov za {0} ni bilo mogoče pridobiti.
apps/erpnext/erpnext/accounts/party.py,Billing currency must be equal to either default company's currency or party account currency,Valuta za obračun mora biti enaka privzeti valuti podjetja ali valuti računa stranke
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js,Please enter Employee Id of this sales person,Vnesite ID zaposlenega te prodajne osebe
DocType: Shift Type,Early Exit Consequence after,Zgodnja izstopna posledica
apps/erpnext/erpnext/config/getting_started.py,Create Opening Sales and Purchase Invoices,Ustvarite odprte račune za prodajo in nakup
DocType: Disease,Treatment Period,Obdobje zdravljenja
apps/erpnext/erpnext/config/settings.py,Setting up Email,Nastavitev e-pošte
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Debit Note Amount,Znesek plačila v breme
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Stopnja, po kateri se valuta Cenika pretvori v osnovno valuto stranke"
apps/erpnext/erpnext/hooks.py,Certification,Certificiranje
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Tukaj lahko vzdržujete višino, težo, alergije, zdravstvene težave itd"
DocType: Journal Entry,Print Heading,Naslov za tiskanje
DocType: Grant Application,Withdrawn,Umaknjeno
apps/erpnext/erpnext/public/js/utils/party.js,Select company first,Najprej izberite podjetje
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Application period cannot be across two allocation records,Obdobje uporabe ne more biti v dveh zapisih o dodelitvi
apps/erpnext/erpnext/templates/pages/order.html,Rate:,Oceniti:
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Employee {0} has no maximum benefit amount,Zaposleni {0} nima najvišjega zneska nadomestila
DocType: Employee Skill Map,Employee Skills,Spretnosti zaposlenih
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Name: ,Študentsko ime:
DocType: SMS Log,Sent On,Poslano vklopljeno
DocType: Bank Statement Transaction Invoice Item,Sales Invoice,Prodajni račun
DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.","Za študentsko skupino, ki temelji na predmetu, bo tečaj potrjen za vsakega študenta iz vpisanih tečajev v programu za vpis."
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Intra-State Supplies,Dobave znotraj države
DocType: Employee,Create User Permission,Ustvari uporabniško dovoljenje
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Please save the report again to rebuild or update,Znova shranite poročilo za ponovno izdelavo ali posodobitev
DocType: C-Form Invoice Detail,Territory,Ozemlje
DocType: C-Form,Quarter,Četrtletje
DocType: Purchase Invoice,Grand Total (Company Currency),Skupna vsota (valuta podjetja)
DocType: Prescription Dosage,Prescription Dosage,Odmerek na recept
DocType: Salary Slip,Hour Rate,Hour Rate
DocType: Location,Latitude,Zemljepisna širina
DocType: Expense Claim Detail,Expense Date,Datum izdatka
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show Payment Details,Prikaži podrobnosti plačila
DocType: Company,Default Payable Account,Privzeti plačljivi račun
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to any Warehouse,Zaporedna št. {0} ne pripada nobenemu skladišču
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Party,Skupina pogodbenice
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,Izmenjava dobička / izgube
DocType: Payment Request,Make Sales Invoice,Naredite račun za prodajo
DocType: Opening Invoice Creation Tool,Create Missing Party,Ustvari manjkajočo stranko
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For quantity {0} should not be grater than work order quantity {1},Za količino {0} ne bi smeli biti večje od količine naročila {1}
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,{0}: {1} must be less than {2},{0}: {1} mora biti manjša od {2}
DocType: Landed Cost Voucher,Additional Charges,Dodatni stroški
DocType: Assessment Result Tool,Assessment Result Tool,Orodje za oceno rezultatov
DocType: Journal Entry,Contra Entry,Contra Entry
DocType: Student Applicant,Application Status,Stanje aplikacije
DocType: Journal Entry,Total Amount in Words,Skupni znesek v besedah
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment. ","Spremljajte prodajne akcije. Spremljajte vodnike, ponudbe, prodajno naročilo itd iz oglaševalskih akcij, da bi ocenili donosnost naložb."
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Missing Currency Exchange Rates for {0},Manjkajoči menjalni tečaji za {0}
DocType: Pricing Rule Item Group,Pricing Rule Item Group,Skupina elementov za določanje cen
DocType: Quality Inspection Reading,Reading 8,Branje 8
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,From Fiscal Year,Od fiskalnega leta
DocType: Tally Migration,Tally Creditors Account,Račun upnikov
DocType: Student Report Generation Tool,Print Section,Odsek za tiskanje
apps/erpnext/erpnext/hr/doctype/department/department.js,This is a root department and cannot be edited.,To je korenski oddelek in ga ni mogoče urejati.
,Project Quantity,Projektna količina
apps/erpnext/erpnext/config/settings.py,Standard contract terms for Sales or Purchase.,Standardni pogodbeni pogoji za prodajo ali nakup.
DocType: Sales Invoice,Customer PO Details,Podrobnosti o stranki naročnika
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Patient not found,Bolnika ni mogoče najti
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Select a Default Priority.,Izberite privzeto prednost.
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Remove item if charges is not applicable to that item,"Odstranite element, če se stroški ne nanašajo na ta element"
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 strank obstaja z istim imenom. Prosimo, spremenite ime stranke ali preimenujete skupino kupcev"
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.","Standardna davčna predloga, ki jo lahko uporabite za vse prodajne transakcije. Ta predloga lahko vsebuje seznam davčnih glav in tudi drugih glav porabe / prihodkov, kot so &quot;Shipping&quot;, &quot;Insurance&quot;, &quot;Handling&quot; itd. #### Opomba Tukaj določena davčna stopnja bo standardna davčna stopnja za vse ** Postavke **. Če obstajajo ** postavke **, ki imajo različne stopnje, jih je treba dodati v tabelo ** Item Tax ** v glavnem elementu ** Item **. #### Opis stolpcev 1. Vrsta izračuna: - To je lahko na ** Neto Skupaj ** (to je vsota osnovnega zneska). - ** Na prejšnji vrstici Skupaj / znesek ** (za kumulativne davke ali stroške). Če izberete to možnost, se bo davek uporabljal kot odstotek od prejšnje vrstice (v davčni tabeli) ali skupnega zneska. - ** Dejansko ** (kot je navedeno). 2. Vodja računa: Knjigovodska knjiga, po kateri bo ta davek knjižen. 3. Stroškovno mesto: Če je davek / davek dohodek (kot je ladijski promet) ali strošek, ga je treba knjižiti na stroškovnem mestu. 4. Opis: Opis davka (ki bo natisnjen v računih / ponudbah). 5. Stopnja: Stopnja davka. 6. Znesek: Znesek davka. 7. Skupaj: Kumulativna vsota do te točke. 8. Vnesite vrstico: Če na podlagi &quot;Prejšnja vrstica skupaj&quot; izberete številko vrstice, ki bo vzeta kot osnova za ta izračun (privzeta je prejšnja vrstica). 9. Ali je ta davek vključen v osnovni tečaj ?: Če to preverite, to pomeni, da ta davek ne bo prikazan pod tabelo postavk, ampak bo vključen v osnovno stopnjo v vaši glavni tabeli postavk. To je uporabno tam, kjer želite strankam ponuditi ceno (vključno z vsemi davki)."
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,To Date must be greater than From Date,Datum mora biti večji od datuma
DocType: Customer Group,Parent Customer Group,Skupina matičnih strank
DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,"Cene ne bodo prikazane, če cenik ni nastavljen"
apps/erpnext/erpnext/config/settings.py,ERPNext Settings,Nastavitve ERPNext
apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Časovni list za proizvodnjo.
DocType: Student Language,Student Language,Študentski jezik
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Payment Schedule,Nastavite urnik plačil
DocType: Travel Request,Name of Organizer,Ime organizatorja
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Nastavite račune za amortizacijo v kategoriji sredstev {0} ali Podjetje {1}
apps/erpnext/erpnext/config/accounting.py,Setup cheque dimensions for printing,Nastavitev preveri dimenzije za tiskanje
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,"If you have any questions, please get back to us.","Če imate kakršnakoli vprašanja, nam prosim odgovorite."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Purchase Receipt {0} is not submitted,Potrdilo o nakupu {0} ni poslano
DocType: Task,Total Expense Claim (via Expense Claim),Skupni zahtevek za stroške (prek zahtevka za stroške)
DocType: Quality Goal,Quality Goal,Cilj kakovosti
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,{0} bank transaction(s) created,Izdelanih je bilo {0} bančnih transakcij
DocType: Support Settings,Support Portal,Portal za podporo
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} is on Leave on {1},Zaposleni {0} je zapustil na {1}
apps/erpnext/erpnext/support/doctype/issue/issue.py,This Service Level Agreement is specific to Customer {0},Ta sporazum o ravni storitev je specifičen za stranko {0}
DocType: Employee,Held On,Held On
DocType: Healthcare Practitioner,Practitioner Schedules,Seznami zdravilcev
DocType: Project Template Task,Begin On (Days),Začni dne (dneve)
DocType: Production Plan,"If enabled, then system will create the material even if the raw materials are available","Če je omogočeno, bo sistem ustvaril material, tudi če so surovine na voljo"
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work Order has been {0},Delovni nalog je bil {0}
DocType: Inpatient Record,Admission Schedule Date,Datum vpisa
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Value Adjustment,Prilagoditev vrednosti sredstev
DocType: Exotel Settings,Account SID,Račun SID
DocType: Shift Type,Mark attendance based on 'Employee Checkin' for Employees assigned to this shift.,"Označite prisotnost na podlagi &#39;Preverjanje zaposlenih&#39; za zaposlene, ki so dodeljeni tej izmeni."
apps/erpnext/erpnext/regional/india/utils.py,GST HSN Code does not exist for one or more items,Koda GST HSN ne obstaja za enega ali več elementov
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to Unregistered Persons,Dobave za neregistrirane osebe
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,All Jobs,Vsa delovna mesta
DocType: Appointment Type,Appointment Type,Vrsta sestanka
DocType: Manufacturing Settings,Allow Overtime,Dovoli nadure
DocType: Sales Invoice Item,Available Qty at Warehouse,Na voljo Qty at Warehouse
DocType: Sales Invoice Item,Sales Invoice Item,Postavka računa za prodajo
DocType: Additional Salary,HR,HR
DocType: Student Report Generation Tool,Assessment Terms,Pogoji ocenjevanja
apps/erpnext/erpnext/controllers/item_variant.py,Increment for Attribute {0} cannot be 0,Povečanje za atribut {0} ne more biti 0
DocType: Leave Control Panel,Carry Forward,Prenesi naprej
DocType: Dependent Task,Dependent Task,Odvisna naloga
apps/erpnext/erpnext/support/doctype/issue/issue.py,Priority has been changed to {0}.,Prednost je bila spremenjena v {0}.
DocType: Allowed To Transact With,Allowed To Transact With,Dovoljeno za transakcijo z
apps/erpnext/erpnext/public/js/hub/marketplace.js,Become a Seller,Postanite prodajalec
DocType: Bank Reconciliation,Bank Reconciliation,Usklajevanje bank
apps/erpnext/erpnext/config/projects.py,Types of activities for Time Logs,Vrste dejavnosti za dnevnike časa
DocType: POS Closing Voucher Invoices,POS Closing Voucher Invoices,Računi za zaključevanje potrdil za POS-plačila
DocType: Inpatient Record,AB Negative,AB Negativen
DocType: Company,Budget Detail,Podrobnosti o proračunu
DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Običajen referenčni razpon za odraslega je 16-20 vdihov / minuto (RCP 2012)
DocType: Production Plan,Sales Orders,Prodajni nalogi
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Create Journal Entry,Ustvari vnos v dnevnik
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Zavarovana posojila
DocType: Share Transfer,To Shareholder,Za delničarja
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Maintenance Schedule,Urnik vzdrževanja
DocType: Chapter,"chapters/chapter_name
leave blank automatically set after saving chapter.",poglavja / chapter_name pustite prazno samodejno nastavljeno po shranjevanju poglavja.
DocType: Shopping Cart Settings,Payment Success Url,URL uspešnosti plačila
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Dostavljeni znesek
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Min Amt can not be greater than Max Amt,Min Amt ne sme biti večji od Max Amt
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Salary Structure not found for employee {0} and date {1},Struktura plače ni bila najdena za zaposlene {0} in datum {1}
DocType: Healthcare Settings,Invoice Appointments Automatically,Imenovanja računa so samodejno
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js,Please fill in all the details to generate Assessment Result.,"Prosimo, izpolnite vse podrobnosti za ustvarjanje rezultatov ocenjevanja."
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Variance ({}),Varianca ({})
DocType: Healthcare Settings,Patient Name,Ime bolnika
apps/erpnext/erpnext/public/js/setup_wizard.js,Your Organization,Vaša organizacija
DocType: Contract,Fulfilment Details,Podrobnosti o izpolnjevanju
DocType: Project,Total Billed Amount (via Sales Invoices),Skupni znesek obračuna (prek računov za prodajo)
apps/erpnext/erpnext/utilities/user_progress.py,Kg,Kg
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Appointment cancelled,Dogovor je bil preklican
DocType: Healthcare Settings,Reminder Message,Opomnik
DocType: Repayment Schedule,Balance Loan Amount,Znesek bilančnega posojila
apps/erpnext/erpnext/config/crm.py,Manage Sales Person Tree.,Upravljanje drevesa prodajnih oseb.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,There are more holidays than working days this month.,V tem mesecu je več počitnic kot delovnih dni.
DocType: Item,Default BOM,Privzeta BOM
DocType: BOM,Operating Cost (Company Currency),Obratovalni stroški (valuta podjetja)
DocType: Item Price,Item Price,Cena izdelka
DocType: Payment Entry,Party Name,Ime stranke
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select a customer,Izberite stranko
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",Število novega stroškovnega mesta bo vključeno v ime stroškovnega mesta kot predpona
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Select the customer or supplier.,Izberite stranko ali dobavitelja.
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Valid till date cannot be before transaction date,Veljavno do datuma ne more biti pred datumom transakcije
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Cannot deactivate or cancel BOM as it is linked with other BOMs,"BOM ni mogoče deaktivirati ali preklicati, ker je povezana z drugimi BOM"
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Place Of Supply (State/UT),Kraj dobave (država / UT)
DocType: Job Opening,Job Title,Naslov dela
DocType: Fee Component,Fee Component,Komponenta pristojbin
apps/erpnext/erpnext/config/accounting.py,C-Form records,Zapisi C-Form
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Cancelled. Please check your GoCardless Account for more details,"Plačilo je preklicano. Prosimo, preverite svoj GoCardless račun za več podrobnosti"
DocType: Crop Cycle,Less than a year,Manj kot eno leto
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0} must be submitted,Predložiti je treba delovni nalog {0}
apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js,Filter Total Zero Qty,Filter Skupna ničelna količina
DocType: Job Applicant,Applicant for a Job,Prijavitelj za delo
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,No records found in the Invoice table,V tabeli računa ni najdenih nobenih zapisov
DocType: Chart of Accounts Importer,Chart of Accounts Importer,Preglednica računov Uvoznik
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item or Warehouse for row {0} does not match Material Request,Element ali Skladišče za vrstico {0} se ne ujema z zahtevo za material
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,IGST Amount,Znesek IGST
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,Delivery Notes {0} updated,Opombe za dostavo {0} so posodobljene
DocType: Travel Itinerary,Lodging Required,Vlaganje je potrebno
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Total Revenue,Skupni prihodki
DocType: Student Group Student,Student Group Student,Študentska skupina Študent
DocType: Customer,Buyer of Goods and Services.,Kupec blaga in storitev.
DocType: Vehicle,Vehicle,Vozilo
apps/erpnext/erpnext/utilities/transaction_base.py,Quantity ({0}) cannot be a fraction in row {1},Količina ({0}) ne more biti del v vrstici {1}
DocType: Retention Bonus,Bonus Amount,Znesek bonusa
DocType: Stock Reconciliation Item,Amount Difference,Razlika v količini
DocType: Asset Maintenance,Maintenance Tasks,Naloge vzdrževanja
DocType: HR Settings,Stop Birthday Reminders,Ustavite opomnike za rojstni dan
DocType: Payment Gateway Account,Payment Account,Račun za plačilo
DocType: Stock Settings,Stock Frozen Upto,Zaloga Frozen Upto
DocType: Item,Default Material Request Type,Privzeti tip zahteve za material
DocType: Clinical Procedure Item,Clinical Procedure Item,Točka kliničnega postopka
DocType: Finance Book,Finance Book,Finance Book
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py,From Datetime,Iz Datetime
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Currency of the price list {0} must be {1} or {2},Valuta cenika {0} mora biti {1} ali {2}
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Open Orders,Odpri naročila
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.js,Admit,Priznaj
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py,Total {0} ({1}),Skupaj {0} ({1})
DocType: Certified Consultant,GitHub ID,GitHub ID
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Address 1,Iz naslova 1
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Total hours: {0},Skupno število ur: {0}
DocType: Employee Transfer,Transfer Date,Datum prenosa
DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,"Vnesite ime oglaševalske akcije, če je vir povpraševanja oglaševalska akcija"
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,"Ta postavka je predloga in je ni mogoče uporabiti v transakcijah. Atributi postavk bodo kopirani v različice, razen če je nastavljena možnost »No Copy«"
DocType: Cheque Print Template,Regular,Redno
apps/erpnext/erpnext/controllers/selling_controller.py,Maximum discount for Item {0} is {1}%,Največji popust za element {0} je {1}%
DocType: Production Plan,Not Started,Ni se začelo
DocType: Disease,Treatment Task,Naloga zdravljenja
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>,Vrstica {0}: uporabnik ni uporabil pravila <b>{1}</b> za element <b>{2}</b>
DocType: Landed Cost Voucher,Landed Cost Help,Pomoč za iztovorjene stroške
DocType: Supplier Scorecard,Scoring Criteria,Merila za točkovanje
DocType: Bank Statement Transaction Entry,Matching Invoices,Ustrezni računi
DocType: Donor,Donor Name,Ime darovalca
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Select Property,Izberite Lastnost
DocType: Homepage,Homepage Section,Oddelek za domačo stran
DocType: Assessment Result,Grade,Razred
DocType: Production Plan Material Request,Production Plan Material Request,Zahteva za materialni načrt proizvodnje
DocType: Request for Quotation Supplier,Send Email,Pošlji sporočilo
DocType: Item,Retain Sample,Ohranite vzorec
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0} (Payment Table): Amount must be negative,Vrstica # {0} (Tabela plačil): Znesek mora biti negativen
,Warehouse wise Item Balance Age and Value,Skladiščna pametna postavka Starost in vrednost
DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Bruto teža paketa. Običajno neto teža + teža embalaže. (za tiskanje)
DocType: Plant Analysis,Laboratory Testing Datetime,Datetime čas laboratorijskega testiranja
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,The Item {0} cannot have Batch,Postavka {0} ne more imeti paketa
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Student Group Strength,Moč učenčeve skupine
DocType: Bank Statement Transaction Entry,Bank Statement Transaction Entry,Vnos transakcije bančnega izpiska
DocType: Purchase Order,Get Items from Open Material Requests,Pridobite elemente iz odprtih zahtev za material
DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Poslovno leto ** predstavlja finančno leto. Vse vknjižbe in druge pomembnejše transakcije se spremljajo glede na ** fiskalno leto **.
DocType: Procedure Prescription,Procedure Name,Ime postopka
apps/erpnext/erpnext/public/js/event.js,Add Sales Partners,Dodaj prodajne partnerje
apps/erpnext/erpnext/public/js/pos/pos.html,Qty Total,Količina skupaj
DocType: Payment Entry Reference,Outstanding,Odlično
DocType: Employee Tax Exemption Proof Submission,Employee Tax Exemption Proof Submission,Oddaja oprostitve plačila davka na zaposlene
DocType: Contract Fulfilment Checklist,Requirement,Zahteva
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,No active or default Salary Structure found for employee {0} for the given dates,Ni aktivne ali privzete strukture plač za zaposlenega {0} za dane datume
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity should be greater than 0,Količina mora biti večja od 0
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Row #{0}: Payment document is required to complete the transaction,Vrstica # {0}: Dokument plačila je potreben za dokončanje transakcije
DocType: Purchase Order Item,Supplier Quotation Item,Postavka ponudnika za dobavitelje
DocType: Appraisal,Appraisal Template,Predloga za oceno
DocType: Item,Hub Category to Publish,Kategorija središča za objavo
DocType: Staffing Plan Detail,Current Openings,Trenutno odprtje
apps/erpnext/erpnext/config/crm.py,Customer Database.,Podatkovna baza strank.
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,As On Date,Kot na datum
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Delivery Note {0} is not submitted,Opomba za dostavo {0} ni poslana
DocType: Appraisal Template Goal,Appraisal Template Goal,Predloga za oceno cilja
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.js,Unlink external integrations,Prekinite povezavo zunanjih integracij
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Closing (Cr),Zapiranje (Cr)
DocType: Restaurant Reservation,Restaurant Reservation,Rezervacija restavracije
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Last Order Amount,Znesek zadnjega naročila
apps/erpnext/erpnext/config/desktop.py,Learn,Naučite se
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Večkratni privzeti način plačila ni dovoljen
DocType: Crop Cycle,This will be day 1 of the crop cycle,To bo prvi dan cikla pridelka
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} is not associated with {2} {3},{0} {1} ni povezana z {2} {3}
apps/erpnext/erpnext/controllers/stock_controller.py,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,"Račun stroškov ali razlike je obvezen za postavko {0}, saj vpliva na skupno vrednost delnice"
DocType: Purchase Invoice,Price List Exchange Rate,Cenovni tečaj
DocType: Purchase Invoice Item,Amount (Company Currency),Znesek (valuta podjetja)
DocType: Driver,Driver,Voznik
DocType: GST Account,CGST Account,Račun CGST
DocType: Loan,Disbursement Date,Datum izplačila
apps/erpnext/erpnext/templates/pages/projects.html,New task,Nova naloga
DocType: Customer Feedback Table,Customer Feedback Table,Tabela povratnih informacij strank
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Course {2},{0} - {1} ni vpisan v tečaj {2}
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Difference Amount,Razlika Znesek
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Cheques and Deposits incorrectly cleared,Nepravilno prečiščena preverjanja in vloge
DocType: Journal Entry,Cash Entry,Vnos gotovine
DocType: GST Settings,GST Settings,Nastavitve GST
,Item-wise Sales Register,Prodajni register po postavkah
apps/erpnext/erpnext/stock/doctype/item/item.py,Item has variants.,Postavka ima različice.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Difference Amount must be zero,Razlika Znesek mora biti nič
DocType: Fee Schedule,Institution,Institucija
DocType: Patient,Tobacco Current Use,Trenutna uporaba tobaka
apps/erpnext/erpnext/utilities/user_progress.py,Setup your ,Nastavite svoj
DocType: Payment Entry Deduction,Payment Entry Deduction,Odbitek za plačilo
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","Vrstica # {0}: Paket {1} ima samo {2} kol. Izberite drug paket, ki ima na voljo {3} količino ali razdelite vrstico v več vrstic, da se prikaže ali izda več paketov"
DocType: Patient Appointment,Procedure,Postopek
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Missed,Neodgovorjeni klic
,Total Stock Summary,Povzetek skupnih zalog
DocType: Purchase Invoice,Additional Discount,Dodatni popust
DocType: Healthcare Settings,Patient Name By,Ime bolnika
DocType: Healthcare Service Unit Type,Rate / UOM,Stopnja / UOM
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Nastavite Naming Series za {0} prek Setup&gt; Settings&gt; Series Naming
DocType: Job Offer,Job Offer Terms,Pogoji ponudbe dela
DocType: GL Entry,Debit Amount in Account Currency,Znesek bremenitve v valuti računa
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,{0} must appear only once,{0} se mora prikazati samo enkrat
apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Račun stroškov / razlike ({0}) mora biti račun &quot;dobiček ali izguba&quot;
DocType: Communication Medium,Communication Medium,Srednja komunikacija
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},Število vrstic {0}: znesek ne sme biti večji od čakajočega zneska za zahtevek za stroške {1}. Čakajoči znesek je {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Earnest Money,Najvarnejši denar
apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Vse karte dobaviteljev.
DocType: Sales Invoice,Terms and Conditions Details,Pogoji in določila Podrobnosti
DocType: Exchange Rate Revaluation,Get Entries,Prenos vnosov
DocType: Vehicle Service,Service Item,Postavka storitve
DocType: Sales Invoice,Customer's Purchase Order,Naročilnica naročnika
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in formula or condition: {0},Napaka v sintaksi v formuli ali stanju: {0}
DocType: Agriculture Analysis Criteria,Agriculture User,Uporabnik kmetijstva
apps/erpnext/erpnext/controllers/buying_controller.py,Please enter Reqd by Date,Vnesite Reqd by Date
DocType: Company,Total Monthly Sales,Skupna mesečna prodaja
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Odstotek mesečne porazdelitve
DocType: Stock Reconciliation,Reconciliation JSON,Usklajevanje JSON
apps/erpnext/erpnext/stock/get_item_details.py,No Item with Barcode {0},Ni elementa s črtno kodo {0}
DocType: Asset,Scrapped,Odpisano
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Delivery Trip,Trip Trip
DocType: Student Admission Program,Application Fee,Prijavnina
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Sales orders are not available for production,Prodajna naročila niso na voljo za proizvodnjo
DocType: Website Attribute,Attribute,Atribut
DocType: Rename Tool,Rename Log,Preimenuj dnevnik
apps/erpnext/erpnext/controllers/trends.py,'Based On' and 'Group By' can not be same,&#39;Based On&#39; in &#39;Group By&#39; ne moreta biti enaka
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.js,Show Ageing Warehouse-wise,Pokaži skladišče staranja
DocType: Sales Invoice,Write Off Outstanding Amount,Izpusti neporavnani znesek
DocType: Payroll Entry,Employee Details,Podrobnosti o zaposlenih
DocType: Pricing Rule,Discount Amount,Znesek popusta
DocType: Healthcare Service Unit Type,Item Details,Podrobnosti izdelka
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.py,Duplicate Tax Declaration of {0} for period {1},Podvojena davčna izjava o {0} za obdobje {1}
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js,From Delivery Note,Iz dobavne opombe
DocType: Holiday,Holiday,Počitnice
DocType: Company,Default Buying Terms,Privzeti pogoji nakupa
DocType: Cheque Print Template,Line spacing for amount in words,Razmik med vrsticami za znesek v besedah
DocType: Item Group,Item Group Defaults,Privzete nastavitve skupine elementov
DocType: Salary Component,Abbr,Abbr
apps/erpnext/erpnext/config/support.py,Warranty Claim against Serial No.,Zahtevek za garancijo proti serijski številki
apps/erpnext/erpnext/config/desktop.py,Quality,Kakovost
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,{0} is not a stock Item,{0} ni stalež
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Stroški dobavljenih surovin
DocType: Employee,Permanent Address,Stalni naslov
DocType: Asset,Booked Fixed Asset,Rezervirano fiksno sredstvo
apps/erpnext/erpnext/templates/pages/help.html,Your tickets,Vaše vozovnice
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Create Supplier Quotation,Ustvarite ponudbo ponudnika
DocType: Item,Inspection Required before Purchase,Potreben pregled pred nakupom
DocType: Payment Entry,Payment Ordered,Naročeno plačilo
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.","Zdi se, da obstaja težava s konfiguracijo strežnika GoCardless. Ne skrbite, v primeru neuspeha se znesek vrne na vaš račun."
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.","Način plačila ni konfiguriran. Preverite, ali je bil račun nastavljen na način plačila ali na profil POS."
DocType: Email Digest,Purchase Orders Items Overdue,Postavke naročil so zapadle
DocType: BOM,Inspection Required,Potreben pregled
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled so the action cannot be completed,"{0} {1} je preklicano, zato dejanja ni mogoče dokončati"
DocType: Project Template Task,Project Template Task,Naloga predloge projekta
apps/erpnext/erpnext/projects/doctype/task/task.py,Circular Reference Error,Krožna referenčna napaka
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}: račun za vrsto dobička in izgube {2} ni dovoljen v začetnem vnosu
DocType: Website Item Group,Cross Listing of Item in multiple groups,Navzkrižno uvrstitev elementa v več skupin
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction cannot be converted to ledger,Računa z obstoječo transakcijo ni mogoče pretvoriti v knjigo
DocType: POS Profile,Display Items In Stock,Prikaz elementov na zalogi
DocType: Issue,Service Level,Raven storitve
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Other outward supplies(Nil rated,Exempted)","Druge zunanje dobave (Ničelne, izvzete)"
,TDS Payable Monthly,TDS Plača Mesečno
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select Posting Date before selecting Party,"Preden izberete pogodbenico, izberite Datum knjiženja"
,GST Purchase Register,GST register nabave
DocType: Accounts Settings,Automatically Add Taxes and Charges from Item Tax Template,Samodejno dodajte davke in stroške iz predloga za davek na postavko
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Stock Options,Delniške opcije
DocType: Healthcare Schedule Time Slot,Healthcare Schedule Time Slot,Terminski načrt urnika zdravstvenega varstva
apps/erpnext/erpnext/public/js/pos/pos.html,Tap items to add them here,"Tapnite elemente, da jih dodate tukaj"
DocType: Payment Schedule,Invoice Portion,Delni račun
apps/erpnext/erpnext/config/accounting.py,Tax Category for overriding tax rates.,Davčna kategorija za prevladujoče davčne stopnje.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Retained Earnings,Zadržani prejemki
DocType: Grant Application,Requested Amount,Zahtevani znesek
DocType: Salary Detail,Additional Amount,Dodatni znesek
DocType: Quiz,Quiz Configuration,Konfiguracija kviza
DocType: Mode of Payment,General,Splošno
DocType: Email Digest,Annual Expenses,Letni stroški
DocType: Global Defaults,Disable In Words,Onemogoči besede
DocType: Customer,CUST-.YYYY.-,CUST-.YYYY.-
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Net pay cannot be negative,Neto plačilo ne more biti negativno
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,No of Interactions,Št. Interakcij
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Vrstice {0} # Predmet {1} ni mogoče prenesti več kot {2} proti naročilu za nakup {3}
DocType: Attendance,Shift,Shift
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Chart of Accounts and Parties,Obdelovalni kontni načrt in pogodbenice
DocType: Stock Settings,Convert Item Description to Clean HTML,Pretvori opis elementa v Clean HTML
apps/erpnext/erpnext/patches/v11_0/rename_supplier_type_to_supplier_group.py,All Supplier Groups,Vse skupine dobaviteljev
,Final Assessment Grades,Končne ocene
apps/erpnext/erpnext/projects/doctype/task/task.py,Cannot close task {0} as its dependant task {1} is not closed.,"Opravila {0} ni mogoče zapreti, ker njena odvisna naloga {1} ni zaprta."
DocType: Promotional Scheme,Promotional Scheme Price Discount,Promocijska shema s popustom
DocType: Installation Note,Installation Note,Namestitvena opomba
DocType: Student Admission,Application Form Route,Pot obrazca za prijavo
DocType: Work Order,Planned Operating Cost,Načrtovani obratovalni stroški
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Colour,Barva
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} is not in Optional Holiday List,{0} ni v izbirnem seznamu počitnic
DocType: Student Report Generation Tool,Show Marks,Pokaži oznake
DocType: Salary Component,Max Benefit Amount (Yearly),Najvišji znesek koristi (letno)
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Vrstica amortizacije {0}: naslednji datum amortizacije ne more biti pred datumom nakupa
DocType: Loyalty Program,Customer Group,Skupina strank
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year Start Date should be one year earlier than Fiscal Year End Date,Datum začetka fiskalnega leta mora biti eno leto prej kot končni datum proračunskega leta
,BOM Items and Scraps,Postavke BOM in zapisi
apps/erpnext/erpnext/healthcare/setup.py,High Sensitivity,Visoka občutljivost
DocType: Pricing Rule,Apply Discount on Rate,Uporabi popust na stopnjo
DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Stroške BOM-a posodobite samodejno prek razporejevalnika, ki temelji na najnovejši stopnji vrednotenja / ceniku / zadnji stopnji nakupa surovin."
DocType: Tally Migration,Tally Company,Tally Company
DocType: Quiz Question,Quiz Question,Kvizno vprašanje
DocType: Task Depends On,Task Depends On,Naloga je odvisna od
,Lead Id,Vodilni ID
DocType: Subscription Plan Detail,Subscription Plan Detail,Podrobnosti naročniškega načrta
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Created {0} scorecards for {1} between: ,Ustvaril je {0} razglednice za {1} med:
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,This Week's Summary,Povzetek tega tedna
DocType: Pricing Rule Item Code,Pricing Rule Item Code,Koda postavke za določanje cen
DocType: Water Analysis,Storage Temperature,Temperatura skladiščenja
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Income,Neposredni dohodek
apps/erpnext/erpnext/controllers/trends.py,Amt,Amt
,Sales Analytics,Prodajna analiza
DocType: Project,Total Billable Amount (via Timesheets),Skupni obračunljivi znesek (prek časovnih listov)
DocType: Setup Progress Action,Domains,Domene
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,"Not permitted, configure Lab Test Template as required","Ni dovoljeno, konfigurirajte Lab Test Template po potrebi"
DocType: Item,Default Unit of Measure,Privzeta merska enota
DocType: Serial No,Distinct unit of an Item,Razločljiva enota postavke
DocType: Amazon MWS Settings,Synch Products,Izdelki za sinhronizacijo
DocType: Supplier Scorecard Scoring Variable,Path,Pot
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Dr),Odpiranje (Dr)
DocType: Project,% Completed,% Dokončano
DocType: Customer,Commission Rate,Stopnja Komisije
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Central Tax,Centralni davek
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Total Outstanding Amount,Skupni neporavnani znesek
DocType: Employee Tax Exemption Proof Submission Detail,Maximum Exemption Amount,Najvišji znesek oprostitve
DocType: Subscription Plan,Based on price list,Glede na cenik
DocType: Stock Entry Detail,Additional Cost,Dodatni stroški
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Closing Account {0} must be of type Liability / Equity,Zaključni račun {0} mora biti tipa Liability / Equity
apps/erpnext/erpnext/utilities/user_progress.py,Setup Company,Setup Company
DocType: Inpatient Occupancy,Check In,Prijava
apps/erpnext/erpnext/config/help.py,Customer and Supplier,Stranka in dobavitelj
DocType: Issue,Support Team,Skupina za podporo
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: You can not assign itself as parent account,Račun {0}: Ne morete se dodeliti kot nadrejeni račun
apps/erpnext/erpnext/stock/doctype/item/item.py,Fixed Asset Item must be a non-stock item.,"Postavka osnovnih sredstev mora biti postavka, ki ni na zalogi."
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch ID (Optional),Nov ID paketa (izbirno)
apps/erpnext/erpnext/projects/doctype/project/project.js,Gantt Chart,Gantogram
DocType: Employee Benefit Application Detail,Max Benefit Amount,Najvišji znesek ugodnosti
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Leave on {1},{0} v Izhod ob {1}
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Do you really want to restore this scrapped asset?,Ali res želite obnoviti ta izpisani predmet?
apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py,Registration fee can not be Zero,Kotizacija ne sme biti nič
DocType: Item Tax Template,Item Tax Template,Predloga za davek na postavko
DocType: Fiscal Year,Auto Created,Samodejno ustvarjeno
DocType: Quality Objective,Quality Objective,Cilj kakovosti
DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Glavnica računa v okviru obveznosti ali lastniškega kapitala, v kateri bo knjižen dobiček / izguba"
DocType: GL Entry,Credit Amount in Account Currency,Znesek kredita v valuti računa
DocType: Employee Onboarding Activity,Employee Onboarding Activity,Zaposlitvena dejavnost zaposlenih
DocType: Healthcare Service Unit,Parent Service Unit,Enota matične službe
DocType: Sales Invoice,Include Payment (POS),Vključi plačilo (POS)
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Private Equity,Zasebni kapital
DocType: Shift Type,First Check-in and Last Check-out,Prva prijava in zadnja odjava
DocType: Landed Cost Item,Receipt Document,Dokument o prejemu
DocType: Supplier Scorecard Period,Supplier Scorecard Period,Obdobje kazalnika dobavitelja
DocType: Employee Grade,Default Salary Structure,Privzeta struktura plač
DocType: Exchange Rate Revaluation,Total Gain/Loss,Skupna dobiček / izguba
apps/erpnext/erpnext/education/doctype/course_enrollment/course_enrollment.py,Student is already enrolled.,Študent je že vpisan.
DocType: Product Bundle,Parent Item,Nadrejeni element
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Brokerage,Posredništvo
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please create purchase receipt or purchase invoice for the item {0},Za izdelek {0} ustvarite račun za nakup ali račun za nakup
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Please select Patient to get prescribed procedure,"Prosimo, da izberete bolnika, da dobite predpisan postopek"
,Product Bundle Balance,Stanje paketa izdelkov
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Name cannot be Company,Ime podjetja ne more biti družba
DocType: Maintenance Visit,Breakdown,Zlomiti se
DocType: Inpatient Record,B Negative,B Negativno
DocType: Issue,Response By,Odziv z
DocType: Purchase Invoice,Credit To,Zasluge za
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Submit this Work Order for further processing.,Predložite ta delovni nalog za nadaljnjo obdelavo.
DocType: Bank Transaction,Reconciled,Usklajeno
DocType: Bank Guarantee,Bank Guarantee Number,Številka bančne garancije
apps/erpnext/erpnext/templates/pages/material_request_info.html,Delivered: {0},Dostavljeno: {0}
DocType: Quality Meeting Table,Under Review,V pregledu
apps/erpnext/erpnext/public/js/setup_wizard.js,Agriculture (beta),Kmetijstvo (beta)
,Average Commission Rate,Povprečna stopnja Komisije
DocType: Sales Invoice,Customer's Purchase Order Date,Datum naročila kupca
apps/erpnext/erpnext/config/buying.py,All Contacts.,Vsi stiki.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Uporabljeni listi
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field From Shareholder cannot be blank,Polje Iz delničarja ne sme biti prazno
DocType: Brand,Brand Defaults,Privzete nastavitve blagovne znamke
DocType: Task,Depends on Tasks,Odvisno od nalog
DocType: Healthcare Settings,Healthcare Settings,Nastavitve zdravstvenega varstva
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,{0} Student Groups created.,{0} Ustvarjene skupine študentov.
apps/erpnext/erpnext/public/js/hub/marketplace.js,Register,Register
DocType: Woocommerce Settings,"This warehouse will be used to create Sale Orders. The fallback warehouse is ""Stores"".",To skladišče bo uporabljeno za izdelavo prodajnih naročil. Varnostno skladišče je &quot;Stores&quot;.
DocType: Vehicle Service,Oil Change,Menjava olja
DocType: Project User,Project User,Uporabnik projekta
DocType: Course,Assessment,Ocena
DocType: Promotional Scheme,Price Discount Slabs,Plošče s popustom za cene
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,New Customers,Nove stranke
DocType: Project,Total Expense Claim (via Expense Claims),Skupni zahtevek za stroške (prek zahtevkov za stroške)
DocType: Instructor Log,Other Details,Drugi podatki
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,Atributov po transakciji z zalogami ni mogoče spremeniti. Naredite nov element in prenesite zaloge v novo postavko
DocType: Employee Attendance Tool,Employees HTML,Zaposleni HTML
DocType: Leave Block List,Stop users from making Leave Applications on following days.,"Preprečite, da bi uporabniki v naslednjih dneh uvajali aplikacije Pustite."
DocType: Budget,Ignore,Prezri
,Sales Person Target Variance Based On Item Group,Prodajna oseba odstopa glede na skupino izdelkov
DocType: Education Settings,Current Academic Year,Tekoče akademsko leto
DocType: Bank Statement Transaction Entry,Submit/Reconcile Payments,Pošljite / uskladite plačila
DocType: Purchase Invoice,Set Advances and Allocate (FIFO),Nastavi predplačila in dodeli (FIFO)
DocType: BOM,Item to be manufactured or repacked,"Izdelek, ki ga je treba izdelati ali prepakirati"
apps/erpnext/erpnext/accounts/page/pos/pos.js,New Cart,Nova košarica
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,Najprej izberite Skladišče vzorčne hrambe v nastavitvah zaloge
DocType: Lab Test Template,Result Format,Oblika rezultatov
DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,"Vodje (ali skupine), proti katerim se sestavljajo računovodski vnosi in se vzdržujejo stanja."
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,"Zahteva za material, ki je bila uporabljena za izdelavo te zaloge"
DocType: Request for Quotation,Link to material requests,Povezava z materialnimi zahtevami
apps/erpnext/erpnext/regional/india/utils.py,Invalid {0}! The check digit validation has failed. ,Neveljaven {0}! Preverjanje veljavnosti kontrolne številke ni uspelo.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Unsecured Loans,Nezavarovana posojila
apps/erpnext/erpnext/public/js/event.js,Add Customers,Dodajanje strank
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Skladišče privzetega končnega blaga
DocType: Grant Application,Grant Description,Opis donacije
apps/erpnext/erpnext/stock/doctype/item/item.js,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Navedite tudi težo, prosimo, navedite tudi &quot;UOM za težo&quot;"
apps/erpnext/erpnext/accounts/party.py,{0} {1} is disabled,{0} {1} je onemogočen
DocType: Contract,Contract Period,Obdobje pogodbe
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js,Please enter Item Code to get Batch Number,"Vnesite kodo postavke, da dobite številko paketa"
DocType: Cash Flow Mapping,Is Working Capital,Je obratni kapital
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Missing email template for dispatch. Please set one in Delivery Settings.,Manjka e-poštna predloga za pošiljanje. Nastavite eno v nastavitvah dostave.
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)
","Uporabite lahko spremenljivke kazalnikov, kot tudi: {total_score} (skupni rezultat iz tega obdobja), {period_number} (število obdobij do danes)"
apps/erpnext/erpnext/public/js/stock_analytics.js,Value Or Qty,Vrednost ali količina
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,Vnesite številko SIREN v datoteko z informacijami o podjetju
DocType: Amazon MWS Settings,Check this to enable a scheduled Daily synchronization routine via scheduler,"Označite to možnost, če želite omogočiti načrtovano dnevno rutino sinhronizacije prek razporejevalnika"
DocType: Employee Tax Exemption Declaration,Declarations,Izjave
DocType: Manufacturing Settings,Backflush Raw Materials Based On,"Surovi materiali, ki se nahajajo na"
DocType: Cheque Print Template,Distance from top edge,Razdalja od zgornjega roba
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Job Description,Opis dela
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"Can not filter based on Voucher No, if grouped by Voucher","Ne morem filtrirati na podlagi kupona, če je združeno po bonu"
DocType: Purchase Receipt Item,Received and Accepted,Prejeto in Sprejeto
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Negative Valuation Rate is not allowed,Negativna stopnja ocenjevanja ni dovoljena
DocType: Woocommerce Settings,"The user that will be used to create Customers, Items and Sales Orders. This user should have the relevant permissions.","Uporabnik, ki bo uporabljen za ustvarjanje strank, elementov in prodajnih naročil. Ta uporabnik mora imeti ustrezna dovoljenja."
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Purchase Order,Ustvarite naročilo
apps/erpnext/erpnext/config/accounting.py,Define budget for a financial year.,Določite proračun za proračunsko leto.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Accounts table cannot be blank.,Tabela računov ne sme biti prazna.
DocType: Employee Checkin,Entry Grace Period Consequence,Posledica vstopnega obdobja
,Payment Period Based On Invoice Date,Obdobje plačila na podlagi datuma računa
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Installation date cannot be before delivery date for Item {0},Datum namestitve ne more biti pred datumom dobave za element {0}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Link to Material Request,Povezava na zahtevo za material
DocType: Warranty Claim,From Company,Iz podjetja
DocType: Bank Statement Transaction Settings Item,Mapped Data Type,Vrsta preslikanih podatkov
apps/erpnext/erpnext/stock/doctype/item/item.py,Row {0}: An Reorder entry already exists for this warehouse {1},Vrstica {0}: v tem skladišču že obstaja vnos ponovnega urejanja {1}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Date,Datum dokumenta
DocType: Monthly Distribution,Distribution Name,Ime distribucije
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Workday {0} has been repeated.,Delovni dan {0} se je ponovil.
apps/erpnext/erpnext/accounts/doctype/account/account.js,Group to Non-Group,Skupina v drugo skupino
apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Posodobitev poteka. Morda bo trajalo nekaj časa.
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.","Primer: ABCD. ##### Če je niz nastavljen in serijska številka ni navedena v transakcijah, se bo na podlagi te serije ustvarila avtomatska serijska številka. Če vedno želite izrecno omeniti serijske številke za to postavko. pustite prazno."
DocType: Stock Entry,Stock Entry (Outward GIT),Vnos delnic (Outward GIT)
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Party Addresses,Naslovi obdelave strani
DocType: Selling Settings,Delivery Note Required,Potrebna je opomba za dostavo
DocType: Pricing Rule,Sales Partner,Prodajni partner
DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Računovodski vnos zamrznjen do tega datuma, nihče ne more storiti / spremeniti vnosa razen vloge, ki je navedena spodaj."
DocType: Vehicle Log,Fuel Qty,Količina goriva
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Mobile No,Guardian1 Mobile No
DocType: Invoice Discounting,Disbursed,Izplačano
DocType: Shift Type,Time after the end of shift during which check-out is considered for attendance.,"Čas po koncu izmene, v katerem se upošteva check-out za udeležbo."
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Accounts Payable,Neto sprememba obveznosti do dobaviteljev
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Not Available,Ni na voljo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Part-time,Krajši delovni čas
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Delivery,Dostava
DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Tečaj orodja za ustvarjanje študentskih skupin
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be greater than unadjusted amount,Dodeljeni znesek ne sme biti večji od neprilagojenega zneska
DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,"Tretja oseba distributer / trgovec / provizija agent / affiliate / prodajalec, ki prodaja podjetja izdelke za provizijo."
DocType: BOM Item,Original Item,Izvirna postavka
apps/erpnext/erpnext/buying/doctype/supplier/supplier.py,Series is mandatory,Serija je obvezna
apps/erpnext/erpnext/config/crm.py,Potential opportunities for selling.,Možne priložnosti za prodajo.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show PDC in Print,Pokaži PDC v tiskanju
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/sync_product.py,Shopify Supplier,Shopify dobavitelj
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Ta bančna transakcija je že v celoti usklajena
DocType: POS Profile User,POS Profile User,Uporabnik POS profila
DocType: Sales Person,Sales Person Name,Ime prodajne osebe
DocType: Packing Slip,Gross Weight,Bruto teža
DocType: Journal Entry,Bill No,Predlog št
apps/erpnext/erpnext/assets/doctype/location/location_tree.js,New Location,Nova lokacija
,Project wise Stock Tracking,Sledenje projektom
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,"Preden dodate nov račun, ga shranite"
DocType: Issue,Service Level Agreement,Sporazum o ravni storitev
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Item valuation rate is recalculated considering landed cost voucher amount,Stopnja vrednotenja postavke se preračuna glede na znesek kupona stroškov iztovarjanja
DocType: Timesheet,Employee Detail,Podrobnosti o zaposlenih
DocType: Tally Migration,Vouchers,Kuponi
DocType: Student,Guardian Details,Podrobnosti o skrbniku
DocType: Shopify Settings,eg: frappe.myshopify.com,npr .: frappe.myshopify.com
apps/erpnext/erpnext/crm/doctype/lead/lead.py,"Email Address must be unique, already exists for {0}","E-poštni naslov mora biti edinstven, že obstaja za {0}"
apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Ujemite plačila z računi
DocType: Holiday List,Weekly Off,Tedenski izklop
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Ni dovoljeno nastaviti alternativne postavke za element {0}
apps/erpnext/erpnext/www/lms/program.py,Program {0} does not exist.,Program {0} ne obstaja.
apps/erpnext/erpnext/hr/doctype/department/department.js,You cannot edit root node.,Korenskega vozlišča ni mogoče urediti.
DocType: Fee Schedule,Student Category,Kategorija študentov
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Item {0}: {1} qty produced, ","Element {0}: {1} proizvedeno število,"
DocType: Identification Document Type,Identification Document Type,Vrsta identifikacijskega dokumenta
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Insufficient Stock,Nezadostna zaloga
apps/erpnext/erpnext/controllers/selling_controller.py,Row {0}: Conversion Factor is mandatory,Vrstica {0}: faktor konverzije je obvezen
DocType: Buying Settings,Purchase Receipt Required,Potrdilo o nakupu je potrebno
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM Rate
DocType: HR Settings,Max working hours against Timesheet,Največje število delovnih ur proti časovnemu listu
DocType: HR Settings,Include holidays in Total no. of Working Days,Vključite praznike v Skupaj št. delovnih dni
DocType: Quality Meeting,Quality Meeting,Srečanje kakovosti
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consulting,Svetovanje
DocType: Payment Gateway Account,Default Payment Request Message,Sporočilo o privzeti zahtevi za plačilo
DocType: GST Settings,GSTIN Email Sent On,GSTIN E-pošta je poslana na
DocType: Amazon MWS Settings,Enable Scheduled Synch,Omogoči Scheduled Synch
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Please select Employee,Izberite zaposlenega
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.","Če je označeno, bo stranka ustvarjena, preslikana v bolnika. Računi bolnikov bodo ustvarjeni proti tej stranki. Med ustvarjanjem bolnika lahko izberete obstoječo stranko."
DocType: Fiscal Year,Stock User,Uporabnik delnic
apps/erpnext/erpnext/config/support.py,Service Level Agreement.,Sporazum o ravni storitev.
DocType: Additional Salary,Date on which this component is applied,"Datum, na katerega se ta komponenta uporablja"
apps/erpnext/erpnext/config/accounting.py,List of available Shareholders with folio numbers,Seznam razpoložljivih delničarjev s številkami
apps/erpnext/erpnext/config/accounting.py,Setup Gateway accounts.,Nastavitve računov za prehod.
DocType: Service Level Priority,Response Time Period,Obdobje odzivnega časa
DocType: Purchase Invoice,Purchase Taxes and Charges,Nakup davkov in dajatev
DocType: Course Activity,Activity Date,Datum aktivnosti
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select or add new customer,Izberite ali dodajte novo stranko
DocType: Contract,Unfulfilled,Neizpolnjeno
apps/erpnext/erpnext/education/utils.py,You are not allowed to enroll for this course,Vstop na ta tečaj ni dovoljen
apps/erpnext/erpnext/templates/pages/home.html,Read blog,Preberite spletni dnevnik
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Value,Vrednost projekta
DocType: Task,Expected Time (in hours),Pričakovani čas (v urah)
apps/erpnext/erpnext/stock/doctype/item/item.py,Updating Variants...,Posodabljanje različic ...
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Sales Person in Print,Pokaži prodajalce v tiskanju
DocType: Supplier Scorecard,Per Year,Letno
DocType: Inpatient Record,Admitted Datetime,Sprejet Datetime
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Template is mandatory.,Predloga za davek je obvezna.
DocType: Clinical Procedure,Patient,Potrpežljiv
DocType: Timesheet Detail,Costing Amount,Znesek obračunavanja stroškov
apps/erpnext/erpnext/stock/doctype/item/item.js,Add / Edit Prices,Dodaj / uredi cene
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non-GST outward supplies,Zunanje zaloge brez GST
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0}: From time must be less than to time,Vrstica {0}: Od časa mora biti krajša od časa
apps/erpnext/erpnext/hr/doctype/employee/employee.py,User {0} is already assigned to Employee {1},Uporabnik {0} je že dodeljen zaposlenemu {1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Form View,Pogled obrazca
DocType: Supplier Quotation,Auto Repeat Section,Odsek samodejnega ponavljanja
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid public token error,Napaka javnega žetona
DocType: Sales Person,Select company name first.,Najprej izberite ime podjetja.
apps/erpnext/erpnext/public/js/setup_wizard.js,Financial Year,Finančno leto
DocType: Sales Invoice Item,Deferred Revenue,Odloženi prihodki
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Atleast one of the Selling or Buying must be selected,V vsakem primeru je treba izbrati eno od prodajnih ali nakupnih
DocType: Shift Type,Working Hours Threshold for Half Day,Delovni čas Prag za pol dneva
,Item-wise Purchase History,Zgodovina nabave
apps/erpnext/erpnext/accounts/deferred_revenue.py,Cannot change Service Stop Date for item in row {0},Ni mogoče spremeniti datuma zaustavitve storitve za element v vrstici {0}
DocType: Production Plan,Include Subcontracted Items,Vključite postavke podizvajalcev
DocType: Salary Structure,Max Benefits (Amount),Največje ugodnosti (znesek)
DocType: Homepage,Hero Section,Oddelek Hero
apps/erpnext/erpnext/config/manufacturing.py,Where manufacturing operations are carried.,Kadar se opravljajo proizvodni postopki.
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Dispatch Notification,Obvestilo o pošiljanju
DocType: Projects Settings,Timesheets,Časovni listi
DocType: Purchase Receipt,Get current stock,Pridobite trenutne zaloge
DocType: Account,Expense,Stroški
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,{0} asset cannot be transferred,Sredstva {0} ni mogoče prenesti
,Unpaid Expense Claim,Neplačani odškodninski zahtevek
DocType: Employee,Family Background,Družinsko ozadje
apps/erpnext/erpnext/config/hr.py,Energy Point Leaderboard,Energy Point Leaderboard
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py,Bonus Payment Date cannot be a past date,Datum bonusa plačila ne more biti pretekli datum
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,No {0} found for Inter Company Transactions.,Ni {0} za transakcije med podjetji.
DocType: Bank Account,Party Type,Vrsta stranke
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Finish,Dokončaj
DocType: Sales Invoice,C-Form Applicable,Obrazec C se uporablja
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'",Stanje v računu že v debeti ni dovoljeno nastaviti »Stanje mora biti« kot »kredit«
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Qty increased by 1,Vrstica # {0}: Količina se je povečala za 1
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Nastavite cilje Postavka Skupina za to prodajno osebo.
DocType: Asset Repair,ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-
DocType: Student,Student Mobile Number,Študentska mobilna številka
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Academic Year: ,Študijsko leto:
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}","V skladu z nastavitvami nakupa, če je naročilo za naročilo potrebno == &quot;DA&quot;, potem mora uporabnik za ustvarjanje računa za nakup najprej ustvariti naročilo za nakup izdelka {0}"
DocType: Shipping Rule Condition,To Value,Ovrednotiti
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Please add the account to root level Company - ,Dodajte račun na osnovno raven podjetja -
DocType: Asset Settings,Number of Days in Fiscal Year,Število dni v poslovnem letu
DocType: Journal Entry,Total Amount Currency,Skupna valuta zneska
DocType: BOM,Allow Same Item Multiple Times,Dovoli isti element večkrat
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create BOM,Ustvari BOM
DocType: Healthcare Practitioner,Charges,Stroški
DocType: Employee,Attendance and Leave Details,Prisotnost in podatki o dopustu
DocType: Student,Personal Details,Osebni podatki
DocType: Sales Order,Billing and Delivery Status,Stanje zaračunavanja in dostave
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Row {0}: For supplier {0} Email Address is required to send email,Vrstica {0}: Za dobavitelja {0} E-poštni naslov je potreben za pošiljanje e-pošte
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Investing,Denarni tok iz vlaganja
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Approving Role cannot be same as role the rule is Applicable To,"Odobritev vloge ne more biti enaka vlogi, ki jo ima pravilo"
DocType: Crop,Crop Spacing,Razmik obrezovanja
DocType: Selling Settings,How often should project and company be updated based on Sales Transactions.,Kako pogosto naj se projekt in podjetje posodabljata na podlagi prodajnih transakcij.
DocType: Pricing Rule,Period Settings,Nastavitve obdobja
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Accounts Receivable,Čista sprememba terjatev
DocType: Quality Feedback Template,Quality Feedback Template,Predloga za kakovostne povratne informacije
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Quantity must be greater than zero,Za količino mora biti večja od nič
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,"There are inconsistencies between the rate, no of shares and the amount calculated","Obstajajo neskladnosti med obrestno mero, št. Delnic in izračunanim zneskom"
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Pustite prazno, če naredite skupine študentov na leto"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Loans (Liabilities),Posojila (obveznosti)
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js,Send Grant Review Email,Pošlji e-poštno sporočilo za pregled odobritve
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,GSTR3B-Form,GSTR3B-obrazec
DocType: Production Plan Item,Produced Qty,Proizvedena količina
DocType: Bank Statement Transaction Invoice Item,Journal Entry,Vnos v dnevnik
DocType: Stock Entry,Purchase Receipt No,Potrdilo o nakupu št
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,From Date {0} cannot be before employee's joining Date {1},Od datuma {0} ni mogoče pred datumom pridružitve zaposlenega {1}
DocType: Journal Entry,Debit Note,Debitno obvestilo
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Ali je ta davek vključen v osnovno stopnjo?
DocType: Share Balance,Purchased,Kupljeno
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,"Stopnja, po kateri se valuta Cenika pretvori v osnovno valuto podjetja"
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,View Fees Records,Oglejte si zapise o plačilih
DocType: Training Event,Theory,Teorija
DocType: Sales Invoice,Is Discounted,Je diskontirana
apps/erpnext/erpnext/utilities/activation.py,Create Quotation,Ustvari ponudbo
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,Vrstica # {0}: Vnos v dnevnik {1} nima računa {2} ali se že ujema z drugim kuponom
apps/erpnext/erpnext/accounts/page/pos/pos.js,Create a new Customer,Ustvarite novo stranko
DocType: BOM Website Operation,BOM Website Operation,Operacija spletne strani BOM
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Podrobnosti o vnosu računa / dnevnika
DocType: Share Balance,Share Balance,Delite Balance
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Period Closing Entry,Vnos za zaprtje obdobja
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,Purchase Price List,Nakupni cenik
DocType: Contract,Party User,Uporabnik stranke
DocType: Restaurant Order Entry,Restaurant Order Entry,Vnos naročila v restavraciji
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serializiranega predmeta {0} ni mogoče posodobiti z usklajevanjem zalog, uporabite vnos v zalogi"
DocType: Practitioner Schedule,Time Slots,Časovne reže
apps/erpnext/erpnext/stock/doctype/item/item.js,Select at least one value from each of the attributes.,Izberite vsaj eno vrednost iz vsakega atributa.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Bank Draft,Osnutek banke
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Last Issue,Zadnja izdaja
DocType: Email Digest,Send regular summary reports via Email.,Pošlji redna zbirna poročila prek e-pošte.
DocType: Quality Procedure Table,Step,Korak
DocType: Normal Test Items,Result Value,Vrednost rezultata
DocType: Cash Flow Mapping,Is Income Tax Liability,Je odgovornost za davek od dohodka
DocType: Healthcare Practitioner,Inpatient Visit Charge Item,Plačilni element za bolnišnično obisk
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,{0} {1} does not exist.,{0} {1} ne obstaja.
apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Posodobi odgovor
DocType: Bank Guarantee,Supplier,Dobavitelj
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Enter value betweeen {0} and {1},Vnesite vrednost med {0} in {1}
DocType: Purchase Order,Order Confirmation Date,Datum potrditve naročila
DocType: Delivery Trip,Calculate Estimated Arrival Times,Izračunajte predvideni čas prihoda
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Potrošni
DocType: Instructor,EDU-INS-.YYYY.-,EDU-INS-.YYYY.-
DocType: Subscription,Subscription Start Date,Datum začetka naročnine
DocType: Woocommerce Settings,Woocommerce Server URL,URL strežnika Woocommerce
DocType: Payroll Entry,Number Of Employees,Število zaposlenih
apps/erpnext/erpnext/regional/india/bank_remittance.py,{0} field is limited to size {1},Polje {0} je omejeno na velikost {1}
apps/erpnext/erpnext/education/utils.py,This {0} conflicts with {1} for {2} {3},Ta {0} je v sporu z {1} za {2} {3}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Value Proposition,Predlog za vrednost
DocType: Purchase Invoice,Contact Email,E-pošta za stik
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Cannot set authorization on basis of Discount for {0},Pooblastila ni mogoče nastaviti na podlagi Popusta za {0}
DocType: Attendance Request,Work From Home,Delo z doma
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: From Time and To Time is mandatory.,Vrstica {0}: od časa do časa je obvezna.
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Supplier Id,ID dobavitelja
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Invoice can't be made for zero billing hour,Računa ni mogoče izvesti za ničelno uro obračunavanja
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}","Pustitve ni mogoče dodeliti pred {0}, ker je bil preostanek že prenesen v zapisu o dodelitvi prihodnjega dopusta {1}"
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Last Order Date,Datum zadnjega naročila
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Course: ,Tečaj:
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Dispatch,Odprema
DocType: Installation Note Item,Installation Note Item,Namestitev Opomba Postavka
DocType: Journal Entry Account,Journal Entry Account,Račun za vnos v dnevnik
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant,Varianta
apps/erpnext/erpnext/templates/pages/help.html,Forum Activity,Dejavnost foruma
DocType: Service Level Priority,Resolution Time Period,Časovno obdobje ločljivosti
DocType: Request for Quotation,Supplier Detail,Podrobnosti o dobavitelju
apps/erpnext/erpnext/accounts/doctype/bank_transaction/bank_transaction.js,Document {0} successfully uncleared,Dokument {0} uspešno nejasen
DocType: Serial No,Purchase / Manufacture Details,Podrobnosti o nakupu / izdelavi
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Samodejno knjižite vnos amortizacije sredstev
DocType: Work Order Operation,Operation completed for how many finished goods?,Operacija zaključena za koliko končnih izdelkov?
DocType: Healthcare Settings,Employee name and designation in print,Ime in ime zaposlenega v tiskani obliki
DocType: Tally Migration,Is Day Book Data Processed,Obdelava podatkov dnevne knjige
DocType: Program,Courses,Tečaji
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Update stock must be enable for the purchase invoice {0},Za račun za nakup {0} mora biti omogočeno posodabljanje zaloge
DocType: Employee Boarding Activity,Employee Boarding Activity,Dejavnost vkrcanja zaposlenih
apps/erpnext/erpnext/stock/utils.py,Warehouse {0} does not belong to company {1},Skladišče {0} ne pripada podjetju {1}
DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Če je onemogočen, polje »V besedah« ne bo vidno v nobeni transakciji"
DocType: Payment Entry Reference,Allocated,Dodeljeno
DocType: Project,Time to send,Čas za pošiljanje
DocType: Vital Signs,Bloated,Nadut
DocType: Blanket Order,Order Type,Vrsta naročila
DocType: POS Closing Voucher,Period Start Date,Datum začetka obdobja
DocType: Maintenance Schedule,Generate Schedule,Ustvari razpored
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Opening Value,Začetna vrednost
DocType: Additional Salary,Additional Salary,Dodatna plača
DocType: Loan,Repayment Method,Metoda povračila
apps/erpnext/erpnext/config/projects.py,Cost of various activities,Stroški različnih dejavnosti
DocType: Opportunity,Mins to First Response,Min. Do prvega odgovora
DocType: Patient Appointment,Patient Age,Starost bolnika
DocType: Patient Encounter,Investigations,Preiskave
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Equipments,Pisarniška oprema
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full , did not save","LocalStorage je poln, ni shranil"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Items for Raw Material Request,Postavke za zahtevo za surovine
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Select Item (optional),Izberite element (izbirno)
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py,Parent Item {0} must not be a Stock Item,Nadrejena postavka {0} ne sme biti postavka
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,All bank transactions have been created,Vse bančne transakcije so bile ustvarjene
DocType: Stock Entry Detail,Against Stock Entry,Proti vstopu v zalogo
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Fetch exploded BOM (including sub-assemblies),Pridobivanje eksplodirane BOM (vključno s podsklopi)
DocType: Sales Invoice,ACC-SINV-.YYYY.-,ACC-SINV-.YYYY.-
DocType: Loan,Loan Application,Vloga za posojilo
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Job Card,Za službeni karton
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Master Data,Osnovni podatki procesa
DocType: Cheque Print Template,Is Account Payable,Je plačljiva
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Total Order Value,Skupna vrednost naročila
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,Supplier {0} not found in {1},Dobavitelj {0} ni v {1}
apps/erpnext/erpnext/config/settings.py,Setup SMS gateway settings,Nastavite nastavitve prehoda SMS
DocType: Salary Component,Round to the Nearest Integer,Pojdite na najbližji Integer
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Root cannot have a parent cost center,Root ne more imeti matičnega stroškovnega mesta
DocType: Healthcare Service Unit,Allow Appointments,Dovoli sestanke
DocType: BOM,Show Operations,Pokaži operacije
DocType: Practitioner Schedule,Practitioner Schedule,Urnik zdravnika
DocType: Asset Maintenance Task,Calibration,Praznovanje
DocType: Pricing Rule,Apply On,Uporabi On
apps/erpnext/erpnext/config/accounting.py,Close Balance Sheet and book Profit or Loss.,Zaprite bilanco stanja in knjižite dobiček ali izgubo.
DocType: Employee,Provide Email Address registered in company,"Navedite e-poštni naslov, registriran v podjetju"
DocType: Item Alternative,Alternative Item Name,Alternativno ime predmeta
DocType: Assessment Plan,Course,Seveda
DocType: Patient,Patient Details,Podrobnosti o bolniku
DocType: Employee Separation,Employee Separation,Ločevanje zaposlenih
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Debtors,Dolžniki
DocType: Bank Statement Settings,Mapped Items,Preslikane postavke
DocType: Leave Control Panel,Department (optional),Oddelek (neobvezno)
DocType: Task Type,Task Type,Vrsta opravila
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Debit A/C Number,Številka zadolžnice A / C
DocType: Timesheet,Total Billed Amount,Skupni obračunani znesek
apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Datum / referenčni rok ne more biti po {0}
DocType: Leave Allocation,Add unused leaves from previous allocations,Dodajte neuporabljene liste iz prejšnjih dodelitev
DocType: Employee Transfer,New Company,Nova družba
DocType: Sales Invoice,Commission Rate (%),Stopnja Komisije (%)
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Skladišče se lahko spremeni samo z vstopnico / dobavnico / nakupom
DocType: Support Settings,Close Issue After Days,Zapri vprašanje po dnevih
DocType: Payment Schedule,Payment Schedule,Urnik plačila
DocType: Shift Type,Enable Entry Grace Period,Omogoči začetno obdobje odobritve
DocType: Patient Relation,Spouse,Zakonec
DocType: Purchase Invoice,Reason For Putting On Hold,Razlog za zadržanje
DocType: Item Attribute,Increment,Povečanje
DocType: Vital Signs,Cuts,Cuts
DocType: Student Applicant,LMS Only,Samo LMS
DocType: Shopping Cart Settings,Show Contact Us Button,Gumb Pokaži stik z nami
apps/erpnext/erpnext/public/js/event.js,Add Employees,Dodaj zaposlene
DocType: Holiday List,Holidays,Počitnice
DocType: Chapter,Chapter Head,Poglavje Glava
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Not permitted. Please disable the Test Template,Ni dovoljeno. Onemogočite testno predlogo
DocType: Restaurant Reservation,No Show,Ni predstave
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,The selected payment entry should be linked with a creditor bank transaction,Izbrana plačilna postavka mora biti povezana z bančno transakcijo upnika
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Selling Amount,Znesek prodaje
DocType: Amazon MWS Settings,AWS Access Key ID,ID ključa za dostop AWS
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py,{0} {1} is not present in the parent company,{0} {1} ni v matični družbi
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,To Date cannot be before From Date,Datum ne more biti pred datumom
apps/erpnext/erpnext/public/js/event.js,Add Suppliers,Dodaj dobavitelje
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Summary for this month and pending activities,Povzetek za ta mesec in nedokončane dejavnosti
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Mode of Transport,Način prevoza
apps/erpnext/erpnext/config/hr.py,Recruitment,Zaposlovanje
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Bruto plača - celotni odbitek - odplačilo posojila
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Datum knjiženja ne more biti datum v prihodnosti
apps/erpnext/erpnext/regional/india/utils.py,{} is required to generate e-Way Bill JSON,{} je potreben za ustvarjanje e-Way Bill JSON
,Work Order Stock Report,Poročilo o stanju delovne naloge
apps/erpnext/erpnext/config/accounting.py,Enable / disable currencies.,Omogoči / onemogoči valute.
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,View in Cart,Pogled v košarici
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Fetch based on FIFO,Prenos na podlagi FIFO
DocType: Timesheet,Total Billable Amount,Skupni obračunljivi znesek
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},"Zahtevek za material, ki je največ {0}, lahko naredite za element {1} pred prodajnim nalogom {2}"
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js,Production Item,Proizvodna postavka
DocType: Share Transfer,Equity/Liability Account,Račun lastniškega kapitala / obveznosti
apps/erpnext/erpnext/www/all-products/index.html,No values,Ni vrednosti
apps/erpnext/erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py,Cancel the journal entry {0} first,Najprej prekličite postavko dnevnika {0}
DocType: GL Entry,Remarks,Opombe
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Supplier must be debit,Vrstica {0}: Predplačilo proti dobavitelju mora biti debetno
DocType: Student Report Generation Tool,Attended by Parents,Ob prisotnosti staršev
DocType: POS Profile,Update Stock,Posodobi zalogo
DocType: Account,Old Parent,Stari starš
DocType: Production Plan,Download Materials Required,Zahtevani materiali za prenos
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Another Period Closing Entry {0} has been made after {1},Po {1} je bil vnesen še en vnos za zaključek obdobja {0}
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,Item Template,Predloga postavke
DocType: Purchase Invoice Item,Discount on Price List Rate (%),Popust na cenik (%)
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Kratica je obvezna
DocType: Travel Request,Domestic,Domače
apps/erpnext/erpnext/selling/report/pending_so_items_for_purchase_request/pending_so_items_for_purchase_request.py,SO Qty,SO Kol
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Release date must be in the future,Datum izdaje mora biti v prihodnosti
DocType: Program Enrollment,Pick/Drop by Guardian,Pick / Drop z Guardian
DocType: Exchange Rate Revaluation Account,Balance In Base Currency,Stanje v osnovni valuti
DocType: Payment Entry,Get Outstanding Invoice,Pridobite neporavnani račun
apps/erpnext/erpnext/config/buying.py,All Products or Services.,Vsi izdelki ali storitve.
DocType: Vehicle Service,Brake Pad,Zavorna ploščica
DocType: Pricing Rule,Max Amt,Max Amt
DocType: Shopping Cart Settings,Show Stock Availability,Pokaži razpoložljivost zaloge
DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,Cenik hotelskih sob
DocType: Task,Pending Review,V teku pregled
DocType: Employee,Date of Joining,Datum pridružitve
DocType: Patient,Patient Relation,Odnos bolnikov
DocType: Currency Exchange,For Selling,Za prodajo
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Financing,Denarni tok iz financiranja
DocType: Blanket Order,Manufacturing,Proizvodnja
apps/erpnext/erpnext/templates/pages/home.html,By {0},Do {0}
DocType: Restaurant Menu,Restaurant Manager,Upravitelj restavracij
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Out Value,Vrednost Out
DocType: Volunteer,Availability and Skills,Razpoložljivost in spretnosti
DocType: Employee Advance,Advance Account,Vnaprejšnji račun
DocType: GSTR 3B Report,Invoices with no Place Of Supply,Računi brez kraja dobave
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Ref,Ref
DocType: Invoice Discounting,Loan End Date,Datum konca posojila
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Količina v vrstici {0} ({1}) mora biti enaka izdelani količini {2}
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Creating bank entries...,Ustvarjanje bančnih vnosov ...
apps/erpnext/erpnext/utilities/user_progress_utils.py,Commercial,Komercialno
DocType: Salary Slip,Bank Account No.,Številka bančnega računa
apps/erpnext/erpnext/controllers/taxes_and_totals.py,Advance amount cannot be greater than {0} {1},Znesek predujma ne sme biti večji od {0} {1}
DocType: Cheque Print Template,Width of amount in word,Širina zneska v besedi
DocType: Delivery Note,MAT-DN-.YYYY.-,MAT-DN-.YYYY.-
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign Salary Structure,Dodeli strukturo plač
DocType: Stock Entry,Stock Entry Type,Vrsta vnosa zaloge
DocType: Quality Action Table,Responsible,Odgovorni
DocType: Room,Room Number,Številka sobe
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Fiscal Year...,Izberite fiskalno leto ...
,Trial Balance,Poskusna bilanca
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Employee Transfer cannot be submitted before Transfer Date ,Prenos zaposlenih ni možen pred datumom prenosa
DocType: Grading Scale,Grading Scale Name,Ime merilne lestvice
DocType: Location,Area UOM,Območje UOM
DocType: Timesheet,Total Costing Amount,Celotni obračun stroškov
DocType: Material Request Plan Item,Material Issue,Izdaja materiala
DocType: BOM,Item Image (if not slideshow),Slika izdelka (če ni slideshow)
DocType: Share Balance,Is Company,Je podjetje
DocType: BOM Update Tool,Update latest price in all BOMs,Posodobite najnovejšo ceno v vseh BOM
DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,"Sporočila, večja od 160 znakov, bodo razdeljena v več sporočil"
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Salary Slip submitted for period from {0} to {1},Vplačilo plač je poslano v obdobju od {0} do {1}
apps/erpnext/erpnext/controllers/trends.py,Project-wise data is not available for Quotation,Podatki o projektu niso na voljo za ponudbo
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py,Total Outstanding Amt,Skupaj neplačani amt
DocType: Purchase Invoice Item,Item Tax Rate,Stopnja davka na postavko
DocType: Sales Order Item,Planned Quantity,Načrtovana količina
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Retention Stock Entry,Vnos v skladišče
DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,"V besedi (Izvozi) bo viden, ko shranite dobavno opombo."
DocType: Selling Settings,Each Transaction,Vsaka transakcija
DocType: Program Enrollment,Institute's Bus,Inštitutski avtobus
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select the Company first,Najprej izberite podjetje
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Attendance for employee {0} is already marked for this day,Prisotnost zaposlenega {0} je že označena za ta dan
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,Opening,Odpiranje
DocType: Crop Cycle,Detected Disease,Zaznana bolezen
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}) v proizvodnem nalogu ne more biti večji od načrtovane vrednosti ({2}) {3}
DocType: Stock Ledger Entry,Stock Queue (FIFO),Čakalna vrsta (FIFO)
apps/erpnext/erpnext/controllers/buying_controller.py,Please enter 'Is Subcontracted' as Yes or No,"Prosimo, vnesite &quot;Ali je podizvajalec&quot; kot Da ali Ne"
DocType: Company,Default Holiday List,Privzeti seznam praznikov
DocType: Naming Series,Current Value,Trenutna vrednost
apps/erpnext/erpnext/config/accounting.py,"Seasonality for setting budgets, targets etc.","Sezonskost za določanje proračunov, ciljev itd."
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Opozorilo: prodajno naročilo {0} že obstaja za naročniško naročilo za nakup {1}
apps/erpnext/erpnext/utilities/user_progress.py,Monthly Sales Target (,Mesečni cilj prodaje (
DocType: Guardian,Guardian Interests,Interesi skrbnikov
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Batch ID is mandatory,ID serije je obvezen
DocType: Payment Entry,Paid Amount (Company Currency),Plačani znesek (valuta podjetja)
DocType: Shipping Rule Condition,Shipping Rule Condition,Pogoj pravila pošiljanja
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Maximum attempts for this quiz reached!,Doseženi so bili največji poskusi za ta kviz!
DocType: Employee Boarding Activity,Required for Employee Creation,Potrebno za ustvarjanje zaposlenih
DocType: Loyalty Point Entry Redemption,Loyalty Point Entry Redemption,Odkup vstopa na točko zvestobe
DocType: Job Applicant,Cover Letter,Spremno pismo
DocType: Chart of Accounts Importer,Chart Preview,Predogled grafikona
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Parameter za preverjanje kakovosti izdelka
DocType: Support Settings,Get Started Sections,Začnite razdelke
DocType: Delivery Note,% of materials delivered against this Delivery Note,"% materialov, dostavljenih na podlagi te dobavnice"
DocType: Warranty Claim,Warranty / AMC Status,Stanje garancije / AMC
apps/erpnext/erpnext/utilities/user_progress.py,Gram,Gram
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be negative,Dodeljeni znesek ne more biti negativen
DocType: POS Profile,Item Groups,Skupine postavk
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Customer LPO No.,LPO št. Strank
,Company Name,ime podjetja
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 1,V naslov 1
,Purchase Receipt Trends,Nakup trendov prejemanja
DocType: Leave Block List,Leave Block List Dates,Zapustite datume s seznama blokov
apps/erpnext/erpnext/education/doctype/student/student.py,Student {0} exist against student applicant {1},Študent {0} obstaja proti prijavitelju študentov {1}
DocType: Education Settings,LMS Settings,Nastavitve LMS
apps/erpnext/erpnext/config/settings.py,Titles for print templates e.g. Proforma Invoice.,"Naslovi za predloge za tiskanje, npr."
DocType: Serial No,Delivery Time,Čas dostave
DocType: Loan,Repayment Period in Months,Obdobje odplačevanja v mesecih
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Transporter ID,ID transporterja
apps/erpnext/erpnext/config/buying.py,Price List master.,Glavni cenik.
DocType: Department,The first Expense Approver in the list will be set as the default Expense Approver.,Prvi odobritev stroškov na seznamu bo nastavljen kot privzeti odobritev stroškov.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Advertising,Oglaševanje
DocType: Authorization Rule,Customer or Item,Stranka ali izdelek
DocType: Vehicle Log,Invoice Ref,Račun Ref
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,C-form is not applicable for Invoice: {0},Obrazec C ne velja za račun: {0}
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Invoice Created,Račun je ustvarjen
DocType: Shift Type,Early Exit Grace Period,Zgodnje izhodno obdobje Grace
DocType: Patient Encounter,Review Details,Podrobnosti o pregledu
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: Hours value must be greater than zero.,Vrstica {0}: Vrednost ure mora biti večja od nič.
DocType: Account,Account Number,Številka računa
DocType: Assessment Result Detail,Assessment Result Detail,Podrobnosti o oceni rezultatov
DocType: Support Settings,Auto close Issue after 7 days,Samodejno zaprtje Težava po 7 dneh
DocType: Supplier,Is Frozen,Je zamrznjen
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Total weightage assigned should be 100%. It is {0},Skupna dodeljena masa mora biti 100%. Je {0}
apps/erpnext/erpnext/regional/italy/setup.py,"Applicable if the company is SpA, SApA or SRL","Velja, če je družba SpA, SApA ali SRL"
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Overlapping conditions found between:,"Pogoji, ki se prekrivajo, so med:"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Paid and Not Delivered,Plačan in ni dostavljen
DocType: GST HSN Code,HSN Code,Kodeks HSN
DocType: GSTR 3B Report,September,September
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Administrative Expenses,Administrativni stroški
DocType: C-Form,C-Form No,C-obrazec št
DocType: Purchase Invoice,End date of current invoice's period,Končni datum trenutnega računa
DocType: Item,Manufacturers,Proizvajalci
DocType: Crop Cycle,Crop Cycle,Crop Cycle
DocType: Serial No,Creation Time,Čas ustvarjanja
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Vnesite vlogo za odobritev ali odobri uporabnika
DocType: Plaid Settings,Link a new bank account,Povežite nov bančni račun
DocType: Inpatient Record,Discharged,Izpuščen
DocType: BOM,Raw Material Cost(Company Currency),Stroški surovine (valuta podjetja)
apps/erpnext/erpnext/accounts/party.py,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Opomba: Datum zapadlosti / referenčnega obdobja presega dovoljene kreditne dni strank do {0} dneva
DocType: Email Digest,New Sales Orders,Novi prodajni nalogi
apps/erpnext/erpnext/buying/report/purchase_analytics/purchase_analytics.js,based_on,temelji na
DocType: Employee,Owned,V lasti
DocType: Item Default,Item Default,Predmet Privzeto
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Party can only be one of ,Stranka je lahko le ena od
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Entertainment Expenses,Stroški zabave
DocType: Item,Inspection Required before Delivery,Preverjanje je potrebno pred dobavo
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py,Opening Entry Journal,Odpiranje dnevnika vnosa
DocType: Purchase Taxes and Charges,Add or Deduct,Dodaj ali odštej
DocType: POS Closing Voucher Details,Collected Amount,Zbrani znesek
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Commission on Sales,Komisija za prodajo
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Start entering data from here : ,Začnite vnašati podatke od tukaj:
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Rest Of The World,Ostali svet
apps/erpnext/erpnext/templates/pages/home.html,Publications,Publikacije
DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,"Privzeti bančni / gotovinski račun bo samodejno posodobljen v vnosu plačne knjižice, ko bo izbran ta način."
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Skupni proračun
DocType: Upload Attendance,Upload HTML,Prenesite HTML
DocType: Bank Reconciliation Detail,Payment Document,Plačilni dokument
DocType: Opportunity Item,Opportunity Item,Priložnostni element
DocType: Travel Itinerary,Travel From,Potovanje iz
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,CWIP Account,Račun CWIP
DocType: SMS Log,Sender Name,Ime pošiljatelja
DocType: Pricing Rule,Supplier Group,Skupina dobaviteljev
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,"Set Start Time and End Time for  \
					Support Day {0} at index {1}.",Nastavite čas začetka in končni čas za dan podpore {0} v indeksu {1}.
DocType: Employee,Date of Issue,Datum izdaje
,Requested Items To Be Transferred,Zahtevane postavke za prenos
DocType: Employee,Contract End Date,Datum konca pogodbe
DocType: Purchase Order Item,Returned Qty,Vrnjena količina
DocType: Sales Order,SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-
DocType: Delivery Note,Required only for sample item.,Potrebno samo za vzorčno postavko.
DocType: Healthcare Service Unit,Vacant,Prazen
DocType: Opportunity,Sales Stage,Prodajna faza
DocType: Sales Order,In Words will be visible once you save the Sales Order.,"V besedi bo viden, ko shranite prodajni nalog."
DocType: Item Reorder,Re-order Level,Raven ponovnega naročanja
DocType: Shift Type,Enable Auto Attendance,Omogoči samodejno prisotnost
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Preference,Prednost
,Department Analytics,Analytics oddelka
DocType: Crop,Scientific Name,Znanstveno ime
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Discount amount cannot be greater than 100%,Znesek popustov ne sme biti večji od 100%
DocType: Student Guardian,Relation,Odnos
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py,Name or Email is mandatory,Ime ali e-pošta je obvezna
DocType: Tax Rule,Billing Zipcode,Poštna številka za obračunavanje
apps/erpnext/erpnext/public/js/hub/marketplace.js,Marketplace,Tržnica
apps/erpnext/erpnext/buying/utils.py,{0} {1} status is {2},Stanje {0} {1} je {2}
DocType: Quiz Activity,Quiz Activity,Dejavnost kviza
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,{0} is not in a valid Payroll Period,{0} ni v veljavnem obdobju plačevanja
DocType: Timesheet,Billed,Obračunano
apps/erpnext/erpnext/config/support.py,Issue Type.,Vrsta težave.
DocType: Restaurant Order Entry,Last Sales Invoice,Zadnji prodajni račun
DocType: Payment Terms Template,Payment Terms,Plačilni pogoji
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Reserved Qty: Quantity ordered for sale, but not delivered.","Rezervirano Količina: Količina, naročena za prodajo, vendar ne dostavljena."
apps/erpnext/erpnext/accounts/page/pos/pos.js,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2},{0} je obvezen. Morda zapis za menjavo valute ni ustvarjen za {1} do {2}
DocType: Task,Actual End Date (via Time Sheet),Dejanski datum konca (prek časovnega lista)
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js,Score must be less than or equal to 5,Rezultat mora biti manjši ali enak 5
apps/erpnext/erpnext/controllers/buying_controller.py,Please select BOM in BOM field for Item {0},Izberite polje BOM v polju BOM za element {0}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} is under warranty upto {1},Serijska št. {0} je v garanciji do {1}
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split,Split
DocType: Bank Account,Bank Account No,Bančni račun št
DocType: Payroll Entry,Salary Slip Based on Timesheet,Izplačilo plač na podlagi urnika
DocType: Program Enrollment,Mode of Transportation,Način prevoza
DocType: Budget,Control Action,Nadzorni ukrep
DocType: Employee Tax Exemption Declaration,Total Exemption Amount,Skupni znesek oprostitve
DocType: Medical Code,Medical Code Standard,Standard medicinske kode
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Reqd by Date cannot be before Transaction Date,Vrstica # {0}: Zahteva po datumu ne more biti pred datumom transakcije
DocType: Education Settings,Current Academic Term,Trenutni akademski mandat
DocType: Employee,Short biography for website and other publications.,Kratka biografija za spletno stran in druge publikacije.
DocType: Purchase Invoice Item,Received Qty,Prejete količine
DocType: Purchase Invoice Item,Rate (Company Currency),Cena (valuta podjetja)
DocType: Item Reorder,Request for,Prošnja za
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Installing presets,Namestitev prednastavitev
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter Repayment Periods,Vnesite obdobja odplačevanja
DocType: Pricing Rule,Advanced Settings,Napredne nastavitve
DocType: Payment Entry,Paid Amount,Plačan znesek
DocType: Setup Progress Action,Setup Progress Action,Nastavitev napredovanja
DocType: Subscription Plan,Billing Interval Count,Interval obračunavanja
apps/erpnext/erpnext/public/js/financial_statements.js,Financial Statements,Finančne izjave
DocType: Project,Message will sent to users to get their status on the project,"Sporočilo bo poslano uporabnikom, da dobijo status projekta"
DocType: Employee Tax Exemption Proof Submission Detail,Employee Tax Exemption Proof Submission Detail,Podrobnosti o oprostitvi plačila davka od zaposlenih
DocType: Purchase Order,Delivered,Dostavljeno
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Delivered,{0}% Dostavljeno
DocType: Lead,Request for Information,Prošnja za informacije
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,End Year,Končno leto
DocType: Vehicle,Diesel,Diesel
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankcionirani znesek ne sme biti višji od zneska zahtevka v vrstici {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,Rezultat je že poslan
DocType: Pricing Rule Detail,Rule Applied,Uporabljeno pravilo
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Actual Qty is mandatory,Dejanska količina je obvezna
DocType: Purchase Order Item,Expected Delivery Date,Pričakovani datum dobave
DocType: Issue,Resolution Date,Datum razrešitve
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave of type {0} cannot be longer than {1},Pustitev vrste {0} ne sme biti daljša od {1}
DocType: Shopping Cart Settings,Enable Shopping Cart,Omogoči nakupovalno košarico
DocType: Pricing Rule,Apply Rule On Other,Uporabi pravilo za drugo
DocType: Vehicle,Last Carbon Check,Zadnji pregled ogljika
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Make,Znamka
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Sales Invoice {0} created as paid,Račun za prodajo {0} je bil ustvarjen kot plačan
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Za izdelavo zahtevka za plačilo je potreben referenčni dokument
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Income Tax,Davek na prihodek
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Computer,Računalnik
DocType: Material Request,% Ordered,% Naročeno
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,Naslednje postavke {0} niso označene kot element {1}. Omogočite jih lahko kot element {1} iz glavnega elementa
DocType: Quiz,Passing Score,Zmogljivost
apps/erpnext/erpnext/config/website.py,Settings for website homepage,Nastavitve za domačo stran spletnega mesta
DocType: Work Order,Qty To Manufacture,Količina za izdelavo
apps/erpnext/erpnext/public/js/setup_wizard.js,Non Profit (beta),Dobiček (beta)
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Outstanding Amt,Neporavnani amt
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Pin Code,PIN koda
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,"Naslednjim uporabnikom dovolite, da odobrijo pustite aplikacije za blok dni."
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Please select Maintenance Status as Completed or remove Completion Date,Izberite Stanje vzdrževanja kot končano ali odstranite datum dokončanja
DocType: Production Plan,Get Items For Work Order,Pridobite artikle za delovni nalog
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Project and all Tasks to status {0}?,Nastavite Project in vse naloge na stanje {0}?
DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Prikaži &quot;Na zalogi&quot; ali &quot;Ni na zalogi&quot; glede na zalogo, ki je na voljo v tem skladišču."
apps/erpnext/erpnext/accounts/page/pos/pos.js,Delete permanently?,Želite trajno izbrisati?
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,Izbrati je treba vsaj enega od ustreznih modulov
DocType: Leave Type,Is Leave Without Pay,Pusti brez plačila
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} must be submitted,Predložiti je treba vrstico # {0}: Sredstvo {1}
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Dodatni znesek popustov (valuta podjetja)
DocType: Patient,Tobacco Past Use,Pretekla uporaba tobaka
DocType: Crop,Materials Required,Potrebni materiali
DocType: POS Profile,POS Profile,POS profil
DocType: Journal Entry,Write Off Entry,Napiši vnos
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.,"Če želite registrirati na spletnem mestu Marketplace, morate biti uporabnik, ki ni skrbnik s funkcijami upravitelja sistema in upravitelja izdelkov."
DocType: Asset,Insured value,Zavarovana vrednost
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","Ker je predvidena količina surovin večja od zahtevane količine, ni potrebe po izdelavi materialne zahteve. Če želite izdelati zahtevo za material, potrdite polje <b>Zanemari obstoječo predvideno količino</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} vnosov plačil ni mogoče filtrirati do {1}
DocType: Variant Field,Variant Field,Variantno polje
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py,Access token or Shopify URL missing,Manjka žeton za dostop ali URL trgovine Shopify
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Bank account cannot be named as {0},Bančnega računa ni mogoče poimenovati kot {0}
DocType: Terms and Conditions,Terms and Conditions Help,Pravila in pogoji Pomoč
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,From and To dates required,Potrebni datumi od in do
DocType: Production Plan Item,Product Bundle Item,Element paketa izdelka
DocType: Student Group,Group Based On,Na osnovi skupine
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Mobile No,Guardian2 Mobile No
DocType: Manufacturing Settings,Allow Multiple Material Consumption,Dovoli večjo porabo materiala
DocType: Item Quality Inspection Parameter,Acceptance Criteria,Merila sprejemljivosti
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Pravilo o dostavi velja samo za prodajo
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Selling Rate,Stopnja prodaje
DocType: Account,Asset,Sredstvo
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} nima programa Zdravstveni delavec. Dodajte ga v nadrejenega zdravnika
DocType: Vehicle,Chassis No,Št
DocType: Employee,Default Shift,Privzeti premik
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation,Okrajšava podjetja
apps/erpnext/erpnext/config/manufacturing.py,Tree of Bill of Materials,Drevo gradiva
DocType: Article,LMS User,Uporabnik LMS
DocType: BOM,Allow Alternative Item,Dovoli alternativno postavko
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Strošek dejavnosti na zaposlenega
DocType: Email Digest,Open Quotations,Odpri ponudbe
DocType: Cash Flow Mapper,Section Footer,Noga odseka
DocType: Lead,Next Contact By,Naslednji stik z
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Pending Quantity,Predvidena količina
DocType: Quotation,SAL-QTN-.YYYY.-,SAL-QTN-.YYYY.-
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select to add Serial Number.,"Izberite, da dodate serijsko številko."
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html,modified,spremenjena
DocType: Pricing Rule,Qty,Kol
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Neto ITC na voljo (A) - (B)
,Material Requests for which Supplier Quotations are not created,"Zahteve za material, za katere ponudniki niso izdelani"
apps/erpnext/erpnext/public/js/education/lms/quiz.js,Something went wrong while evaluating the quiz.,Nekaj je šlo narobe med ocenjevanjem kviza.
DocType: GST Account,GST Account,Račun GST
DocType: Pricing Rule,For Price List,Za cenik
DocType: GoCardless Mandate,GoCardless Mandate,Mandat GoCardless
DocType: Work Order,Skip Material Transfer to WIP Warehouse,Preskoči prenos materiala v WIP skladišče
DocType: Training Event Employee,Feedback Submitted,Oddaja povratnih informacij
DocType: Cheque Print Template,Primary Settings,Primarne nastavitve
DocType: Amazon MWS Settings,Customer Type,Tip stranke
DocType: Supplier Scorecard Period,PU-SSP-.YYYY.-,PU-SSP-.YYYY.-
DocType: POS Settings,Use POS in Offline Mode,Uporabite POS v načinu brez povezave
DocType: Territory,Parent Territory,Nadrejeno ozemlje
DocType: Vehicle Log,Odometer Reading,Odčitavanje prevoženih kilometrov
DocType: Additional Salary,Salary Slip,Izplačilo plač
DocType: Payroll Entry,Payroll Frequency,Frekvenca plač
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}.,Vrstica # {0}: Operacija {1} ni končana za {2} število dokončanih izdelkov v delovnem nalogu {3}. Posodobite stanje delovanja prek Job Card {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}","Začetni in končni datumi, ki niso v veljavnem obdobju plačil, ne morejo izračunati {0}"
DocType: Products Settings,Home Page is Products,Domača stran je Izdelki
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Calls,Klici
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference #{0} dated {1},Sklic # {0} z dne {1}
DocType: Guardian Interest,Guardian Interest,Interes skrbnika
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,PO already created for all sales order items,PO je že ustvarjena za vse postavke prodajnega naročila
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Subscription,Naročnina
DocType: Stock Entry Detail,Stock Entry Detail,Podrobnosti o vstopu v zalogo
DocType: Email Digest,Sales Orders to Bill,Prodajni nalogi do računa
DocType: Company,For reference only.,Samo za referenco.
DocType: GL Entry,GL Entry,GL Entry
DocType: Employee Tax Exemption Category,Employee Tax Exemption Category,Kategorija oprostitve davka na zaposlene
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Row {0}: asset is required for item {1},Vrstica {0}: sredstvo je obvezno za element {1}
DocType: Expense Claim Detail,Sanctioned Amount,Sankcionirani znesek
apps/erpnext/erpnext/accounts/doctype/subscription_plan/subscription_plan.py,Billing Interval Count cannot be less than 1,Število intervalov obračunavanja ne sme biti manjše od 1
DocType: Taxable Salary Slab,Taxable Salary Slab,Obdavčljiva plačna plošča
DocType: Grant Application,Grant Application,Vloga za odobritev
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,Ne morem najti zadetka z začetkom na {0}. Stalni rezultati morajo biti od 0 do 100
DocType: Fee Structure,EDU-FST-.YYYY.-,EDU-FST-.YYYY.-
DocType: Sales Person,Parent Sales Person,Matična prodajna oseba
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,View all issues from {0},Oglejte si vsa vprašanja od {0}
DocType: Student Group Creation Tool,Get Courses,Pridobite tečaje
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.","Vrstica # {0}: Količina mora biti 1, ker je postavka osnovno sredstvo. Uporabite ločeno vrstico za večkratno količino."
DocType: Shift Type,Working hours below which Absent is marked. (Zero to disable),"Delovne ure, pod katerimi je označena odsotnost. (Nič do onemogočenja)"
DocType: Customer Group,Only leaf nodes are allowed in transaction,V transakciji so dovoljene le listne vozlišča
DocType: Grant Application,Organization,Organizacija
DocType: Fee Category,Fee Category,Kategorija plačila
DocType: Batch,Batch ID,ID serije
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot be a fixed asset item as Stock Ledger is created.,"Ne more biti postavka osnovnega sredstva, ko je ustvarjena zaloga zaloge."
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,This Month's Summary,Povzetek tega meseca
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: {1} {2} does not match with {3},Vrstica {0}: {1} {2} se ne ujema z {3}
apps/erpnext/erpnext/utilities/user_progress.py,Go to Suppliers,Pojdite na dobavitelje
DocType: Payment Order,PMO-,PMO-
apps/erpnext/erpnext/templates/emails/training_event.html,Please update your status for this training event,Posodobite svoje stanje za to usposabljanje
DocType: Volunteer,Morning,Jutro
DocType: Quotation Item,Quotation Item,Postavka ponudbe
apps/erpnext/erpnext/config/support.py,Issue Priority.,Prednostna naloga.
DocType: Journal Entry,Credit Card Entry,Vnos s kreditno kartico
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Časovna reža je preskočena, reža {0} do {1} prekriva obstoječo režo {2} do {3}"
DocType: Journal Entry Account,If Income or Expense,Če dohodek ali odhodek
DocType: Work Order Operation,Work Order Operation,Delovni nalog
DocType: Accounts Settings,Address used to determine Tax Category in transactions.,"Naslov, ki se uporablja za določitev davčne kategorije v transakcijah."
apps/erpnext/erpnext/utilities/user_progress.py,Go to Customers,Pojdi na Stranke
DocType: Student Group,Set 0 for no limit,Nastavite 0 brez omejitve
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} is inactive,{0} {1}: Račun {2} je neaktiven
DocType: Repayment Schedule,Payment Date,Dan plačila
DocType: Asset Maintenance Task,Assign To Name,Dodeli ime
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Warning: Material Requested Qty is less than Minimum Order Qty,Opozorilo: zahtevana količina materiala je manjša od minimalne količine naročila
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Current BOM and New BOM can not be same,Trenutni BOM in New BOM ne moreta biti enaka
apps/erpnext/erpnext/config/agriculture.py,Crops & Lands,Pridelki in zemlje
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbr can not be blank or space,Abbr ne sme biti prazen ali presledek
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}","Serijske številke {0} elementa {1} ni mogoče dostaviti, ker je rezervirano za izpolnjevanje prodajnega naloga {2}"
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Fetching records......,Pridobivanje zapisov ......
DocType: Delivery Stop,Contact Information,Kontaktni podatki
DocType: Sales Order Item,For Production,Za proizvodnjo
DocType: Serial No,Asset Details,Podrobnosti sredstva
DocType: Restaurant Reservation,Reservation Time,Čas rezervacije
DocType: Selling Settings,Default Territory,Privzeto območje
DocType: Employee Benefit Application,Dispensed Amount (Pro-rated),Izplačani znesek (pro-ocenjeno)
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Max discount allowed for item: {0} is {1}%,Najvišji dovoljeni popust za element: {0} je {1}%
DocType: Product Bundle,List items that form the package.,"Seznam elementov, ki tvorijo paket."
DocType: Payment Request,Amount in customer's currency,Znesek v valuti stranke
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Pridobite elemente iz potrdil o nakupu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0} (Payment Table): Amount must be positive,Vrstica # {0} (Tabela plačil): Znesek mora biti pozitiven
DocType: Employee Tax Exemption Declaration,Employee Tax Exemption Declaration,Izjava o oprostitvi davka na zaposlene
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Finding linked payments,Iskanje povezanih plačil
DocType: Project,Expected End Date,Pričakovani končni datum
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Conversion rate cannot be 0 or 1,Stopnja konverzije ne more biti 0 ali 1
DocType: Opportunity,CRM-OPP-.YYYY.-,CRM-OPP-.YYYY.-
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Name,Ime inštituta
DocType: Serial No,Asset Status,Stanje sredstva
DocType: Salary Slip,Earnings,Zaslužki
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Total Paid Amount,Skupni plačani znesek
apps/erpnext/erpnext/stock/doctype/batch/batch.js,To Warehouse,V skladišče
DocType: Appraisal,Total Score (Out of 5),Skupni rezultat (od 5)
DocType: Journal Entry,Accounts Receivable,Terjatve do kupcev
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Setting defaults,Nastavitev privzetih vrednosti
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.","Ne morem zagotoviti dostave po serijski številki, ker je element {0} dodan z ali brez Zagotoviti dostavo"
,Invoiced Amount (Exclusive Tax),Obračunani znesek (izključni davek)
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Cannot change status as student {0} is linked with student application {1},Statusa študenta ni mogoče spremeniti. {0} je povezan s prijavo za študente {1}
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total leaves allocated is mandatory for Leave Type {0},Skupno število dodeljenih listov je obvezno za vrsto zapustitve {0}
apps/erpnext/erpnext/config/getting_started.py,Data Import and Settings,Uvoz podatkov in nastavitve
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)","Če je izbrana možnost Samodejni vklop, bodo stranke samodejno povezane z zadevnim programom zvestobe (ob shranjevanju)"
DocType: Account,Expense Account,Stroškovni račun
DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"Čas pred začetkom izmene, med katerim se šteje za prijavo zaposlenega."
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian1,Povezava z varuhom1
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.js,Create Invoice,Ustvari račun
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Request already exists {0},Zahtevek za plačilo že obstaja {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Employee relieved on {0} must be set as 'Left',"Zaposleni, ki je bil odpuščen {0}, mora biti nastavljen kot &quot;levo&quot;"
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py,Pay {0} {1},Plačajte {0} {1}
DocType: Company,Sales Settings,Prodajne nastavitve
DocType: Sales Order Item,Produced Quantity,Proizvedena količina
apps/erpnext/erpnext/templates/emails/request_for_quotation.html,The request for quotation can be accessed by clicking on the following link,Do zahteve za ponudbo lahko dostopate s klikom na naslednjo povezavo
DocType: Monthly Distribution,Name of the Monthly Distribution,Ime mesečne distribucije
DocType: Production Plan,Get Raw Materials For Production,Pridobite surovine za proizvodnjo
DocType: Employee,New Workplace,Novo delovno mesto
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","Manjka vrednost za geslo, ključ API ali URL za Shopify"
DocType: Supplier Scorecard Scoring Variable,Parameter Name,Ime 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},Račun {0} se ne ujema s podjetjem {1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select an item in the cart,Izberite element v vozičku
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Create Payment Entries,Ustvarite plačilne vnose
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Select Company,Izberite podjetje
DocType: Material Request Plan Item,Material Request Type,Vrsta zahteve za material
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Member ID,ID člana
DocType: Issue,Raised By (Email),Povišano z (E-pošta)
DocType: Employee Health Insurance,Employee Health Insurance,Zdravstveno zavarovanje zaposlenih
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Application period cannot be outside leave allocation period,Obdobje uporabe ne sme biti izven obdobja dodelitve dopusta
DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Če ni označeno, element ne bo prikazan v računu za prodajo, temveč se lahko uporabi pri ustvarjanju skupinskih testov."
DocType: Healthcare Settings,Registration Fee,Kotizacija
,Produced,Proizvedeno
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,White,Bela
DocType: Clinical Procedure,Procedure Template,Predloga postopka
DocType: Account,Frozen,Zamrznjeno
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Price not found for item {0} in price list {1},Cena ni na voljo za izdelek {0} v ceniku {1}
DocType: Student Admission,Publish on website,Objavi na spletnem mestu
apps/erpnext/erpnext/portal/doctype/homepage/homepage.py,This is an example website auto-generated from ERPNext,"To je primer spletne strani, ki je samodejno ustvarjena iz ERPNext"
DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Prekličite plačilo ob preklicu računa
apps/erpnext/erpnext/templates/pages/projects.html,No tasks,Ni nalog
DocType: Delivery Note,Print Without Amount,Tiskanje brez zneska
apps/erpnext/erpnext/config/buying.py,Purchase Orders given to Suppliers.,Naročila dobaviteljem.
,Reserved,Rezervirano
DocType: Employee,Notice (days),Obvestilo (dnevi)
apps/erpnext/erpnext/config/help.py,Setting up Email Account,Nastavitev e-poštnega računa
DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
DocType: Contract,Unsigned,Nepodpisan
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.,"Dnevi, na katere se prijavljate za dopust, so prazniki. Ni vam treba zaprositi za dopust."
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Could not submit some Salary Slips,Ne morem predložiti nekaj plače
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},"Skladišča {0} ni mogoče izbrisati, ker obstaja količina za element {1}"
DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Potrdilo o nakupu iztovorjenih stroškov
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Approve,Odobri
apps/erpnext/erpnext/hr/page/team_updates/team_updates.js,No more updates,Ni več posodobitev
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,Leaves Allocated Successfully for {0},Levi dodeljeni uspehi za {0}
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Report,Poročilo o oceni
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.","Če ne želite uporabiti Pravilnika za določanje cen v določeni transakciji, morate onemogočiti vsa veljavna Pravila za določanje cen."
DocType: Company,Default Deferred Revenue Account,Privzeti račun z odloženim prihodkom
apps/erpnext/erpnext/config/non_profit.py,Donor information.,Informacije o darovalcu.
DocType: Authorization Rule,Customerwise Discount,Popust na kupca
DocType: Stock Ledger Entry,Outgoing Rate,Odhodna stopnja
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Prosimo, da izberete Dodeljeni znesek, Vrsta fakture in Številka računa v vsaj eni vrstici"
DocType: Asset Category,Asset Category Name,Ime kategorije sredstev
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Receipt document must be submitted,Predložiti je treba potrdilo o prejemu
,Employee Advance Summary,Povzetek vnaprej zaposlenih
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Please check the error log for details about the import errors,Za podrobnosti o napakah pri uvozu preverite dnevnik napak
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Detailed Reason,Podroben razlog
apps/erpnext/erpnext/healthcare/setup.py,Low Sensitivity,Nizka občutljivost
apps/erpnext/erpnext/accounts/doctype/bank_transaction/bank_transaction.py,The total allocated amount ({0}) is greated than the paid amount ({1}).,Skupni dodeljeni znesek ({0}) je večji od plačanega zneska ({1}).
DocType: Authorization Rule,Applicable To (Designation),Velja za (označba)
DocType: Tax Rule,Billing City,Mesto plačevanja
DocType: Item,Is Customer Provided Item,"Je predmet, ki ga je dobavil kupec"
DocType: Purchase Invoice,Purchase Taxes and Charges Template,Predloga za nabavo davkov in dajatev
DocType: Sales Invoice Item,Brand Name,Blagovna znamka
DocType: Fee Schedule,Total Amount per Student,Skupni znesek na študenta
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Apparel & Accessories,Oblačila in dodatki
DocType: Compensatory Leave Request,Work From Date,Delo od datuma
apps/erpnext/erpnext/projects/doctype/project/project.py,Project Collaboration Invitation,Vabilo za sodelovanje pri projektu
DocType: Student Attendance Tool,Student Attendance Tool,Orodje za udeležbo učencev
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Prescribed Procedures,Predpisani postopki
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py,Unable to find variable: ,Ni mogoče najti spremenljivke:
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,PDC/LC Amount,Znesek PDC / LC
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Set Details,Nastavi podrobnosti
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total claimed amount,Skupni znesek predplačila ne sme biti višji od skupnega zahtevanega zneska
DocType: POS Item Group,Item Group,Skupina postavk
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Trenutno ni na zalogi v nobenem skladišču
apps/erpnext/erpnext/utilities/user_progress.py,Upload your letter head (Keep it web friendly as 900px by 100px),Naložite glavo pisma (naj bo spletno prijazno 900px s 100px)
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item {0} is not setup for Serial Nos. Column must be blank,Element {0} ni nastavljen za serijske številke. Stolpec mora biti prazen
DocType: Company,Default Values,Privzete vrednosti
apps/erpnext/erpnext/setup/doctype/company/company.js,Default tax templates for sales and purchase are created.,Ustvarjene so privzete predloge za davek za prodajo in nakup.
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leave Type {0} cannot be carry-forwarded,Tipa zapustitve {0} ni mogoče prenesti
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To account must be a Receivable account,Bremenitev Račun mora biti račun terjatev
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,End Date of Agreement can't be less than today.,Datum konca pogodbe ne sme biti manjši kot danes.
apps/erpnext/erpnext/stock/__init__.py,Please set Account in Warehouse {0} or Default Inventory Account in Company {1},Nastavite račun v skladišču {0} ali privzetem računu inventarja v podjetju {1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Set as Default,Ponastavi
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Neto teža tega paketa. (izračunano samodejno kot vsota neto teže postavk)
apps/erpnext/erpnext/stock/doctype/item_variant_settings/item_variant_settings.py,Cannot set the field <b>{0}</b> for copying in variants,Polja <b>{0}</b> ni mogoče nastaviti za kopiranje v različicah
DocType: Payment Term,Month(s) after the end of the invoice month,Mesec / mesec po koncu meseca računa
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Get Employees,Pridobite zaposlene
DocType: Student,Leaving Certificate Number,Številka potrdila o izstopu
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js,Not Expired,Ni potekla
DocType: Company,Unrealized Exchange Gain/Loss Account,Nerealizirani račun dobička / izgube iz tečajne razlike
DocType: Employee,Relieving Date,Datum odstranitve
DocType: Plant Analysis,Plant Analysis Criterias,Kriteriji za analizo rastlin
DocType: Leave Block List Date,Leave Block List Date,Zapusti datum blokovnega seznama
DocType: Payment Entry,Receive,Prejeti
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Relieving Date must be greater than Date of Joining,Datum sproščanja mora biti večji od datuma pridružitve
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Error: Not a valid id?,Napaka: ni veljaven 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.","Zamenjajte določeno BOM v vseh drugih BOM, kjer se uporablja. Zamenjal bo staro povezavo BOM, stroške posodobitve in regeneriral tabelo &quot;BOM Explosion Item&quot; kot na novo BOM. Prav tako posodobi najnovejšo ceno v vseh BOM."
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,"Company, Payment Account, From Date and To Date is mandatory","Podjetje, plačilni račun, datum in datum je obvezen"
DocType: Sales Invoice Payment,Base Amount (Company Currency),Osnovni znesek (valuta podjetja)
DocType: Sales Invoice Advance,Sales Invoice Advance,Akontacija prodajnega računa
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Notify Customers via Email,Obvestite stranke po e-pošti
DocType: Production Plan Item,Make Work Order for Sub Assembly Items,Naredite delovni nalog za elemente v podskupini
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Manager,Manager
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Expired Batches,Potekle serije
DocType: Shipping Rule,Shipping Rule Type,Vrsta pravila pošiljanja
DocType: Job Offer,Accepted,Sprejeto
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,You have already assessed for the assessment criteria {}.,Ocenjevalna merila {} ste že ocenili.
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch Numbers,Izberite Serijske številke
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Age (Days),Starost (dnevi)
DocType: Student Batch Name,Batch Name,Ime paketa
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Large,Velika
apps/erpnext/erpnext/controllers/accounts_controller.py,Accounting Entry for {0}: {1} can only be made in currency: {2},Računovodski vnos za {0}: {1} je lahko samo v valuti: {2}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for hold: ,Razlog za zadržanje:
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Failed,Ustvarjanje provizije ni uspelo
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Reorder Level,Nivo naročanja
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} '{1}' is disabled,{0} &#39;{1}&#39; je onemogočen
DocType: Stock Ledger Entry,Actual Qty After Transaction,Dejanska količina po transakciji
DocType: Subscription,Cancel At End Of Period,Prekliči ob koncu obdobja
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js,Healthcare Service Unit Tree,Drevo enot zdravstvenih storitev
apps/erpnext/erpnext/config/buying.py,Bundle items at time of sale.,Združite elemente v času prodaje.
DocType: Payment Reconciliation Payment,Allocated Amount,Dodeljeni znesek
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,Please select Company and Designation,Izberite podjetje in oznaka
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&quot;Datum&quot; je obvezen
DocType: Email Digest,Bank Credit Balance,Stanje bančnega kredita
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Pokaži skupni znesek
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,You don't have enought Loyalty Points to redeem,"Niste pridobili točk zvestobe, ki bi jih unovčili"
DocType: Purchase Invoice,Additional DIscount Percentage,Dodatni odstotek DIscount
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the name of the bank or lending institution before submittting.,Pred oddajo vnesite ime banke ali posojilne institucije.
apps/erpnext/erpnext/controllers/accounts_controller.py,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,"Opozorilo: Sistem ne bo preverjal preračunavanja, ker je znesek za element {0} v {1} nič"
apps/erpnext/erpnext/public/js/setup_wizard.js,Select your Domains,Izberite svoje domene
DocType: Agriculture Task,Task Name,Ime opravila
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Stock Entries already created for Work Order ,Vnosi v zalogi so že ustvarjeni za delovni nalog
,Amount to Deliver,Znesek za dostavo
apps/erpnext/erpnext/accounts/doctype/account/account.py,Company {0} does not exist,Podjetje {0} ne obstaja
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,No pending Material Requests found to link for the given items.,Za povezavo za dane elemente ni bilo najdenih nerešenih zahtevkov za material.
apps/erpnext/erpnext/utilities/activation.py,"Students are at the heart of the system, add all your students","Učenci so v središču sistema, dodajte vse svoje učence"
DocType: Company,Company Logo,Logotip podjetja
DocType: Content Question,Question Link,Povezava z vprašanjem
DocType: HR Settings,Leave Approver Mandatory In Leave Application,Odobri opustitev Obvezno v aplikaciji Pusti
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Add notes,Dodajte opombe
apps/erpnext/erpnext/templates/generators/item/item_configure.js,{0} items found.,Najdenih je bilo {0} elementov.
DocType: Patient,Personal and Social History,Osebna in socialna zgodovina
DocType: Maintenance Visit Purpose,Work Done,Delo končano
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}","Nastavitev dogodkov na {0}, ker zaposleni, ki je priključen na spodnje prodajne osebe, nima ID-ja uporabnika {1}"
DocType: Student Guardian,Father,Oče
,Purchase Order Items To Be Received,"Postavke naročilnice, ki jih je treba prejeti"
apps/erpnext/erpnext/accounts/general_ledger.py,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Bremenitve in krediti niso enaki za {0} # {1}. Razlika je {2}.
DocType: Marketplace Settings,Custom Data,Podatki po meri
DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,"V besedi bo viden, ko shranite naročilo."
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Actual type tax cannot be included in Item rate in row {0},Dejanski davek za vrsto izdelka ne more biti vključen v ceno postavke v vrstici {0}
DocType: Lab Test Template,Compound,Spojina
DocType: Quotation,Rate at which customer's currency is converted to company's base currency,"Stopnja, pri kateri se valuta stranke pretvori v osnovno valuto podjetja"
DocType: Lead,Converted,Pretvorjeno
DocType: Email Digest,New Income,Novi dohodek
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Retention Stock Entry already created or Sample Quantity not provided,Zadržana zaloga Vpis že ustvarjen ali vzorčna količina ni zagotovljena
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Vouchers,Obdelava kuponov
DocType: Support Settings,Allow Resetting Service Level Agreement,Dovoli ponastavitev sporazuma o ravni storitev
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please enter Item Code to get batch no,"Vnesite Šifro postavke, da dobite paket št"
apps/erpnext/erpnext/public/js/controllers/transaction.js,Service Stop Date cannot be before Service Start Date,Datum servisnega postanka ne more biti pred začetkom storitve
DocType: Employee Property History,Employee Property History,Zgodovina premoženja zaposlenih
,Requested Items To Be Ordered,Zahtevane postavke za naročanje
DocType: Vital Signs,Blood Pressure (systolic),Krvni tlak (sistolični)
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Leave Without Pay does not match with approved Leave Application records,Pusti brez plačila se ne ujema z odobrenimi zapisi o zapustitvi aplikacije
DocType: Purchase Invoice Item,Expense Head,Stroškovna glava
DocType: Employee,Reason for Resignation,Razlog za odstop
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Fetch Subscription Updates,Prenos posodobitev naročnine
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Izplačani znesek + Pisanje Odpisani znesek ne sme biti večji od skupnega zneska
DocType: Asset Repair,Error Description,Opis napake
DocType: Healthcare Practitioner,Out Patient Consulting Charge Item,Out Patient Consulting Charge Item
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Invoice,Nov račun
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,No replies from,Ni odgovorov od
DocType: Shopify Settings,Sales Order Series,Serija prodajnih naročil
DocType: Accounts Settings,Automatically Fetch Payment Terms,Samodejno pridobite pogoje plačila
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,"Številke vrstic, ki so večje ali enake trenutni številki vrstice za ta tip polnjenja, ni mogoče napotiti"
apps/erpnext/erpnext/public/js/hub/components/reviews.js,Anonymous,Anonimno
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please select the Company,Izberite podjetje
apps/erpnext/erpnext/accounts/page/pos/pos.js,"Master data syncing, it might take some time",Sinhronizacija glavnih podatkov lahko traja nekaj časa
DocType: Leave Application,HR-LAP-.YYYY.-,HR-LAP-.LLLL.-
DocType: Item,Customer Items,Postavke strank
DocType: Program Enrollment,Enrolled courses,Vpisani tečaji
DocType: Lab Prescription,Test Code,Preskusni kod
DocType: Purchase Taxes and Charges,On Previous Row Total,Na prejšnji vrstici Skupaj
DocType: Student,Student Email Address,E-naslov študenta
,Delayed Item Report,Zapoznelo poročilo o postavki
DocType: Academic Term,Education,Izobraževanje
DocType: Supplier Quotation,Supplier Address,Naslov dobavitelja
DocType: Salary Detail,Do not include in total,Ne vključujte skupaj
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot set multiple Item Defaults for a company.,Za podjetje ni mogoče nastaviti več privzetih vrednosti elementov.
apps/erpnext/erpnext/accounts/party.py,{0}: {1} does not exists,{0}: {1} ne obstaja
DocType: Purchase Receipt Item,Rejected Quantity,Zavrnjena količina
DocType: Cashier Closing,To TIme,V TIme
DocType: Daily Work Summary Group User,Daily Work Summary Group User,Dnevni uporabnik skupine Povzetek dela
DocType: Fiscal Year Company,Fiscal Year Company,Poslovno leto Podjetje
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Alternative item must not be same as item code,Alternativni element ne sme biti enak kodi izdelka
DocType: Payment Schedule,Payment Term,Pogoji plačila
DocType: Quality Action,Quality Review,Pregled kakovosti
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,In Stock Qty,Na zalogi Količina
DocType: Material Request Plan Item,Customer Provided,Naročnik
apps/erpnext/erpnext/projects/doctype/task/task.py,Child Task exists for this Task. You can not delete this Task.,Za to opravilo obstaja podrejena naloga. Tega opravila ne morete izbrisati.
DocType: Item,Inventory,Inventar
apps/erpnext/erpnext/regional/india/utils.py,Either GST Transporter ID or Vehicle No is required if Mode of Transport is Road,"Če je način prevoza cestni, se zahteva GST Transporter ID ali številka vozila"
DocType: Supplier Scorecard Criteria,Criteria Name,Ime merila
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Total Allocated Leaves,Skupni dodeljeni listi
DocType: Chapter,Members,Člani
DocType: Fees,Student Details,Podrobnosti o študentih
DocType: Account,Fixed Asset,Osnovno sredstvo
DocType: Cheque Print Template,Has Print Format,Ima format za tiskanje
DocType: Training Result Employee,Training Result Employee,Rezultat usposabljanja uslužbenec
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with child nodes cannot be set as ledger,Računa z otrokovimi vozlišči ni mogoče nastaviti kot knjigo
apps/erpnext/erpnext/config/help.py,Purchase Order to Payment,Naročilo za plačilo
apps/erpnext/erpnext/agriculture/doctype/disease/disease.py,Start day is greater than end day in task '{0}',Začetni dan je večji od končnega dneva v opravilu &#39;{0}&#39;
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Financing,Neto denar iz financiranja
DocType: Quiz,Enter 0 to waive limit,Vnesite 0 za omejitev omejitve
apps/erpnext/erpnext/accounts/doctype/cashier_closing/cashier_closing.py,From Time Should Be Less Than To Time,Od časa bi moralo biti krajše od časa
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Newspaper Publishers,Založniki časopisov
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Supplier is required against Payable account {2},{0} {1}: dobavitelj je obvezen proti plačljivemu računu {2}
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Outstanding Cheques and Deposits to clear,Neporavnane preglede in vloge
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,You can only have Plans with the same billing cycle in a Subscription,V naročnini lahko imate samo načrte z enakim obračunskim ciklom
DocType: Vehicle,Natural Gas,Zemeljski plin
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} not found,Serijska številka {0} ni bila najdena
DocType: Hub User,Hub Password,Geslo strežnika
,Bank Reconciliation Statement,Izjava o bančni poravnavi
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Fixed Asset,Neto sprememba osnovnega sredstva
DocType: Payment Request,Paid,Plačan
DocType: Maintenance Visit,Completion Status,Stanje dokončanja
DocType: Job Card,Transferred Qty,Prenesena količina
DocType: Healthcare Service Unit,Occupied,Zasedeno
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Opening {0} Invoice created,Odpiranje {0} Ustvarjen račun
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to create website,Spletnega mesta ni bilo mogoče ustvariti
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Opportunities by lead source,Priložnosti iz vodilnega vira
DocType: Grading Scale Interval,Grading Scale Interval,Interval merilne lestvice
DocType: Education Settings,Instructor Records to be created by,"Inštruktorske zapise, ki jih bo ustvaril"
DocType: Student Report Generation Tool,Student Report Generation Tool,Orodje za generiranje študentskega poročila
apps/erpnext/erpnext/stock/doctype/batch/batch.js,View Ledger,Ogled knjige
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Vse druge pripombe, pomembna prizadevanja, ki bi morala iti v evidenco."
DocType: Travel Request,"Details of Sponsor (Name, Location)","Podrobnosti sponzorja (ime, lokacija)"
DocType: Task,Weight,Utež
DocType: Staffing Plan Detail,Current Count,Trenutno število
DocType: Sales Team,Incentives,Spodbude
DocType: Program Fee,Program Fee,Pristojbina za program
DocType: Delivery Settings,Delay between Delivery Stops,Zamuda med ustavitvijo dostave
DocType: Stock Settings,Freeze Stocks Older Than [Days],Zamrzni zaloge starejše od [dni]
DocType: Promotional Scheme,Promotional Scheme Product Discount,Popust za promocijske izdelke
apps/erpnext/erpnext/support/doctype/issue_priority/issue_priority.py,Issue Priority Already Exists,Obstaja že prednostna naloga
DocType: Account,Asset Received But Not Billed,"Prejeta sredstva, vendar ne zaračunajo"
DocType: POS Closing Voucher,Total Collected Amount,Skupni zbrani znesek
DocType: Course,Default Grading Scale,Privzeta lestvica ocenjevanja
DocType: POS Profile,Allow user to edit Discount,Dovoli uporabniku urejanje popusta
DocType: POS Closing Voucher,Linked Invoices,Povezani računi
DocType: Volunteer,Weekends,Vikendi
DocType: Employee,Health Details,Podrobnosti o zdravju
DocType: Employee Education,Graduate,Diplomant
DocType: Asset Maintenance Task,Asset Maintenance Task,Naloga vzdrževanja sredstva
DocType: Restaurant Order Entry,Restaurant Table,Restavracijska miza
DocType: Amazon MWS Settings,CN,CN
apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js,Order Entry,Vnos naročila
DocType: Request for Quotation Supplier,Download PDF,Prenesite PDF
DocType: Bank Transaction,Unallocated Amount,Nedodeljeni znesek
DocType: Travel Itinerary,Rented Car,Najem avtomobila
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Na čakanju
DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Preglednica prodajnega računa
DocType: Subscription,Plans,Načrti
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Znesek kupona za iztovorjene stroške
DocType: Student Log,Medical,Medicina
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Account {0} is frozen,Račun {0} je zamrznjen
DocType: Project,First Email,Prva e-pošta
DocType: Supplier Scorecard,Criteria Setup,Nastavitev meril
DocType: Crop,Yield UOM,Donos UOM
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Lab Test Prescriptions,Predpisi za laboratorijske teste
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,Service Expense,Stroški storitev
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference No & Reference Date is required for {0},Za {0} je potreben referenčni datum in referenčni datum
DocType: Salary Structure,Leave Encashment Amount Per Day,Pustite znesek nakazila na dan
DocType: Student Admission Program,Naming Series (for Student Applicant),Naming Series (za študentskega kandidata)
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per section 17(5),Kot v oddelku 17 (5)
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,Credit Days cannot be a negative number,Kreditni dnevi ne morejo biti negativno število
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Same supplier has been entered multiple times,Isti dobavitelj je bil vnesen večkrat
DocType: Customs Tariff Number,Tariff Number,Tarifna številka
DocType: Plant Analysis Criteria,Maximum Permissible Value,Največja dovoljena vrednost. \ T
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Received Stock Entries,Prejete zaloge
DocType: Opportunity,Opportunity Amount,Znesek priložnosti
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount,Znesek naročila
DocType: C-Form,III,III
DocType: Contract,Fulfilment Terms,Pogoji za izpolnitev
apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Ne-skupina v skupino
DocType: Student Guardian,Mother,Mati
DocType: Issue,Service Level Agreement Fulfilled,Izpolnjen sporazum o ravni storitev
DocType: Payroll Entry,Deduct Tax For Unclaimed Employee Benefits,Odbitni davek za nezavarovane dajatve zaposlenih
DocType: Travel Request,Travel Funding,Financiranje potovanj
DocType: Shipping Rule,Fixed,Fiksno
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}) ne more biti višja od načrtovane količine ({2}) v delovnem nalogu {3}
DocType: Quality Review,Additional Information,Dodatne informacije
DocType: Course Scheduling Tool,Reschedule,Prestavi
apps/erpnext/erpnext/setup/doctype/company/company.py,Please select Existing Company for creating Chart of Accounts,Izberite možnost Obstoječe podjetje za ustvarjanje kontnega načrta
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Active Leads / Customers,Aktivni kupci / kupci
apps/erpnext/erpnext/templates/generators/item/item_configure.js,1 exact match.,1 natančno ujemanje.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Sports,Šport
DocType: Employee Advance,Claimed Amount,Zahtevani znesek
DocType: Plant Analysis Criteria,Plant Analysis Criteria,Merila za analizo rastlin
DocType: Fee Schedule,Send Payment Request Email,Pošlji e-pošto z zahtevo za plačilo
DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,"V besedi bo viden, ko shranite račun za prodajo."
DocType: Sales Invoice,Sales Team1,Prodajna ekipa1
DocType: Work Order,Required Items,Zahtevane postavke
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Read the ERPNext Manual,Preberite priročnik ERPNext
DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Preverite edinstvenost številke računa dobavitelja
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Search Sub Assemblies,Išči podsklopi
DocType: Rename Tool,Type of document to rename.,Vnesite dokument za preimenovanje.
apps/erpnext/erpnext/utilities/activation.py,"Leads help you get business, add all your contacts and more as your leads","Vodniki vam pomagajo pri poslovanju, dodajte vse svoje stike in še več kot svoje stranke"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Indirect Expenses,Posredni stroški
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Internet Publishing,Internetno objavljanje
DocType: Customer,Account Manager,Upravitelj računa
DocType: Amazon MWS Settings,BR,BR
DocType: Item,Warranty Period (in days),Garancijsko obdobje (v dneh)
apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js,No items found.,Ni najdenih elementov.
DocType: Item Attribute,From Range,Iz območja
DocType: Clinical Procedure,Consumables,Potrošni material
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,'employee_field_value' and 'timestamp' are required.,&#39;employee_field_value&#39; in &#39;timestamp&#39; sta obvezna.
DocType: Purchase Taxes and Charges,Reference Row #,Referenčna vrstica #
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set 'Asset Depreciation Cost Center' in Company {0},V podjetju {0} nastavite &#39;Središče stroškov amortizacije sredstev&#39;
DocType: Amazon MWS Settings,Click this button to pull your Sales Order data from Amazon MWS.,"Kliknite ta gumb, če želite podatke o prodajnem nalogu povleči iz storitve Amazon MWS."
DocType: Shift Type,Working hours below which Half Day is marked. (Zero to disable),"Delovni čas, pod katerim je označen pol dneva. (Nič do onemogočenja)"
,Assessment Plan Status,Status načrta ocenjevanja
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select {0} first,Najprej izberite {0}
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,Submit this to create the Employee record,"Pošljite to, da ustvarite zapis zaposlenega"
DocType: Item Attribute Value,"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","To bo dodano k šifri postavke različice. Na primer, če je vaša okrajšava &quot;SM&quot; in koda postavke &quot;T-SHIRT&quot;, bo koda postavke različice &quot;T-SHIRT-SM&quot;"
DocType: Support Settings,Track Service Level Agreement,Spremljajte sporazum o ravni storitev
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please enter Delivery Date,Vnesite datum dostave
DocType: Purchase Invoice Item,Quality Inspection,Pregled kakovosti
DocType: Account,Root Type,Vrsta korena
DocType: Journal Entry,Write Off Based On,Napiši na podlagi
DocType: Lab Test,Report Preference,Nastavitev poročila
DocType: Products Settings,Products Settings,Nastavitve izdelkov
DocType: Amazon MWS Settings,Synch Taxes and Charges,Sinhronizirajte davke in stroške
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Total cannot be zero,Skupaj ne more biti nič
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Cr),Odpiranje (Cr)
DocType: Employee,Company Email,E-pošta podjetja
DocType: Shopping Cart Settings,Show Stock Quantity,Pokaži količino zaloge
DocType: Student,A-,A-
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0} is added in the child company {1},Račun {0} je dodan v podrejeno podjetje {1}
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date Of Retirement must be greater than Date of Joining,Datum upokojitve mora biti večji od datuma pridružitve
DocType: Restaurant Order Entry,Add Item,Dodaj element
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Sick Leave,Bolniški dopust
DocType: Lab Test,Lab Test,Laboratorijski test
DocType: Account,Accumulated Depreciation,Skupna amortizacija
DocType: Support Search Source,Source Type,Vrsta vira
DocType: Department Approver,Department Approver,Odobreni oddelek
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Qty per BOM Line,Količina na vrstico BOM
apps/erpnext/erpnext/controllers/buying_controller.py,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Sprejeta + zavrnjena količina mora biti enaka prejeti količini za element {0}
apps/erpnext/erpnext/projects/doctype/task/task.js,Expense Claims,Stroškovne terjatve
DocType: Bank Account,Address HTML,HTML naslova
,Stock Projected Qty,Predvidena količina zalog
DocType: Employee Onboarding,Job Offer,Zaposlitvena ponudba
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,No Remarks,Št
DocType: Sales Invoice,Change Amount,Spremeni znesek
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Write Off Amount,Izpiši znesek
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,No Items available for transfer,"Ni elementov, ki so na voljo za prenos"
DocType: Work Order,Actual End Date,Dejanski končni datum
DocType: Loyalty Point Entry,Loyalty Point Entry,Vnos točke zvestobe
DocType: Travel Itinerary,Train,Vlak
DocType: BOM Explosion Item,BOM Explosion Item,BOM Eksplozijski element
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward Supplies(liable to reverse charge,Notranja dobava (ki se lahko obrne
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,{0}: {1} not found in Invoice Details table,{0}: {1} ni na voljo v tabeli Podrobnosti računa
DocType: Stock Entry,Total Incoming Value,Skupna dohodna vrednost
DocType: Bank Transaction Payments,Bank Transaction Payments,Plačila za bančne transakcije
apps/erpnext/erpnext/public/js/stock_analytics.js,Select Warehouse...,Izberi skladišče ...
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Type of Business,Vrsta podjetja
apps/erpnext/erpnext/config/buying.py,All Addresses.,Vsi naslovi.
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","Če omogočite »Uporabi za nakupovalno košarico«, ko je omogočena nakupovalna košarica, mora obstajati vsaj en davčni predpis za nakupovalno košarico"
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Course,Izberite predmet
DocType: Taxable Salary Slab,Percent Deduction,Odstotek odbitka
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Quantity to Produce can not be less than Zero,Količina za proizvodnjo ne sme biti manjša od nič
DocType: Share Balance,To No,Na št
DocType: Leave Control Panel,Allocate Leaves,Dodeli liste
DocType: Assessment Result,Student Name,Študentsko ime
apps/erpnext/erpnext/config/crm.py,Plan for maintenance visits.,Načrtujte obiske za vzdrževanje.
apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Naslednji zahtevki za gradivo so bili sproženi samodejno na podlagi ponovnega naročanja elementa
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on PO,"Ukrep, če je skupni mesečni proračun presežen na PO"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Full-time,Polni delovni čas
DocType: Program Enrollment,Vehicle/Bus Number,Številka vozila / avtobusa
DocType: Tax Rule,Purchase Tax Template,Predloga za davek za nakup
DocType: Production Plan,Material Request Planning,Načrtovanje materialnih zahtev
DocType: UOM,Check this to disallow fractions. (for Nos),"Označite to možnost, če želite onemogočiti ulomke. (za št.)"
DocType: Retention Bonus,Bonus Payment Date,Datum plačila bonusa
DocType: BOM,Operating Cost,Operativni stroški
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select Items based on Delivery Date,Izberite elemente na podlagi datuma dobave
DocType: Homepage,Tag Line,Oznaka vrstica
DocType: Customer,From Lead,Od svinca
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Unclosed Fiscal Years Profit / Loss (Credit),"Dobiček / izguba v poslovnem letu, ki ni zaprta (kredit)"
DocType: Agriculture Analysis Criteria,Agriculture,Kmetijstvo
DocType: Quality Procedure,Parent Procedure,Postopek staršev
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Set Open,Nastavite Odpri
apps/erpnext/erpnext/www/all-products/index.html,Toggle Filters,Preklop filtrov
DocType: Production Plan,Material Request Detail,Podrobnosti o zahtevi za material
DocType: Shift Type,Process Attendance After,Udeležba v procesu po
DocType: Material Request Item,Quantity and Warehouse,Količina in skladišče
apps/erpnext/erpnext/utilities/user_progress.py,Go to Programs,Pojdite na Programi
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Duplicate entry in References {1} {2},Vrstica # {0}: podvojen vnos v virih {1} {2}
DocType: Loyalty Point Entry,Loyalty Program,Program zvestobe
DocType: Lost Reason Detail,Opportunity Lost Reason,Izgubljeni razlog za priložnost
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is a limited liability company,"Velja, če je družba družba z omejeno odgovornostjo"
DocType: Patient,"Allergies, Medical and Surgical History","Alergije, medicinska in kirurška zgodovina"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Capital Stock,Osnovni kapital
DocType: Share Transfer,From Folio No,Iz Folio No
apps/erpnext/erpnext/templates/pages/order.js,Pay Remaining,Preostanek plačila
apps/erpnext/erpnext/accounts/page/pos/pos.js,Search Item,Iskanje elementa
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Leaves,Skupaj listi
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update rate as per last purchase,Hitrost posodabljanja glede na zadnji nakup
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please select a table,Izberite tabelo
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} is blocked so this transaction cannot proceed,"{0} je blokirano, zato ta transakcija ne more nadaljevati"
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get Items From,Pridobite predmete iz
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.",Točke zvestobe se izračunajo iz opravljenega dela (preko prodajnega računa) na podlagi omenjenega faktorja zbiranja.
DocType: Setup Progress Action,Min Doc Count,Min
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} must be a non-stock item,"Element {0} mora biti element, ki ni na zalogi"
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge Account,Združi račun
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to Group,Pretvori v skupino
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,"Already set default in pos profile {0} for user {1}, kindly disabled default","Že nastavljen privzeti profil v posu {0} za uporabnika {1}, prijazno onemogočeno privzeto"
DocType: Fiscal Year,Companies,Podjetja
,Minutes to First Response for Opportunity,Minuta do prvega odgovora za priložnost
DocType: Hotel Room Amenity,Hotel Room Amenity,Hotelska soba
apps/erpnext/erpnext/config/selling.py,Invoices for Costumers.,Računi za kupce.
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.js,No Staffing Plans found for this Designation,Za to imenovanje ni na voljo kadrovskih načrtov
DocType: BOM Update Tool,Current BOM,Trenutni BOM
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Casual Leave
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Cost Updated,Strošek posodobljen
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,One customer can be part of only single Loyalty Program.,Ena stranka je lahko del samo enega programa zvestobe.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Cannot cancel transaction for Completed Work Order.,Transakcije za dokončan delovni nalog ni mogoče preklicati.
DocType: Grant Application,Grant Application Details ,Podeli podrobnosti vloge
DocType: Purchase Invoice,Apply Additional Discount On,Uporabi dodatni popust na
,Sales Partner Commission Summary,Povzetek komisije za prodajne partnerje
apps/erpnext/erpnext/controllers/selling_controller.py,Order Type must be one of {0},Vrsta naročila mora biti ena od {0}
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry already exists,Vnos plačil že obstaja
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No Work Orders created,Ni ustvarjenih delovnih nalogov
DocType: Assessment Plan,Grading Scale,Lestvica ocenjevanja
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Marketing Expenses,Tržni stroški
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Next Contact Date cannot be in the past,Datum naslednjega stika ne more biti v preteklosti
DocType: Shopify Settings,Webhooks Details,Spletni trgi Podrobnosti
DocType: Authorization Rule,Authorization Rule,Avtorizacijsko pravilo
apps/erpnext/erpnext/config/non_profit.py,Volunteer Type information.,Informacije o vrsti prostovoljca.
DocType: Naming Series,This is the number of the last created transaction with this prefix,To je številka zadnje ustvarjene transakcije s to predpono
DocType: Supplier Scorecard,Indicator Color,Barva indikatorja
DocType: Item Variant Settings,Copy Fields to Variant,Kopiraj polja v Variant
DocType: Soil Texture,Sandy Loam,Sandy Loam
DocType: Question,Single Correct Answer,Enoten pravilen odgovor
apps/erpnext/erpnext/hr/utils.py,From date can not be less than employee's joining date,Od datuma ne more biti manjši od datuma zaposlitve
DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Dovoli več naročil za naročilo kupca
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","Če je izbrano, se znesek davka šteje kot že vključen v količino tiskanja / tiskanje"
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Datum se ponovi
DocType: Pricing Rule,Party Information,Informacije o strankah
apps/erpnext/erpnext/shopping_cart/cart.py,Debtors ({0}),Dolžniki ({0})
apps/erpnext/erpnext/hr/utils.py,To date can not greater than employee's relieving date,Do danes ne more presegati datuma odpuščanja zaposlenega
DocType: Shift Type,Enable Exit Grace Period,Omogoči izhodno obdobje mirovanja
DocType: Expense Claim,Employees Email Id,ID osebja e-pošte
DocType: Shopify Settings,Update Price from Shopify To ERPNext Price List,Posodobi Cena iz Shopify V ERPNext cenik
DocType: Healthcare Settings,Default Medical Code Standard,Privzeti standard medicinske kode
DocType: Woocommerce Settings,Tax Account,Davčni račun
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py,Total Paid Amt,Skupaj plačani amt
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Select finance book for the item {0} at row {1},Izberite knjigo o financiranju za element {0} v vrstici {1}
DocType: BOM,Website Specifications,Specifikacije spletnega mesta
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"From a supplier under composition scheme, Exempt and Nil rated","Od dobavitelja po shemi sestave, oproščeni in Nil ocenjeni"
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,"Do you want to update attendance?<br>Present: {0}\
					<br>Absent: {1}",Ali želite posodobiti prisotnost? <br> Prisotni: {0} <br> Ni: {1}
DocType: Leave Control Panel,Employee (optional),Zaposleni (neobvezno)
DocType: Purchase Invoice,Supplier Invoice Details,Podrobnosti računa dobavitelja
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Stranka {0} je ustvarjena.
DocType: Company,Default Cost of Goods Sold Account,Privzeta vrednost prodanega računa blaga
apps/erpnext/erpnext/accounts/utils.py,{0} Number {1} already used in account {2},{0} Številka {1} je že uporabljena v računu {2}
DocType: Mode of Payment Account,Default Account,Privzeti račun
DocType: Purchase Invoice,Disable Rounded Total,Onemogoči zaokroženo vsoto
DocType: Contract,Signee,Signee
apps/erpnext/erpnext/crm/doctype/contract/contract.py,End Date cannot be before Start Date.,Datum konca ne sme biti pred začetnim datumom.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to group.,Skladišča z obstoječo transakcijo ni mogoče pretvoriti v skupino.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Both Warehouse must belong to same Company,Oba skladišča morata pripadati istemu podjetju
DocType: Maintenance Visit Purpose,Against Document Detail No,Proti dokumentu št
apps/erpnext/erpnext/public/js/queries.js,Please set {0},Nastavite {0}
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Najprej izberite predpono
apps/erpnext/erpnext/config/help.py,Managing Subcontracting,Upravljanje podizvajanja
DocType: Activity Cost,Projects User,Uporabnik projektov
DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Variable
DocType: Item Group,Item Group Name,Ime skupine elementov
DocType: Budget,Applicable on Material Request,Velja na zahtevo za material
DocType: Support Settings,Search APIs,API-ji za iskanje
DocType: Manufacturing Settings,Overproduction Percentage For Sales Order,Odstotek prekomerne proizvodnje za prodajni nalog
DocType: Purchase Invoice,Supplied Items,Priloženi predmeti
DocType: Leave Control Panel,Select Employees,Izberite Zaposleni
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.js,Create Loan,Ustvari posojilo
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Select interest income account in loan {0},Izberite račun obrestnih prihodkov v posojilu {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Vsi deli so že preneseni za ta delovni nalog.
DocType: Certification Application,Payment Details,Podatki o plačilu
apps/erpnext/erpnext/config/settings.py,Printing and Branding,Tiskanje in blagovna znamka
DocType: Item Group,HTML / Banner that will show on the top of product list.,"HTML / Banner, ki se bo prikazal na vrhu seznama izdelkov."
,Sales Payment Summary,Povzetek plačil prodaje
DocType: Salary Component,Is Flexible Benefit,Je prilagodljiva ugodnost
DocType: GST Account,IGST Account,Račun IGST
DocType: Shopping Cart Settings,Checkout Settings,Nastavitve storitve Checkout
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the customer '%s',"Prosimo, nastavite fiskalno kodo za stranko »% s«"
DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"** Mesečna porazdelitev ** vam pomaga razdeliti proračun / cilj čez mesece, če imate v podjetju sezonsko naravo."
DocType: Guardian,Students,Študenti
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Expense Claim {0} already exists for the Vehicle Log,Trditev o stroških {0} že obstaja za dnevnik vozil
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. ","Če je izbrana, vrednost, določena ali izračunana v tej komponenti, ne bo prispevala k zaslužku ali odbitkom. Vendar pa se na njegovo vrednost lahko sklicujejo druge komponente, ki se lahko dodajo ali odštejejo."
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter repayment Amount,Vnesite znesek odplačila
DocType: Sales Invoice,Is Opening Entry,Odpre se vnos
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Set New Release Date,Nastavite nov datum izdaje
DocType: Account,Expenses Included In Valuation,"Stroški, vključeni v vrednotenje"
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Serial Numbers,Serijske številke
DocType: Salary Slip,Deductions,Odbitki
,Supplier-Wise Sales Analytics,Prodajna analiza podjetja Wise
DocType: GSTR 3B Report,February,Februar
DocType: Appraisal,For Employee,Za zaposlenega
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Actual Delivery Date,Dejanski datum dostave
DocType: Sales Partner,Sales Partner Name,Ime prodajnega partnerja
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Depreciation Start Date is entered as past date,Vrstica amortizacije {0}: Začetni datum amortizacije se vnese kot pretekli datum
DocType: GST HSN Code,Regional,Regionalno
DocType: Lead,Lead is an Organization,Svinec je organizacija
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select Charge Type first,Najprej izberite Vrsta polnjenja
DocType: Purchase Receipt Item,Accepted Quantity,Sprejeta količina
DocType: Amazon MWS Settings,DE,DE
apps/erpnext/erpnext/templates/pages/product_search.html,Search Results,Rezultati iskanja
DocType: Item Default,Default Buying Cost Center,Privzeto mesto stroškov za nakup
DocType: Production Plan,Include Non Stock Items,Vključite nepremičnine
DocType: Student,AB+,AB +
DocType: Upload Attendance,Upload Attendance,Naloži prisotnost
DocType: Drug Prescription,Drug Code,Zakon o drogah
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Booking Actual Expenses,"Prosimo, omogočite možnost Uporabi pri dejanskih stroških rezervacije"
apps/erpnext/erpnext/accounts/report/account_balance/account_balance.js,Chargeble,Chargeble
DocType: Purchase Order,Supply Raw Materials,Dobava surovin
,Item-wise Price List Rate,Cena po cenikih po postavkah
DocType: Purchase Invoice Item,BOM,BOM
DocType: Quality Inspection,Readings,Odčitki
apps/erpnext/erpnext/accounts/deferred_revenue.py,Error while processing deferred accounting for {0},Napaka pri obdelavi odloženega obračunavanja za {0}
apps/erpnext/erpnext/regional/italy/utils.py,Please set either the Tax ID or Fiscal Code on Company '%s',Nastavite davčno številko ali davčno številko za podjetje »% s«
apps/erpnext/erpnext/public/js/utils.js,Add Serial No,Dodaj serijsko št
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Avg. Selling Rate,Povp. Stopnja prodaje
DocType: Payment Request,payment_url,payment_url
DocType: Delivery Note,Excise Page Number,Številka trošarinske strani
,Sales Partner Target Variance based on Item Group,Varianca ciljne prodaje prodajnega partnerja na podlagi skupine izdelkov
DocType: Stock Settings,Naming Series Prefix,Predpona serije poimenovanja
DocType: BOM Operation,Workstation,Delovna postaja
DocType: Plaid Settings,Synchronize all accounts every hour,Sinhronizirajte vse račune vsako uro
DocType: Employee Boarding Activity,Task Weight,Teža opravila
apps/erpnext/erpnext/public/js/utils.js,Annual Billing: {0},Letni obračun: {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,Fiskalnega leta {0} ne morete izbrisati. Fiskalno leto {0} je privzeto nastavljeno v globalnih nastavitvah
apps/erpnext/erpnext/public/js/pos/pos.html,No Customers yet!,Še ni strank!
DocType: Company,Enable Perpetual Inventory,Omogoči trajni inventar
DocType: Opportunity,Potential Sales Deal,Potencialni prodajni dogovor
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Excise Invoice,Trošarinski račun
DocType: Supplier Scorecard,Supplier Scorecard,Tabela rezultatov dobavitelja
DocType: Travel Itinerary,Travel To,Potovati v
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Mark Attendance,Označi Prisotnost
DocType: Shift Type,Determine Check-in and Check-out,Določite prijavo in odjavo
DocType: POS Closing Voucher,Difference,Razlika
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Small,Majhna
DocType: Work Order Item,Work Order Item,Postavka delovnega naloga
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py,Sales and Returns,Prodaja in vračila
DocType: Budget,Monthly Distribution,Mesečna distribucija
DocType: Quality Action,Quality Action,Akcija kakovosti
DocType: Work Order,Work-in-Progress Warehouse,Skladišče za delo v teku
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Dividends Paid,Plačane dividende
DocType: Program Enrollment Tool,New Academic Year,Novo akademsko leto
DocType: Sales Person,Name and Employee ID,Ime in ID zaposlenega
DocType: Subscription,Generate Invoice At Beginning Of Period,Ustvari račun na začetku obdobja
DocType: Item,Minimum Order Qty,Najmanjša količina naročila
DocType: Leave Block List,Block Holidays on important days.,Blokirajte počitnice v pomembnih dneh.
apps/erpnext/erpnext/public/js/conf.js,Documentation,Dokumentacija
DocType: Item Alternative,Alternative Item Code,Alternativna koda artikla
DocType: Sales Partner,Partner website,Spletno mesto partnerja
DocType: Loan,Applicant,Vlagatelj
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.","Enotno za rezultate, ki zahtevajo le en vnos, rezultat UOM in normalno vrednost <br> Sestavite se za rezultate, ki zahtevajo več vnosnih polj z ustreznimi imeni dogodkov, UOMs rezultatov in normalne vrednosti <br> Opisni za preskuse, ki imajo več komponent rezultatov in ustrezna polja za vnos rezultatov. <br> Združene za testne predloge, ki so skupina drugih testnih predlog. <br> Ne Rezultat za teste brez rezultatov. Tudi Lab Test ni ustvarjen. npr. Sub-testi za rezultate združenih v skupine."
apps/erpnext/erpnext/accounts/general_ledger.py,Please mention Round Off Cost Center in Company,"Prosimo, da v podjetju navedete Round Off Cost Center"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Pred odpošiljanjem tega prodajnega naloga je treba odpovedati obvestila o dostavi {0}
DocType: Grant Application,Show on Website,Pokaži na spletni strani
DocType: Sales Invoice,Shipping Address Name,Ime in naslov pošiljanja
apps/erpnext/erpnext/healthcare/setup.py,Drug,Drog
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is closed,{0} {1} je zaprt
DocType: Patient,Medical History,Zdravstvena zgodovina
DocType: Expense Claim,Expense Taxes and Charges,Stroški in stroški
DocType: Subscription Settings,Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,"Število dni po preteku datuma izdaje računa, preden prekličete naročnino ali označite naročnino kot neplačano"
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Installation Note {0} has already been submitted,Namestitvena opomba {0} je že bila poslana
DocType: Patient Relation,Family,Družina
DocType: Work Order Operation,Updated via 'Time Log',Posodobljeno prek »Dnevnika časa«
DocType: Quality Inspection,Sample Size,Velikost vzorca
DocType: Bank Transaction,Reference Number,Referenčna številka
DocType: UOM Conversion Detail,UOM Conversion Detail,Podrobnosti konverzije UOM
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Opening Accumulated Depreciation must be less than equal to {0},Odpiranje akumulirane amortizacije mora biti manjše od {0}
DocType: Antibiotic,Antibiotic Name,Ime 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 spodnji tabeli bo izbran le kandidat, ki ima status &quot;odobreno&quot;."
DocType: Task,% Progress,% Napredka
DocType: UOM Category,UOM Category,Kategorija UOM
apps/erpnext/erpnext/config/help.py,Publish Items on Website,Objavite elemente na spletnem mestu
DocType: Chapter,Meetup Embed HTML,Meetup Vdelaj HTML
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.js,Please select Party Type first,Najprej izberite vrsto pogodbenice
DocType: Loan,Repayment Start Date,Datum začetka odplačevanja
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Not authroized since {0} exceeds limits,"Ni avtorizirano, ker {0} presega omejitve"
DocType: Procedure Prescription,Procedure Created,Ustvarjen postopek
,Serial No Warranty Expiry,Zaporedna št. Garancije: Iztek
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Against Supplier Invoice {0} dated {1},Proti računu dobavitelja {0} z dne {1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Change POS Profile,Spremeni profil POS
apps/erpnext/erpnext/utilities/activation.py,Create Lead,Ustvari svinca
DocType: Shopify Settings,Default Customer,Privzeta stranka
DocType: Payment Entry Reference,Supplier Invoice No,Račun dobavitelja št
DocType: Pricing Rule,Mixed Conditions,Mešani pogoji
DocType: Woocommerce Settings,"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".","To je privzeta UOM, ki se uporablja za postavke in prodajna naročila. Pomožni UOM je &quot;št.&quot;"
DocType: Payment Request,Mute Email,Izklopi e-pošto
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 2,Točka 2
apps/erpnext/erpnext/config/accounting.py,Tax Withholding rates to be applied on transactions.,"Davčne stopnje zadržanja, ki se uporabljajo za transakcije."
DocType: Dosage Strength,Strength,Trdnost
DocType: Buying Settings,Backflush Raw Materials of Subcontract Based On,"Surovine za backflush, ki temeljijo na podnaročilu"
DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Če je omogočeno, bo polje Academic Term obvezno v orodju za včlanitev v program."
DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Za Študentsko skupino, ki temelji na serijah, bo Študentska Serija potrjena za vsakega Študenta iz Vpisa v Program."
DocType: Course,Topics,Teme
apps/erpnext/erpnext/stock/doctype/item/item.py,Row #{0}: Please set reorder quantity,Vrstica # {0}: Nastavite količino ponovnega naročanja
DocType: Crop Cycle,Linked Location,Povezana lokacija
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Batch number is mandatory for Item {0},Številka paketa je obvezna za element {0}
apps/erpnext/erpnext/accounts/party.py,Not permitted for {0},Ni dovoljeno za {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is fully billed,Računu {0} {1} je v celoti zaračunano
DocType: Payment Request,Inward,Notranjost
apps/erpnext/erpnext/templates/pages/help.html,See All Articles,Glej vse člene
DocType: Bank Reconciliation Detail,Payment Entry,Vnos plačila
DocType: Payment Request,Recipient Message And Payment Details,Sporočilo prejemnika in podrobnosti o plačilu
DocType: Payment Terms Template Detail,Payment Terms Template Detail,Podrobnosti o pogojih plačila
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Select Quantity,Izberite količino
DocType: Student Attendance,Student Attendance,Udeležba študentov
DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Samodejno nastavi serijske številke na podlagi FIFO
,Available Qty,Na voljo št
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invoices based on Filters,Pridobite račune na podlagi filtrov
DocType: Operation,Default Workstation,Privzeta delovna postaja
DocType: Salary Slip,Salary Structure,Struktura plač
DocType: Products Settings,Enable Attribute Filters,Omogoči filtre atributov
DocType: Member,Non Profit Member,Član neprofitne organizacije
DocType: Material Request Plan Item,Material Request Plan Item,Načrtna postavka zahteve za material
DocType: Holiday List,Add to Holidays,Dodaj v praznike
apps/erpnext/erpnext/controllers/status_updater.py,Limit Crossed,Prekrita meja
DocType: Company,Transactions Annual History,Letne zgodovine transakcij
DocType: Company,Delete Company Transactions,Izbriši transakcije podjetja
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To State,Trditi
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Department Stores,Veleblagovnice
DocType: Healthcare Service Unit,Inpatient Occupancy,Bolnišnično bivanje
apps/erpnext/erpnext/controllers/accounts_controller.py,Row {0}: Due Date cannot be before posting date,Vrstica {0}: Datum zapadlosti ne more biti pred datumom knjiženja
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please set default customer in Restaurant Settings,V nastavitvah restavracij nastavite privzetega uporabnika
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py, Group Roll No,Št
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please specify a valid Row ID for row {0} in table {1},Navedite veljaven ID vrstice za vrstico {0} v tabeli {1}
DocType: Asset Movement,To Employee,Za zaposlenega
DocType: Item,End of Life,Konec življenja
DocType: Lab Test Template,Sensitivity,Občutljivost
DocType: Territory,Territory Targets,Ciljni cilji
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čitev dodeljenih sredstev za naslednje zaposlene, saj zapisi o dodelitvi dopusta že obstajajo. {0}"
DocType: Quality Action Resolution,Quality Action Resolution,Resolucija o dejanju kakovosti
DocType: Sales Invoice Item,Delivered By Supplier,Dobavljeno po dobavitelju
DocType: Agriculture Analysis Criteria,Plant Analysis,Analiza rastlin
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Expense account is mandatory for item {0},Stroškovni račun je obvezen za element {0}
,Subcontracted Raw Materials To Be Transferred,"Podizvajane surovine, ki jih je treba prenesti"
DocType: Cashier Closing,Cashier Closing,Zapiranje blagajne
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Item {0} has already been returned,Element {0} je že vrnjen
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,Neveljaven GSTIN! Vneseni vnos se ne ujema z obliko GSTIN za imetnike UIN ali nerezidenčne ponudnike storitev OIDAR
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Child warehouse exists for this warehouse. You can not delete this warehouse.,Za to skladišče obstaja otroško skladišče. Tega skladišča ne morete izbrisati.
DocType: Diagnosis,Diagnosis,Diagnoza
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,There is no leave period in between {0} and {1},Med {0} in {1} ni obdobja dopusta
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} Proračun za račun {1} za {2} {3} je {4}. Presega do {5}
DocType: Purchase Invoice Item,Asset Location,Lokacija sredstva
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Please enter Difference Account,Vnesite račun razlike
DocType: Journal Entry,Total Credit,Skupni znesek kredita
DocType: Certified Consultant,Name of Consultant,Ime svetovalca
DocType: Driver,License Number,Številka licence
DocType: Program Enrollment Tool,Program Enrollment Tool,Orodje za včlanitev v program
DocType: Amazon MWS Settings,US,ZDA
DocType: Sales Order,Track this Sales Order against any Project,Sledite temu prodajnemu nalogu za katerikoli projekt
DocType: QuickBooks Migrator,Authorization Settings,Nastavitve za avtorizacijo
DocType: Homepage,Products,Izdelki
,Profit and Loss Statement,Izkaz poslovnega izida
apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py,Rooms Booked,Rezervirane sobe
apps/erpnext/erpnext/stock/doctype/item_manufacturer/item_manufacturer.py,Duplicate entry against the item code {0} and manufacturer {1},Podvojen vnos za šifro postavke {0} in proizvajalec {1}
DocType: Item Barcode,EAN,EAN
DocType: Purchase Invoice Item,Total Weight,Totalna teža
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Travel,Potovanje
,Stock Ledger,Zaloga knjige
DocType: Volunteer,Volunteer Name,Ime prostovoljca
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! First 2 digits of GSTIN should match with State number {0}.,Neveljaven GSTIN! Prvi dve števki GSTIN se morata ujemati s številko države {0}.
DocType: Quality Inspection,Report Date,Datum poročila
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Create Inter Company Journal Entry,Ustvarite vnos internega dnevnika
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Enough Parts to Build,Dovolj delov za gradnjo
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,Stroški izdanih postavk
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Treshold {0}% appears more than once,Prag {0}% se prikaže več kot enkrat
DocType: Chapter,Chapter Members,Člani poglavja
DocType: Warranty Claim,Service Address,Naslov storitve
DocType: Journal Entry,Remark,Opomba
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}),Vrstica {0}: količina ni na voljo za {4} v skladišču {1} ob času objave vnosa ({2} {3})
DocType: Patient Encounter,Encounter Time,Čas srečanja
DocType: Serial No,Invoice Details,Podrobnosti računa
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Further accounts can be made under Groups, but entries can be made against non-Groups","Nadaljnje račune lahko ustvarite v skupinah, vendar lahko vnose vnesete za skupine, ki niso skupine"
apps/erpnext/erpnext/public/js/pos/pos.html,Stock Items,Zaloge
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Vrstica {0} # Dodeljena količina {1} ne more biti večja od neporavnanega zneska {2}
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Reqd Qty,Zahtevajte količino
DocType: Vital Signs,Body Temperature,Telesna temperatura
DocType: Customer Group,Customer Group Name,Ime skupine strank
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total allocated leaves are more than days in the period,Skupaj dodeljeni listi so več kot dni v obdobju
DocType: Homepage Section,Section Cards,Razdelek Kartice
apps/erpnext/erpnext/config/selling.py,Rules for adding shipping costs.,Pravila za dodajanje stroškov pošiljanja.
DocType: Item Price,Valid From,Velja od
DocType: Travel Itinerary,Preferred Area for Lodging,Želeno območje za vložitev
DocType: Student Attendance,Absent,Odsoten
DocType: Global Defaults,Hide Currency Symbol,Skrij simbol valute
DocType: Additional Salary,Overwrite Salary Structure Amount,Zamenjajte znesek strukture plač
DocType: Supplier Quotation,Is Subcontracted,Je podizvajalec
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.py,Loan Amount cannot exceed Maximum Loan Amount of {0},Znesek posojila ne sme presegati najvišjega zneska posojila v višini {0}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,BOM does not contain any stock item,BOM ne vsebuje nobene postavke zalog
DocType: Employee Skill Map,Employee Skill Map,Mapo znanja zaposlenih
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Marketing,Trženje
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,"Vrstica # {0}: Ni dovoljeno spremeniti dobavitelja, ker naročilnica že obstaja"
DocType: Item,Maximum sample quantity that can be retained,"Največja vzorčna količina, ki jo je mogoče ohraniti"
DocType: Staffing Plan,Total Estimated Budget,Skupni ocenjeni proračun
DocType: Supplier Scorecard Scoring Standing,Standing Name,Stalno ime
DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Potrdite vpisani tečaj za študente v študentski skupini
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,From Date {0} cannot be after employee's relieving Date {1},Od datuma {0} ne more biti po datumu razrešitve zaposlenega {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}",Skupna količina izdaj / prenosa {0} v zahtevi za material {1} ne sme presegati zahtevane količine {2} za element {3}
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js,Please select {0},Izberite {0}
DocType: Selling Settings,Default Customer Group,Privzeta skupina strank
DocType: Journal Entry Account,Debit in Company Currency,Plačilo v valuti podjetja
DocType: Woocommerce Settings,"The fallback series is ""SO-WOO-"".",Pomožna serija je &quot;SO-WOO-&quot;.
DocType: Quality Meeting Agenda,Quality Meeting Agenda,Program za kakovostno srečanje
apps/erpnext/erpnext/controllers/item_variant.py,Please do not create more than 500 items at a time,Ne ustvarjajte več kot 500 elementov naenkrat
DocType: Cash Flow Mapper,Section Header,Glava odseka
apps/erpnext/erpnext/utilities/user_progress.py,Your Products or Services,Vaših izdelkov ali storitev
DocType: Crop,Perennial,Trajen
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Freight and Forwarding Charges,Stroški prevoza in špedicije
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Last Purchase Price,Zadnja nakupna cena
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Tax Assets,Davčna sredstva
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.","Če je izbrano pravilo za določanje cen izdelano za »Rate«, bo preklical cenik. Obrestna mera za določanje cen je končna stopnja, zato ni treba uporabiti nadaljnjega popusta. Zato se v transakcijah, kot so prodajna naročila, naročila itd., Prevzame polje &quot;Rate&quot; (&quot;Rate&quot;) in ne polje &quot;Price List Rate&quot;."
DocType: Share Balance,Share Type,Vrsta skupne rabe
DocType: Agriculture Analysis Criteria,Soil Analysis,Analiza tal
DocType: Water Analysis,Water Analysis Criteria,Merila za analizo vode
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,Opomba: Skupni dodeljeni listi {0} ne smejo biti manjši od že odobrenih listov {1} za obdobje
DocType: Salary Component,Deduction,Odbitek
DocType: Accounts Settings,Over Billing Allowance (%),Nadomestilo za zaračunavanje (%)
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,You cannot restart a Subscription that is not cancelled.,"Naročnine, ki ni preklicana, ne morete znova zagnati."
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Employee Advances,Predplačila za zaposlene
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Provisional Profit / Loss (Credit),Začasni dobiček / izguba (kredit)
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Public token is missing for this bank,Za to banko manjka javni žeton
DocType: Employee Tax Exemption Category,Max Exemption Amount,Najvišji znesek oprostitve
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.,"Različni elementi UOM za postavke bodo povzročili napačno vrednost (skupne) neto teže. Prepričajte se, da je neto teža vsakega elementa v isti UOM."
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Supplier Quotation,Ponudbena ponudba
DocType: Item,Auto re-order,Samodejno ponovno naročanje
DocType: Expense Claim,Total Advance Amount,Skupni predujem
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Vrstica # {0}: Datum preklica {1} ne more biti pred datumom preverjanja {2}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Can only make payment against unbilled {0},Izplačilo lahko opravite samo za neobračunano {0}
DocType: BOM,Thumbnail,Sličica
DocType: Production Plan Item,Planned Qty,Načrtovana količina
DocType: Tax Withholding Category,Rates,Stopnje
DocType: Asset,Journal Entry for Scrap,Vnos v dnevnik za odpadke
DocType: GL Entry,Voucher Detail No,Podrobnosti kupona št
apps/erpnext/erpnext/stock/doctype/item/item.py,Variant Based On cannot be changed,Variant Based On ni mogoče spremeniti
DocType: Task,Review Date,Datum pregleda
DocType: Crop,Biennial,Bienale
DocType: Woocommerce Settings,Endpoints,Končne točke
DocType: Subscription Plan Detail,Plan,Načrt
DocType: Employee Education,Year of Passing,Leto prehoda
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Total Tax,Skupni davek
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please enter default currency in Company Master,"Prosimo, vnesite privzeto valuto v Company Master"
DocType: Tally Migration,Processed Files,Obdelane datoteke
DocType: Leave Type,Is Earned Leave,Je zaslužen dopust
DocType: Support Search Source,Search Term Param Name,Iskalni izraz Param Name
DocType: Sales Invoice,Time Sheets,Časovni listi
DocType: Installation Note,Installation Time,Čas namestitve
apps/erpnext/erpnext/config/buying.py,Templates of supplier scorecard variables.,Predloge spremenljivk kazalnikov dobavitelja.
DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Izdelek ali storitev, ki je kupljen, prodan ali hranjen na zalogi."
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Closing (Opening + Total),Zapiranje (Odpiranje + Skupaj)
DocType: Supplier Scorecard Criteria,Criteria Formula,Formula za merila
apps/erpnext/erpnext/config/support.py,Support Analytics,Podpora Analytics
DocType: Employee,Attendance Device ID (Biometric/RF tag ID),ID naprave za prisotnost (ID biometrične / RF oznake)
apps/erpnext/erpnext/config/quality_management.py,Review and Action,Pregled in dejanje
DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Če je račun zamrznjen, so vpisi dovoljeni za omejene uporabnike."
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py,Amount After Depreciation,Znesek po amortizaciji
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Master Data,Uvozite glavne podatke
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} must be active,BOM {0} mora biti aktivna
,GST Sales Register,GST prodajni register
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice Date cannot be greater than Posting Date,Datum računa dobavitelja ne sme biti večji od datuma knjiženja
apps/erpnext/erpnext/utilities/activation.py,Manage your orders,Upravljajte svoja naročila
DocType: Supplier Scorecard,Notify Supplier,Obvestite dobavitelja
,GSTR-2,GSTR-2
DocType: Sales Invoice,Credit Note Issued,Izplačana kreditna opomba
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py,This covers all scorecards tied to this Setup,"To zajema vse kazalce rezultatov, povezane s to nastavitvijo"
DocType: Payment Order,Payment Order Type,Vrsta plačilnega naloga
DocType: Account,Parent Account,Nadrejeni račun
DocType: Maintenance Visit,Unscheduled,Nepredvideno
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Issue Material,Izdajateljski material
DocType: Work Order,Use Multi-Level BOM,Uporabite BOM na več ravneh
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Qty for {0},Količina za {0}
DocType: Salary Slip,Loan Repayment,Odplačilo posojila
DocType: Employee Education,Major/Optional Subjects,Glavni / neobvezni predmeti
DocType: Soil Texture,Silt,Silt
apps/erpnext/erpnext/config/buying.py,Supplier Addresses And Contacts,Naslovi dobaviteljev in stiki
DocType: Bank Guarantee,Bank Guarantee Type,Vrsta bančne garancije
DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Če je onemogočeno, polje »Zaokroženo skupno« ne bo vidno v nobeni transakciji"
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.py,Please setup a default bank account for company {0},Nastavite privzeti bančni račun za podjetje {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.,To je glavna enota zdravstvene službe in je ni mogoče urejati.
apps/erpnext/erpnext/regional/italy/setup.py,Set this if the customer is a Public Administration company.,"To nastavite, če je stranka podjetje za javno upravo."
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Max benefits should be greater than zero to dispense benefits,"Največje ugodnosti bi morale biti večje od nič, da bi odpravili koristi"
DocType: Production Plan Item,Planned Start Date,Načrtovani datum začetka
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Maintenance,Vzdrževanje sredstev
DocType: Lead,Interested,Zanima me
DocType: Purchase Invoice,Net Total (Company Currency),Skupni znesek (valuta podjetja)
DocType: Salary Component,Depends on Payment Days,Odvisno od plačilnih dni
DocType: Subscription,Taxes,Davki
DocType: Bank Account,Bank Account,Bančni račun
DocType: Homepage Section,Section HTML,Razdelek HTML
DocType: Sales Invoice,Packed Items,Pakirani izdelki
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,New {0} pricing rules are created,Ustvarjena so nova {0} pravila za določanje cen
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Achieved ({}),Doseženo ({})
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Investment Banking,Investicijsko bančništvo
DocType: Contract Template,Contract Terms and Conditions,Pogoji pogodbe
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Fetch Data,Prenos podatkov
DocType: Stock Settings,Default Item Group,Privzeta skupina postavk
DocType: Sales Invoice Timesheet,Billing Hours,Obračunske ure
apps/erpnext/erpnext/education/doctype/student_leave_application/student_leave_application.py,Leave application {0} already exists against the student {1},Aplikacija za zapustitev {0} že obstaja proti študentu {1}
DocType: Pricing Rule,Margin Type,Vrsta marže
DocType: Purchase Invoice Item,Rejected Serial No,Zavrnjena serijska št
DocType: Stock Reconciliation Item,Current Amount,Trenutni znesek
apps/erpnext/erpnext/config/retail.py,Setup default values for POS Invoices,Namestite privzete vrednosti za POS račune
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost as on,Strošek kot na
apps/erpnext/erpnext/config/projects.py,Project Update.,Posodobitev projekta.
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root Type is mandatory,Root Type je obvezna
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Authentication Failed,Preverjanje pristnosti ni uspelo
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,Menjalnega tečaja za {0} do {1} ni mogoče najti za ključni datum {2}. Ročno ustvarite zapis menjave valut
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Billed,{0}% zaračunano
DocType: Purchase Invoice,Overdue,Pretečeno
DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,"Količina izdelka, pridobljenega po izdelavi / prepakiranju iz danih količin surovin"
DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Odpiranje elementa orodja za ustvarjanje računa
DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
DocType: Bank Reconciliation,Include POS Transactions,Vključi POS transakcije
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,No Employee found for the given employee field value. '{}': {},"Ni zaposlenih, ki bi našel vrednost polja za zaposlenega. &quot;{}&quot;: {}"
DocType: Payment Entry,Received Amount (Company Currency),Prejeti znesek (valuta podjetja)
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full, did not save","LocalStorage je poln, ni shranil"
DocType: Chapter Member,Chapter Member,Članica poglavja
DocType: Certified Consultant,Certification Validity,Veljavnost certificiranja
DocType: Share Transfer,Asset Account,Račun sredstva
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 zaključnem bonu POS
DocType: Patient Medical Record,HLC-PMR-.YYYY.-,HLC-PMR-.YYYY.-
DocType: Delivery Settings,Delivery Settings,Nastavitve dostave
DocType: Email Digest,Receivables,Terjatve
DocType: Crop,Annual,Letno
DocType: Item Tax Template Detail,Tax Rate,Davčna stopnja
DocType: Patient Encounter,Medical Coding,Medicinsko kodiranje
DocType: Purchase Invoice,Total Quantity,Skupna količina
DocType: Asset,Comprehensive Insurance,Celovito zavarovanje
DocType: Purchase Invoice Item,Quantity and Rate,Količina in hitrost
DocType: Employee Benefit Claim,Max Amount Eligible,Najvišja dovoljena količina
DocType: Salary Slip,Employee Loan,Posojilo zaposlenim
DocType: Payment Entry,Account Paid To,Plačan račun
DocType: Lab Test Template,Single,Ena
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Customer required for 'Customerwise Discount',Stranka je potrebna za »Popust na kupce«
DocType: Purchase Invoice,Advance Payments,Predplačila
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.","Ne morem zagotoviti dostave po serijski številki, ker je element {0} dodan z ali brez Zagotoviti dostavo"
DocType: Inpatient Record,Discharge Date,Datum raztovarjanja
,Open Work Orders,Odpri naročila dela
DocType: Crop Cycle,List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,"Seznam bolezni, odkritih na terenu. Ko je izbrana, bo samodejno dodala seznam opravil za obravnavo bolezni"
DocType: SMS Center,All Lead (Open),Vse vodilo (odprto)
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,No Student Groups created.,Ni ustvarjena nobena študentska skupina.
apps/erpnext/erpnext/utilities/transaction_base.py,Duplicate row {0} with same {1},Podvojena vrstica {0} z isto {1}
DocType: Employee,Salary Details,Podrobnosti o plačah
DocType: Employee Checkin,Exit Grace Period Consequence,Izhod iz obdobja mirovanja
DocType: Bank Statement Transaction Invoice Item,Invoice,Račun
DocType: Special Test Items,Particulars,Podrobnosti
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Please set filter based on Item or Warehouse,Nastavite filter na podlagi elementa ali skladišča
DocType: Bank Statement Transaction Invoice Item,Outstanding Amount,Neporavnani znesek
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py,Transactions can only be deleted by the creator of the Company,Transakcije lahko izbriše samo avtor podjetja
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.","Za postavke „svežnja proizvodov“, skladišče, serijska št. In št. Serije se šteje iz tabele „pakirni seznam“. Če sta Warehouse in Batch No enaka za vse pakirne postavke za katero koli postavko „Product Bundle“, se te vrednosti lahko vnesejo v glavno preglednico postavk, vrednosti se kopirajo v tabelo „Packing List“."
DocType: Lab Test,Submitted Date,Datum pošiljanja
DocType: Delivery Settings,Send with Attachment,Pošlji s prilogo
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill JSON can only be generated from submitted document,E-Way Bill JSON je mogoče ustvariti samo iz predloženega dokumenta
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Account {0} does not exists,Račun {0} ne obstaja
DocType: BOM Item,BOM No,BOM št
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Avg Daily Outgoing,Povprečni dnevni odhodni
DocType: Patient,Allergies,Alergije
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order/Quot %,Naročilo / kvota%
DocType: Delivery Note,Transporter Info,Informacije o prevozniku
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py,Please select the assessment group other than 'All Assessment Groups',"Prosimo, izberite skupino za ocenjevanje, razen &quot;Vse ocenjevalne skupine&quot;."
DocType: Leave Encashment,Payroll,Plače
DocType: POS Closing Voucher,Expense Amount,Znesek stroškov
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Received On,Prejeto Vklopljeno
DocType: Travel Itinerary,Flight,Let
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Davki in pristojbine za iztovorjene stroške
apps/erpnext/erpnext/hr/utils.py,More than one selection for {0} not allowed,Več kot ena izbira za {0} ni dovoljena
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Equity,Neto sprememba kapitala
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Leaves has been granted sucessfully,Listi so uspešno izdani
DocType: Loyalty Point Entry,Expiry Date,Rok uporabnosti
DocType: Task,Working,Delo
apps/erpnext/erpnext/quality_management/doctype/quality_procedure/quality_procedure.py,{0} already has a Parent Procedure {1}.,{0} že ima nadrejeni postopek {1}.
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py,This is based on transactions against this Patient. See timeline below for details,To temelji na transakcijah s tem bolnikom. Za podrobnosti si oglejte časovni pas spodaj
DocType: Material Request,Requested For,Zahtevano za
DocType: SMS Center,All Sales Person,Vsa prodajna oseba
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set default account in Salary Component {0},Nastavite privzeti račun v komponenti Plače {0}
apps/erpnext/erpnext/www/all-products/not_found.html,No products found,Ni najdenih izdelkov
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Rezervirana količina za proizvodnjo: količina surovin za izdelavo izdelkov.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Optional. This setting will be used to filter in various transactions.,Neobvezno. Ta nastavitev bo uporabljena za filtriranje različnih transakcij.
DocType: Stock Entry,Target Warehouse Address,Naslov ciljnega skladišča
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Outward taxable supplies(zero rated),Zunanje obdavčljive dobave (z ničelno stopnjo)
DocType: Sales Invoice,Customer Address,Naslov stranke
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},Sredstvo {0} ne pripada podjetju {1}
apps/erpnext/erpnext/utilities/user_progress.py,Room Capacity,Kapaciteta sobe
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select a batch,Izberite paket
apps/erpnext/erpnext/stock/doctype/item/item.js,Select Attribute Values,Izberite Vrednosti atributov
DocType: Cheque Print Template,Signatory Position,Položaj podpisnika
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Vrstica {0}: Vrsta in pogodbenica se zahtevata za račun terjatev / plačila {1}
apps/erpnext/erpnext/config/manufacturing.py,Production,Proizvodnja
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup post company fixtures,Posodobitev po pošti ni bila nastavljena
DocType: Purchase Invoice Item,Enable Deferred Expense,Omogoči odložene stroške
DocType: Purchase Order,Customer Contact Email,E-poštni naslov za stranke
DocType: Clinical Procedure Template,Collection Details,Podrobnosti zbirke
DocType: Stock Entry Detail,Stock Entry Child,Otrok za vnos zalog
DocType: Request for Quotation Supplier,No Quote,Ni ponudbe
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Sorry, Serial Nos cannot be merged",Žal serijske številke ni mogoče združiti
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 temelji na transakcijah s to prodajno osebo. Za podrobnosti si oglejte časovni pas spodaj
DocType: Course Content,Quiz,Kviz
DocType: Sales Invoice Item,Delivered Qty,Dostavljena količina
DocType: Material Request Plan Item,Minimum Order Quantity,Najmanjša količina naročila
DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Opozori na naročila
DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,"Vloga, ki lahko predloži transakcije, ki presegajo določene omejitve kreditov."
DocType: Employee Boarding Activity,Activity Name,Ime dejavnosti
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,Uskladite ta račun
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Variant Of,Različica
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Target warehouse is mandatory for row {0},Ciljno skladišče je obvezno za vrstico {0}
apps/erpnext/erpnext/config/support.py,Warranty,Garancija
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ID e-pošte skrbnika
DocType: Expense Claim Detail,Expense Claim Type,Vrsta zahtevka za stroške
DocType: Email Digest,Bank Balance,Bančno stanje
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.",Način določanja cen je določen za prepis cenovnega seznama / določanje odstotka popusta na podlagi nekaterih kriterijev.
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Customer Group is Required in POS Profile,Skupina strank je potrebna v profilu POS
DocType: Authorization Rule,Applicable To (Employee),Velja za (zaposlenega)
DocType: Tally Migration,Day Book Data,Dan podatkov o knjigi
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py,Gross Profit / Loss,Bruto dobiček / izguba
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Credit Note Amount,Znesek bančnega kredita
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Payment,Plačilo
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Capacity Planning Error,Napaka pri načrtovanju zmogljivosti
DocType: Supplier,Prevent POs,Preprečiti PO
DocType: QuickBooks Migrator,Authorization Endpoint,Končna točka pooblastila
DocType: Payment Gateway Account,Payment Gateway Account,Račun plačilnega prehoda
,BOM Variance Report,Poročilo o odstopanju BOM
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,"Preostanek svoje organizacije dodajte svojim uporabnikom. Kupce lahko povabite tudi na svoj portal, tako da jih dodate iz imenika"
DocType: Training Event,Employee Emails,E-pošta zaposlenih
DocType: Travel Request,Any other details,Druge podrobnosti
DocType: Patient,Inpatient Status,Stacionarno stanje
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Repayment Entry,Ustvari vnos vračila
apps/erpnext/erpnext/hr/utils.py,A {0} exists between {1} and {2} (,Obstaja {0} med {1} in {2} (
DocType: BOM,Scrap,Ostanki
DocType: Clinical Procedure,Clinical Procedure,Klinični postopek
DocType: Supplier,Hold Type,Tip držite
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Day Book Data,Podatki o knjigi dnevnika procesa
DocType: Fee Validity,Fee Validity,Veljavnost pristojbin
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Ustvarite pristojbine
DocType: Cheque Print Template,Date Settings,Nastavitve datuma
DocType: BOM Operation,Operation Time,Čas delovanja
DocType: Asset,Value After Depreciation,Vrednost po amortizaciji
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Remaining,Preostali
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Lead Count,Vodilni števec
apps/erpnext/erpnext/public/js/setup_wizard.js,The name of your company for which you are setting up this system.,"Ime vašega podjetja, za katerega nastavljate ta sistem."
DocType: Serial No,Out of AMC,Iz AMC
DocType: Job Opening,"Job profile, qualifications required etc.","Profil zaposlitve, zahtevane kvalifikacije itd."
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Ship To State,Ladja v državo
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Ali želite oddati zahtevo za material
DocType: Opportunity Item,Basic Rate,Osnovna stopnja
DocType: Compensatory Leave Request,Work End Date,Datum konca dela
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Request for Raw Materials,Zahteva za surovine
apps/erpnext/erpnext/config/quality_management.py,Quality Goal.,Cilj kakovosti.
apps/erpnext/erpnext/templates/pages/projects.js,Show Open,Pokaži odprto
DocType: Item Attribute,Attribute Name,Ime atributa
apps/erpnext/erpnext/config/non_profit.py,Donor Type information.,Informacije o vrsti darovalca.
DocType: Supplier,Is Transporter,Je prevoznik
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Novi datum izdaje bi moral biti v prihodnosti
DocType: Loan Type,Maximum Loan Amount,Najvišji znesek posojila
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Email not found in default contact,V privzetem kontaktu ni bilo mogoče najti e-pošte
DocType: Hotel Room Reservation,Booked,Rezervirano
DocType: Maintenance Visit,Partially Completed,Delno dokončano
DocType: Quality Procedure Process,Process Description,Opis procesa
DocType: Company,Default Employee Advance Account,Privzeti predujem za zaposlene
DocType: Leave Type,Allow Negative Balance,Dovoli negativno ravnovesje
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Assessment Plan Name,Ime ocenjevalnega načrta
DocType: Supplier,Default Payment Terms Template,Privzeta predloga za plačilne pogoje
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Add more items or open full form,Dodajte več predmetov ali odprite polni obrazec
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,Work Summary for {0},Povzetek dela za {0}
DocType: Academic Term,Academic Term,Akademski mandat
DocType: Pricing Rule,Quantity and Amount,Količina in znesek
DocType: Stock Entry,Target Warehouse Name,Ime ciljnega skladišča
DocType: Employee Tax Exemption Declaration Category,Maximum Exempted Amount,Najvišji oproščeni znesek
DocType: Stock Settings,Sample Retention Warehouse,Vzorčna hramba zadržanja
DocType: Pricing Rule,Discount Percentage,Odstotek popusta
DocType: Company,Company Description,Opis podjetja
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} is not the default supplier for any items.,{0} ni privzeti dobavitelj za vse elemente.
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Item {1},Zaporedna št. {0} ne pripada elementu {1}
DocType: Work Order,Scrap Warehouse,Skladišče odpadkov
apps/erpnext/erpnext/config/non_profit.py,Chapter information.,Informacije v poglavju.
apps/erpnext/erpnext/hr/utils.py,) for {0},) za {0}
DocType: Sales Invoice Item,References,Reference
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Reserved Qty,Rezervirana količina
DocType: Shift Assignment,Shift Type,Vrsta premika
DocType: Delivery Stop,Delivery Stop,Ustavitev dostave
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,No Result to submit,Ni rezultatov
DocType: Loyalty Program,Redemption,Odkup
DocType: Material Request,Transferred,Preneseno
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} has fee validity till {1},{0} ima veljavnost plačila do {1}
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,All Student Admissions,Vsi sprejem študentov
DocType: Travel Request,Address of Organizer,Naslov organizatorja
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Values of exempt, nil rated and non-GST inward supplies","Vrednosti oproščenih, neocenjenih in ne-GST notranjih dobav"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,"Obiski za vzdrževanje {0} morate preklicati, preden prekličete ta prodajni nalog"
DocType: Quotation Item,Stock Balance,Stanje zalog
DocType: Delivery Note Item,Available Qty at From Warehouse,Na voljo Qty at From Warehouse
DocType: Stock Entry,Repack,Prepakirajte
DocType: UOM,Must be Whole Number,Mora biti celotna številka
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Credit limit has been crossed for customer {0} ({1}/{2}),Presežen je bil kreditni limit za stranko {0} ({1} / {2})
apps/erpnext/erpnext/accounts/page/pos/pos.js,Submitted orders can not be deleted,Oddanih nalogov ni mogoče izbrisati
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html,Hello,zdravo
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,Activity Cost exists for Employee {0} against Activity Type - {1},Stroški dejavnosti za zaposlenega {0} obstajajo za vrsto dejavnosti - {1}
DocType: Request for Quotation Item,Request for Quotation Item,Zahteva za postavko ponudbe
apps/erpnext/erpnext/accounts/doctype/item_tax_template/item_tax_template.py,{0} entered twice in Item Tax,{0} je vneseno dvakrat v davku na postavko
DocType: Additional Salary,Deduct Full Tax on Selected Payroll Date,Odbit od celotnega davka na izbranem plačilnem datumu
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Last carbon check date cannot be a future date,Zadnji datum preverjanja emisij ogljika ne more biti prihodnji datum
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Select change amount account,Izberite račun za spremembo zneska
DocType: Support Settings,Forum Posts,Forumska sporočila
DocType: Timesheet Detail,Expected Hrs,Pričakovane ure
DocType: Subscription Plan,Payment Plan,Načrt plačila
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Earliest,Najzgodnejši
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Bank account '{0}' has been synchronized,Bančni račun &quot;{0}&quot; je sinhroniziran
DocType: Program Enrollment Tool,Enroll Students,Vpišite študente
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customer Revenue,Ponovite prihodke strank
DocType: Company,Date of Commencement,Datum začetka
DocType: Bank,Bank Name,Ime banke
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,Veljavni datum mora biti manjši od veljavnega datuma
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,This is based on the attendance of this Employee,To temelji na prisotnosti tega zaposlenega
DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Če je označeno, bo domača stran privzeta skupina elementov za spletno mesto"
DocType: Crop,Row Spacing UOM,Razmik vrstic UOM
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Predložiti je mogoče samo aplikacije s funkcijo »Pusti« s statusom »Odobreno« in »Zavrnjeno«
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Uvozi v večjem obsegu
DocType: Material Request,Terms and Conditions Content,Pravila in pogoji vsebine
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount(Company Currency),Znesek naročila (valuta podjetja)
DocType: Healthcare Practitioner,Hospital,Bolnišnica
,Stock Analytics,Analytics zaloge
apps/erpnext/erpnext/controllers/selling_controller.py,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Stopnja prodaje za postavko {0} je nižja od njene {1}. Stopnja prodaje bi morala biti vsaj {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Application of Funds (Assets),Uporaba sredstev (sredstva)
apps/erpnext/erpnext/config/buying.py,Templates of supplier standings.,Predloge za razvrstitev dobavitelja.
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,"Cenik Valuta, ki ni izbrana"
DocType: Salary Slip,Total in words,Skupaj z besedami
DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Če je omogočeno, bo sistem samodejno knjižil knjiženja za inventar."
DocType: BOM Item,BOM Item,Postavka BOM
DocType: Maintenance Schedule Detail,Scheduled Date,Načrtovani datum
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please enter Maintaince Details first,Najprej vnesite Maintaince Details
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Projected Quantity Formula,Formula predvidene količine
DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Ocena točkovanja dobavitelja Stanje
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the correct code on Mode of Payment {1},Vrstica {0}: nastavite pravilno kodo za način plačila {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",Najvišja korist zaposlenega {0} presega {1} za vsoto {2} prejšnjega zahtevanega zneska
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;,"Stanja zaposlenega ni mogoče nastaviti na »Levo«, saj naslednji zaposleni poročajo temu zaposlenemu:"
DocType: BOM Explosion Item,Source Warehouse,Skladišče vira
apps/erpnext/erpnext/utilities/user_progress.py,Add Users,Dodaj uporabnike
DocType: Exotel Settings,Exotel Settings,Nastavitve Exotela
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Payment Tems,Plačilni deli
DocType: SMS Center,All Sales Partner Contact,Vsi stiki prodajnih partnerjev
apps/erpnext/erpnext/controllers/trends.py,Total(Amt),Skupaj (Amt)
DocType: Bank Statement Transaction Invoice Item,Payment Description,Opis plačila
apps/erpnext/erpnext/accounts/page/pos/pos.js,ZIP Code,Poštna številka
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js,Accumulated Values,Zbrane vrednosti
DocType: Grading Scale,Intervals,Intervali
apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py,Training Events,Usposabljanje
apps/erpnext/erpnext/config/accounting.py,Opening and Closing,Odpiranje in zapiranje
DocType: Production Plan Item,Quantity and Description,Količina in opis
DocType: Payment Entry,Payment Type,Način plačila
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The folio numbers are not matching,Številke folij se ne ujemajo
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},Pregled kakovosti: {0} ni poslan za element: {1} v vrstici {2}
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.js,Show {0},Pokaži {0}
apps/erpnext/erpnext/support/doctype/issue/issue.js,Service Level Agreement Reset.,Dogovor o ravni storitev Ponastavi.
apps/erpnext/erpnext/templates/generators/item/item_configure.js,{0} item found.,{0} najdenih elementov.
,Stock Ageing,Stock Aging
DocType: Customer Group,Mention if non-standard receivable account applicable,"Navedite, če se uporablja nestandardni račun terjatev"
,Subcontracted Item To Be Received,"Pododdeljena postavka, ki jo je treba prejeti"
DocType: Item,Synced With Hub,Sinhronizirano s pestom
apps/erpnext/erpnext/hr/utils.py,To date can not be less than from date,Do danes ne more biti manj kot od datuma
DocType: Guardian,Work Address,Naslov dela
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Total completed qty can not be greater than for quantity,Skupna zaključena količina ne more biti večja od količine
DocType: POS Item Group,POS Item Group,Skupina POS postavk
DocType: Homepage,Company Description for website homepage,Opis podjetja za domačo stran spletnega mesta
,Delivery Note Trends,Trendi obvestila o dostavi
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Ustavljenega proizvodnega naloga ni mogoče preklicati, najprej prekličite prekinitev"
DocType: Share Balance,Current State,Trenutno stanje
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open Item {0},Odpri element {0}
,Batch-Wise Balance History,Batch-Wise Balance zgodovina
DocType: Monthly Distribution Percentage,Percentage Allocation,Dodelitev odstotkov
DocType: Vital Signs,One Sided,Ena stran
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian2,Povezava z Guardian2
DocType: Asset,Disposal Date,Datum odstranitve
DocType: Opportunity,Opportunity Type,Vrsta priložnosti
DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Predloga za preslikavo denarnega toka
DocType: Asset Settings,Depreciation Options,Možnosti amortizacije
DocType: Student Admission,Admission Start Date,Datum začetka vstopa
DocType: Manufacturing Settings,Update BOM Cost Automatically,Samodejno posodobi ceno BOM
DocType: Subscription Settings,Subscription Settings,Nastavitve naročnine
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CGST Amount,Znesek CGST
DocType: Amazon MWS Settings,Seller ID,ID prodajalca
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,'To Case No.' cannot be less than 'From Case No.',&quot;V zadevo št.&quot; ne more biti manjša od &quot;Iz zadeve št.&quot;
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","Združitev je mogoča le, če so naslednje lastnosti v obeh zapisih enake. Je skupina, Root Type, Company"
DocType: SMS Log,SMS Log,Dnevnik SMS
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please specify either Quantity or Valuation Rate or both,Navedite količino ali stopnjo vrednotenja ali oboje
DocType: Salary Component,Amount based on formula,Znesek temelji na formuli
apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Omogoči samodejno ponovno naročanje
DocType: Clinical Procedure Item,Transfer Qty,Količina prenosa
apps/erpnext/erpnext/setup/doctype/company/company.js,Cost Centers,Stroškovna središča
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Paket je obvezen v vrstici {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Error in formula or condition: {0},Napaka v formuli ali pogoju: {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",Za vključitev davka v vrstico {0} v postavko za postavko je treba vključiti tudi davke v vrsticah {1}
,Trial Balance (Simple),Poskusno stanje (preprosto)
DocType: Purchase Order,Customer Contact,Stiki s strankami
DocType: Marketplace Settings,Registered,Registriran
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Gross Purchase Amount is mandatory,Bruto znesek nakupa je obvezen
DocType: Fee Structure,Components,Komponente
DocType: Pricing Rule,Promotional Scheme,Promocijska shema
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Account {1} does not belong to company {2},Vrstica # {0}: Račun {1} ne pripada podjetju {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},Skupna višina prilagodljivega zneska prispevka {0} ne sme biti manjša od najvišje ugodnosti {1}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From GSTIN,Iz GSTIN
DocType: Sales Invoice,Return Against Sales Invoice,Povračilo pred prodajnim računom
DocType: Item Variant Settings,Rename Attribute Value in Item Attribute.,Preimenuj vrednost atributa v atributu postavke.
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 čakalni vrsti za posodobitev zadnje cene v vseh gradivih. To lahko traja nekaj minut.
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select a warehouse,Izberite skladišče
DocType: Purchase Invoice Item,Weight UOM,Teža UOM
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Accounts Payable Summary,Povzetek obveznosti do dobaviteljev
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Order {1},{0} v primerjavi s prodajnim nalogom {1}
DocType: Payroll Employee Detail,Payroll Employee Detail,Podrobnosti o plačah zaposlenih
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Admission and Enrollment,Vpis in vpis
DocType: Budget Account,Budget Amount,Znesek proračuna
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},Račun {0} se ne ujema s podjetjem {1} v načinu računa: {2}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Please enter Receipt Document,Vnesite dokument o prejemu
DocType: Naming Series,Change the starting / current sequence number of an existing series.,Spremenite začetno / trenutno zaporedno številko obstoječe serije.
apps/erpnext/erpnext/config/hr.py,Employee Lifecycle,Življenjski cikel zaposlenih
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Quantity must be less than quantity {0},Za količino mora biti manjša od količine {0}
DocType: Assessment Plan,Assessment Plan,Načrt ocenjevanja
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js,Warranty Claim,Zahtevek za garancijo
DocType: Company,Date of Incorporation,Datum ustanovitve
DocType: Asset,Double Declining Balance,Dvostransko ravnovesje
apps/erpnext/erpnext/erpnext_integrations/connectors/shopify_connection.py,Tax Account not specified for Shopify Tax {0},Davčni račun ni naveden za davčno obvestilo Shopify {0}
DocType: Payroll Entry,Validate Attendance,Potrdite prisotnost
DocType: Lab Test,LP-,LP-
DocType: POS Customer Group,POS Customer Group,POS skupina kupcev
,Qty to Deliver,Količina za dostavo
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} is required,Fiskalno leto {0} je potrebno
DocType: HR Settings,Employee Records to be created by,"Zapisi zaposlenih, ki jih bo ustvaril"
DocType: Depreciation Schedule,Depreciation Amount,Amortizacija Znesek
DocType: Sales Order Item,Gross Profit,Bruto dobiček
DocType: Quality Inspection,Item Serial No,Zaporedna št
DocType: Asset,Insurer,Zavarovalnica
DocType: Employee Checkin,OUT,OUT
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Buying Amount,Znesek nakupa
DocType: Asset Maintenance Task,Certificate Required,Zahtevano potrdilo
DocType: Retention Bonus,Retention Bonus,Bonus za zadržanje
DocType: Item,Asset Naming Series,Serije za poimenovanje sredstva
DocType: Healthcare Settings,Laboratory Settings,Laboratorijske nastavitve
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Amount of Integrated Tax,Znesek integriranega davka
DocType: Branch,Branch,Podružnica
DocType: Request for Quotation Item,Required Date,Zahtevani datum
DocType: Cashier Closing,Returns,Vrne
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Negotiation/Review,Pogajanja / pregled
,Stock Summary,Povzetek zalog
DocType: Bank Reconciliation,From Date,Od datuma
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","Zahtevate lahko samo znesek v višini {0}, preostali znesek {1} pa v aplikaciji kot pro-rata komponento"
DocType: Warehouse,A logical Warehouse against which stock entries are made.,"Logično skladišče, na podlagi katerega se izvedejo vnosi zalog."
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Difference Account,Račun razlike
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?,S tem boste poslali plače in ustvarili vnos v dnevnik nastanka. Ali želite nadaljevati?
DocType: Manufacturer,Manufacturers used in Items,"Proizvajalci, ki se uporabljajo v izdelkih"
apps/erpnext/erpnext/education/__init__.py,Student {0} does not belong to group {1},Študent {0} ne pripada skupini {1}
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Ohraniti enako stopnjo v celotnem nakupnem ciklu
apps/erpnext/erpnext/setup/doctype/company/company.py,Set default inventory account for perpetual inventory,Za trajni inventar nastavite privzeti račun inventarja
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Pending,Ustvarjanje pristojbin v teku
DocType: Accounts Settings,Unlink Advance Payment on Cancelation of Order,Prekličite predplačilo pri preklicu naročila
apps/erpnext/erpnext/config/crm.py,Visit report for maintenance call.,Obiščite poročilo za vzdrževalni klic.
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.","Da bi dobili najboljše od ERPNext, vam priporočamo, da si vzamete nekaj časa in si ogledate te videoposnetke za pomoč."
DocType: Fertilizer Content,Fertilizer Content,Vsebina gnojil
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot delete Serial No {0}, as it is used in stock transactions","Serijske št. {0} ni mogoče izbrisati, ker se uporablja v transakcijah z zalogami"
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Charges are updated in Purchase Receipt against each item,Stroški se posodabljajo v potrdilu o nakupu za vsak element
DocType: Account,Credit,Kredit
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Download JSON,Prenesite JSON
DocType: Sales Invoice,Loyalty Amount,Znesek zvestobe
DocType: Account,Accounts,Računi
DocType: Loyalty Program,Expiry Duration (in days),Trajanje poteka (v dnevih)
DocType: Pricing Rule,Product Discount Scheme,Shema popustov za izdelke
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Creating Company and Importing Chart of Accounts,Ustvarjanje podjetja in uvozni kontni načrt
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Stock Available,Na zalogi
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign to Employees,Dodeli zaposlenim
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,No employees for the mentioned criteria,Ni zaposlenih za navedene kriterije
apps/erpnext/erpnext/accounts/page/pos/pos.js,Not items found,Ni najdenih elementov
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Job card {0} created,Ustvarjena je bila delovna kartica {0}
DocType: Delivery Note,Is Return,Je vrnitev
DocType: Soil Analysis Criteria,Soil Analysis Criteria,Merila za analizo tal
DocType: Quiz Result,Selected Option,Izbrana možnost
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Bank Data mapper doesn't exist,Banka podatkovnih kartografov ne obstaja
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Preview Salary Slip,Predogled Izplačilo plač
DocType: Asset,Assets,Sredstva
DocType: Pricing Rule,Rate or Discount,Cena ali popust
DocType: Travel Itinerary,Non-Vegetarian,Non-Vegetarian
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Outstanding: {0},Skupaj neporavnanih: {0}
DocType: Appraisal,For Employee Name,Za ime zaposlenega
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js,Unknown,Neznano
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Offline Invoices,Sinhroniziranje računov brez povezave
DocType: Practitioner Schedule,Schedule Name,Ime urnika
DocType: Shopify Settings,Shopify Settings,Nastavitve Shopify
DocType: Company,Sales Monthly History,Prodajna mesečna zgodovina
apps/erpnext/erpnext/stock/doctype/item/item.py,'Has Serial No' can not be 'Yes' for non-stock item,"&quot;Serijska št.&quot; Ne more biti &quot;Da&quot; za element, ki ni na zalogi"
DocType: Bank Account,GL Account,GL Račun
apps/erpnext/erpnext/regional/report/hsn_wise_summary_of_outward_supplies/hsn_wise_summary_of_outward_supplies.py,Total Taxable Amount,Skupni obdavčljivi znesek
apps/erpnext/erpnext/controllers/item_variant.py,Invalid attribute {0} {1},Neveljaven atribut {0} {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial no {0} has been already returned,Serijska številka {0} je bila že vrnjena
DocType: Maintenance Schedule,MAT-MSH-.YYYY.-,MAT-MSH-.LLLL.-
DocType: Student Group Student,Group Roll Number,Številka skupine zvonjenja
DocType: QuickBooks Migrator,Default Shipping Account,Privzeti račun za pošiljanje
DocType: Work Order,MFG-WO-.YYYY.-,MFG-WO-.YYYY.-
DocType: Subscription,Trialling,Trialing
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid transactions sync error,Napaka sinhronizacije s transakcijami v kritju
DocType: Loyalty Program,Single Tier Program,Enotni program
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Against Loan: {0},Proti posojilu: {0}
DocType: Tax Withholding Category,Tax Withholding Rates,Davčne odtegljaj
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Community Forum,Forum skupnosti
apps/erpnext/erpnext/config/integrations.py,Connect your bank accounts to ERPNext,Povežite svoje bančne račune z ERPNext
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Account Type for {0} must be {1},Vrsta računa za {0} mora biti {1}
DocType: Purchase Receipt Item Supplied,Required Qty,Zahtevana količina
apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py,Please select Completion Date for Completed Repair,Izberite Datum dokončanja za dokončano popravilo
DocType: Clinical Procedure,Medical Department,Zdravstveni oddelek
DocType: Share Transfer,From Shareholder,Od delničarja
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Time Slots,Dodaj časovne reže
DocType: Sales Order Item,Ensure Delivery Based on Produced Serial No,Zagotovite dostavo na podlagi proizvedene serijske številke
apps/erpnext/erpnext/hr/doctype/hr_settings/hr_settings.js,Password policy cannot contain spaces or simultaneous hyphens. The format will be restructured automatically,Pravilnik o geslih ne sme vsebovati presledkov ali sočasnih vezajev. Oblika se bo samodejno prestrukturirala
,Eway Bill,Eway Bill
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Sub Type,Podtip
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,ERPNext could not find any matching payment entry,ERPNext ni našel nobenega ustreznega plačilnega vnosa
DocType: Task,Closing Date,Datum zaključka
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Go to the Desktop and start using ERPNext,Pojdite na namizje in začnite uporabljati ERPNext
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Duplicate Serial No entered for Item {0},"Podvojena serijska številka, vnesena za element {0}"
DocType: Item Price,Packing Unit,Enota za pakiranje
DocType: Travel Request,International,International
DocType: Item Tax Template Detail,Item Tax Template Detail,Podrobnosti predloga predloge za davek
DocType: BOM Update Tool,New BOM,Nova BOM
DocType: Supplier,Is Internal Supplier,Je notranji dobavitelj
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Reject,Zavrni
DocType: Salary Slip,net pay info,info o neto plačilu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Duties and Taxes,Dajatve in davki
DocType: Appraisal Goal,Score Earned,Zaslužen rezultat
DocType: Task,Dependent Tasks,Odvisne naloge
DocType: Tax Rule,Shipping Zipcode,Poštna številka za pošiljanje
DocType: Naming Series,Update Series,Posodobi serijo
apps/erpnext/erpnext/public/js/setup_wizard.js,"e.g. ""Build tools for builders""",npr. &quot;Build tools for builders&quot;
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Prospecting,Iskanje
DocType: Bank Statement Transaction Entry,Bank Statement,Bančni izpisek
DocType: Appointment Type,Default Duration,Privzeto trajanje
apps/erpnext/erpnext/config/buying.py,Default settings for buying transactions.,Privzete nastavitve za nakupne transakcije.
DocType: Work Order Operation,Actual Time and Cost,Dejanski čas in stroški
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Evaluation,Vrednotenje
apps/erpnext/erpnext/controllers/accounts_controller.py,Account: {0} with currency: {1} can not be selected,Račun: {0} z valuto: {1} ni mogoče izbrati
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Lifecycle,Življenski krog
DocType: Student Sibling,Studying in Same Institute,Študij v istem inštitutu
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Course Code: ,Šifra predmeta:
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution %,Prispevek%
DocType: Journal Entry,Credit Note,Dobropis
DocType: Batch,Parent Batch,Matična serija
DocType: Payment Reconciliation,Get Unreconciled Entries,Pridobite neusklajene vnose
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Please set the Company,"Prosimo, nastavite podjetje"
DocType: Lead,Lead Type,Vrsta svinca
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Vrstica # {0}: Datum knjiženja mora biti enak datumu nakupa {1} sredstva {2}
DocType: Payment Entry,Difference Amount (Company Currency),Znesek razlike (valuta podjetja)
DocType: Invoice Discounting,Sanctioned,Sankcionirano
DocType: Course Enrollment,Course Enrollment,Vpis v tečaj
DocType: Item,Supplier Items,Izdelki dobavitelja
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,"Start Time can't be greater than or equal to End Time \
					for {0}.",Začetni čas ne sme biti večji ali enak končnemu času za {0}.
DocType: Sales Order,Not Applicable,Se ne uporablja
DocType: Support Search Source,Response Options,Možnosti odziva
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py,{0} should be a value between 0 and 100,Vrednost {0} mora biti med 0 in 100
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Select Difference Account,Izberite Račun razlike
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Sales Person,Prodajalec
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Packing Slip,Pakirni listič
apps/erpnext/erpnext/config/manufacturing.py,Global settings for all manufacturing processes.,Globalne nastavitve za vse proizvodne procese.
DocType: Shopify Settings,Customer Group will set to selected group while syncing customers from Shopify,"Skupina strank bo nastavljena na izbrano skupino, medtem ko stranke sinhronizirajo iz storitve Shopify"
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Apply Now,Prijavi se zdaj
DocType: Accounts Settings,Credit Controller,Kreditni kontrolor
DocType: BOM,Exploded_items,Exploded_items
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Done,Končano
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Manufacturing Quantity is mandatory,Količina proizvodnje je obvezna
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Bypass credit check at Sales Order ,Prekličite preverjanje kreditne sposobnosti pri prodajnem nalogu
DocType: Bin,Stock Value,Vrednost zalog
apps/erpnext/erpnext/config/hr.py,Employee Tax and Benefits,Davki in prejemki zaposlenih
apps/erpnext/erpnext/config/accounting.py,Tax template for item tax rates.,Predloga davka za davčne stopnje izdelka.
apps/erpnext/erpnext/accounts/party.py,{0} {1} is not active,{0} {1} ni aktiven
DocType: Inpatient Record,O Positive,O Pozitivno
DocType: Training Event,Training Program,Program usposabljanja
DocType: Cashier Closing Payments,Cashier Closing Payments,Blagajna Zapiranje plačil
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,The 'From Package No.' field must neither be empty nor it's value less than 1.,"&quot;Iz paketa št.&quot; polje ne sme biti prazno, niti vrednost ni manjša od 1."
,Purchase Order Trends,Trendi naročilnice
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Please enter parent cost center,Vnesite matično stroškovno mesto
DocType: Purchase Receipt,Supplier Delivery Note,Opomba o dobavi dobavitelja
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Drug,Izberite Drug
DocType: Support Settings,Post Route Key,Ključ poti objave
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Student Admissions,Sprejem študentov
apps/erpnext/erpnext/config/non_profit.py,Memebership Details,Podrobnosti o članstvu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Probation,Probacija
,Inactive Sales Items,Neaktivne prodajne postavke
DocType: Amazon MWS Settings,AU,AU
DocType: Vital Signs,Abdomen,Abdomen
DocType: HR Settings,Employee Settings,Nastavitve zaposlenih
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Arrear,Zaprto
apps/erpnext/erpnext/config/buying.py,Supplier Group master.,Glavni dobavitelj skupine.
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py,A customer with the same name already exists,Stranka z istim imenom že obstaja
DocType: Course Enrollment,Program Enrollment,Vpis programa
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}",Odpiranje delovnih mest za oznako {0} je že odprto ali najem zaključen glede na načrt zaposlenih {1}
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Pooblaščeni podpisnik
DocType: Pricing Rule,Discount on Other Item,Popust na drugo postavko
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot Count,Quot Count
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Ni najdenih učencev
DocType: Journal Entry,Bank Entry,Vnos banke
DocType: Antibiotic,Antibiotic,Antibiotik
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.,"Odstotek, ki ga lahko prejmete ali dostavite več proti naročeni količini. Na primer: Če ste naročili 100 enot. in vaš dodatek je 10%, potem je dovoljeno prejemati 110 enot."
apps/erpnext/erpnext/config/support.py,Support queries from customers.,Podpora poizvedb strank.
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Actual,Dejansko
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Material Requests in the above table,V zgornjo tabelo vnesite zahteve za material
DocType: Item Reorder,Item Reorder,Postavka zamenjave
DocType: Company,Stock Settings,Nastavitve zalog
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No is mandatory,Vrstica # {0}: Serijska številka je obvezna
DocType: Homepage Section,Number of columns for this section. 3 cards will be shown per row if you select 3 columns.,"Število stolpcev za ta razdelek. Če izberete 3 stolpce, se v vrstici prikažejo 3 kartice."
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py,Consultations,Posvetovanja
DocType: Employee Benefit Claim,Claim Benefit For,Koristi od zahtevka za
DocType: Fiscal Year,Year Name,Ime leta
DocType: Bank Statement Transaction Entry,Reconciled Transactions,Usklajene transakcije
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.,"Odstotek, ki ga lahko zaračunate več v primerjavi z naročenim zneskom. Na primer: Če je vrednost naročila 100 EUR, je odstopanje nastavljeno na 10%, lahko obračunate za 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,"Opomba: Sistem ne bo preverjal prevelike dobave in presežne rezervacije za postavko {0}, ker je količina ali znesek 0"
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,Opening Balance,Začetno stanje
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,'From Date' must be after 'To Date',&quot;Od datuma&quot; mora biti po &quot;datumu&quot;
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Total Amount {0},Skupni znesek {0}
DocType: Employee Skill,Evaluation Date,Datum vrednotenja
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot be Purchase Item also","&quot;Postavka, ki jo je predložil uporabnik&quot; ne more biti tudi predmet nakupa"
DocType: C-Form Invoice Detail,Grand Total,Skupna vsota
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 kreditni limit je manjši od trenutnega neporavnanega zneska za stranko. Omejitev kredita mora biti vsaj {0}
apps/erpnext/erpnext/shopping_cart/cart.py,Only {0} in stock for item {1},Samo {0} na zalogi za element {1}
DocType: Payment Reconciliation,Bank / Cash Account,Bančni / denarni račun
DocType: Serial No,Creation Date,Datum nastanka
apps/erpnext/erpnext/manufacturing/report/bom_variance_report/bom_variance_report.py,Finished Good,Končano dobro
DocType: Healthcare Settings,Manage Sample Collection,Upravljanje zbirke vzorcev
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Unable to find DocType {0},Ni mogoče najti DocType {0}
DocType: Purchase Invoice Item,Item Weight Details,Postavka Teža Podrobnosti
DocType: POS Closing Voucher,Modes of Payment,Načini plačila
DocType: Naming Series,Series List for this Transaction,Seznam serij za to transakcijo
DocType: Crop,Produce,Proizvajamo
DocType: Woocommerce Settings,API consumer key,Ključ potrošnikov API
DocType: Quality Inspection Reading,Reading 2,Branje 2
DocType: Driver,Driving License Categories,Kategorije vozniških dovoljenj
DocType: Asset Repair,Asset Repair,Popravilo sredstev
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation,Revalorizacija deviznega tečaja
DocType: Warehouse,Warehouse Contact Info,Podatki o stikih v skladišču
DocType: Request for Quotation Supplier,Request for Quotation Supplier,Zahtevek za ponudbo ponudb
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Please complete your Plaid API configuration before synchronizing your account,Pred sinhronizacijo računa dokončajte konfiguracijo Plaid API-ja
DocType: Travel Request,Costing,Stroški
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Fixed Assets,Fiksna sredstva
DocType: Purchase Order,Ref SQ,Ref SQ
DocType: Salary Structure,Total Earning,Skupaj zaslužek
DocType: Share Balance,From No,Od št
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Račun poravnave plačil
DocType: Purchase Invoice,Taxes and Charges Added,Dodani davki in pristojbine
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Razmislite o davku ali dajatev za
DocType: Authorization Rule,Authorized Value,Pooblaščena vrednost
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Received From,Prejeto od
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} does not exist,Skladišče {0} ne obstaja
DocType: Item Manufacturer,Item Manufacturer,Proizvajalec izdelka
DocType: Sales Invoice,Sales Team,Prodajna ekipa
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,Bundle Qty,Količina paketa
DocType: Purchase Order Item Supplied,Stock UOM,Stock UOM
DocType: Installation Note,Installation Date,Datum namestitve
DocType: Email Digest,New Quotations,Nove ponudbe
DocType: Production Plan Item,Ordered Qty,Naročena količina
,Minutes to First Response for Issues,Zapisnik do prvega odgovora na vprašanja
DocType: Vehicle Log,Refuelling Details,Podrobnosti o polnjenju z gorivom
DocType: Sales Partner,Targets,Cilji
DocType: Buying Settings,Settings for Buying Module,Nastavitve za nakupni modul
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Purchase Order {0} is not submitted,Naročilo za nakup {0} ni poslano
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Material Request {0} submitted.,Zahteva za material {0} je bila poslana.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Posting date and posting time is mandatory,Datum knjiženja in čas knjiženja sta obvezna
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,{} of {},{} od {}
DocType: Lab Test Template,Lab Routine,Rutina laboratorija
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Failed. Please check your GoCardless Account for more details,"Plačilo ni uspelo. Prosimo, preverite svoj GoCardless račun za več podrobnosti"
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Row {0}:Start Date must be before End Date,Vrstica {0}: začetni datum mora biti pred končnim datumom
apps/erpnext/erpnext/config/education.py,LMS Activity,Dejavnost LMS
DocType: Asset,Next Depreciation Date,Datum naslednje amortizacije
DocType: Healthcare Settings,Appointment Reminder,Opomnik za sestanek
DocType: Cost Center,Cost Center Name,Ime mesta stroškov
DocType: Pricing Rule,Margin Rate or Amount,Stopnja marže ali znesek
DocType: Healthcare Settings,Clinical Procedure Consumable Item,Klinični postopek Potrošni material
DocType: Asset,Manual,Priročnik
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Raw Materials cannot be blank.,Surovine ne smejo biti prazne.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please enter Cost Center,Vnesite stroškovno središče
DocType: Support Search Source,Source DocType,Vir DocType
DocType: Assessment Group,Parent Assessment Group,Skupina za ocenjevanje staršev
DocType: Purchase Invoice Item,Accepted Warehouse,Sprejeto skladišče
DocType: Sales Invoice Item,Discount and Margin,Popust in marža
,Student and Guardian Contact Details,Kontaktni podatki za študente in skrbnike
DocType: Pricing Rule,Buying,Nakup
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Unknown Number,Neznana številka
DocType: Student Attendance,Present,Prisotna
DocType: Membership,Member Since,Član od
DocType: Tax Rule,Use for Shopping Cart,Uporabite za nakupovalno košarico
DocType: Loan,Loan Account,Posojilni račun
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,All the mandatory Task for employee creation hasn't been done yet.,Vse obvezne naloge za ustvarjanje zaposlenih še niso bile opravljene.
DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Najmanjša dolžina med vsako napravo na polju za optimalno rast
DocType: Budget,Applicable on Purchase Order,Velja za naročilnico
DocType: Stock Entry,Receive at Warehouse,Prejmite v skladišču
DocType: Cash Flow Mapping,Is Income Tax Expense,Je davek na dohodek
DocType: Journal Entry,Make Difference Entry,Vstop za razliko
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Total (Credit),Skupaj (kredit)
apps/erpnext/erpnext/public/js/setup_wizard.js,The Brand,Znamka
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 3,Točka 3
DocType: Purchase Invoice Item,Deferred Expense Account,Odloženi račun za odhodke
DocType: Depreciation Schedule,Accumulated Depreciation Amount,Znesek amortizacije
apps/erpnext/erpnext/controllers/stock_controller.py,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Mesto stroškov je obvezno za element {2}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,No accounting entries for the following warehouses,Za naslednja skladišča ni računovodskih vpisov
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Please save first,Najprej shranite
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Extra Small,Extra Small
DocType: Assessment Group,Assessment Group,Ocenjevalna skupina
DocType: Pricing Rule,UOM,UOM
apps/erpnext/erpnext/config/accounting.py,Bills raised by Suppliers.,Računi dobaviteljev.
DocType: Additional Salary,HR User,Uporabnik HR
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py,Profit for the year,Dobiček za leto
DocType: Codification Table,Medical Code,Medicinski kodeks
apps/erpnext/erpnext/config/accounting.py,Update bank payment dates with journals.,Posodobite datume bančnih plačil z dnevniki.
apps/erpnext/erpnext/controllers/item_variant.py,The value {0} is already assigned to an exisiting Item {2}.,Vrednost {0} je že dodeljena obstoječi postavki {2}.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Current Assets,Tekoča sredstva
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} does not belong to company {2},Vrstica # {0}: Sredstvo {1} ne pripada podjetju {2}
DocType: Purchase Invoice,Contact Person,Kontaktna oseba
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Batch {2},{0} - {1} ni vpisan v paketni {2}
DocType: Holiday List,Holiday List Name,Ime prazničnega seznama
DocType: Water Analysis,Collection Temperature ,Temperatura zbiranja
DocType: Healthcare Settings,Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Upravljajte račun za sestanke in ga samodejno prekličite za Patient Encounter
DocType: Employee Benefit Claim,Claim Date,Datum zahtevka
DocType: Supplier,Leave blank if the Supplier is blocked indefinitely,"Pustite prazno, če je dobavitelj blokiran za nedoločen čas"
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Attendance From Date and Attendance To Date is mandatory,Udeležba od datuma in obiska do datuma je obvezna
DocType: Serial No,Out of Warranty,Izven garancije
apps/erpnext/erpnext/buying/utils.py,Same item cannot be entered multiple times.,Istega elementa ni mogoče večkrat vnesti.
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Select students manually for the Activity based Group,"Za skupine, ki temeljijo na aktivnosti, ročno izberite učence"
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Series Updated,Serija posodobljena
DocType: Employee,Date Of Retirement,Datum upokojitve
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Please select Patient,Izberite bolnika
DocType: Asset,Straight Line,Ravna črta
DocType: Quality Action,Resolutions,Resolucije
DocType: SMS Log,No of Sent SMS,Št. Poslanih SMS
,GST Itemised Sales Register,GST Prodajni register po točkah
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Skupni znesek predplačila ne sme biti večji od skupnega zneska sankcije
DocType: Lab Test,Test Name,Ime preizkusa
DocType: Task,Total Billing Amount (via Time Sheet),Skupni znesek obračuna (prek časovnega lista)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Quotation {0} is cancelled,Ponudba {0} je preklicana
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Clear values,Počisti vrednosti
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Traceability,Sledljivost
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py,Same Company is entered more than once,Ista družba se vnese več kot enkrat
DocType: Delivery Stop,Contact Name,Kontaktno ime
DocType: Customer,Is Internal Customer,Je notranja stranka
DocType: Purchase Taxes and Charges,Account Head,Vodja računa
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Lower Income,Nižji dohodek
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py,Start date should be less than end date for task {0},Začetni datum mora biti manjši od končnega datuma za opravilo {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Customer Service,Storitev za stranke
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Pristojbina
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} does not belong to Item {1},BOM {0} ne pripada elementu {1}
DocType: Daily Work Summary,Daily Work Summary Group,Skupina dnevnih povzetkov dela
apps/erpnext/erpnext/config/help.py,Customizing Forms,Prilagajanje obrazcev
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Cancel Material Visit {0} before cancelling this Warranty Claim,"Prekličite material Obiščite {0}, preden prekličete ta zahtevek za garancijo"
DocType: POS Profile,Ignore Pricing Rule,Prezri pravilo o cenah
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Food,Hrana
DocType: Lost Reason Detail,Lost Reason Detail,Podrobnosti izgubljenega razloga
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,The following serial numbers were created: <br> {0},Ustvarjene so bile naslednje serijske številke: <br> {0}
DocType: Maintenance Visit,Customer Feedback,Povratne informacije strank
DocType: Serial No,Warranty / AMC Details,Podrobnosti o garanciji / AMC
DocType: Issue,Opening Time,Čas odpiranja
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,View a list of all the help videos,Oglejte si seznam vseh videoposnetkov za pomoč
DocType: Purchase Invoice,Party Account Currency,Valuta računa stranke
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select a field to edit from numpad,"Iz številske vrstice izberite polje, ki ga želite urediti"
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Merila za načrt ocenjevanja
DocType: Products Settings,Item Fields,Polja postavk
apps/erpnext/erpnext/config/selling.py,Manage Sales Partners.,Upravljanje prodajnih partnerjev.
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py,"Cannot declare as lost, because Quotation has been made.","Ne morem razglasiti, da je izgubljeno, ker je bila narejena ponudba."
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Tukaj lahko ohranite družinske podrobnosti, kot so ime in poklic staršev, zakonca in otrok"
DocType: Tax Rule,Shipping City,Dostava City
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update Items,Elementi posodobitve
,Customer Ledger Summary,Povzetek glavne knjige
DocType: Inpatient Record,B Positive,B Pozitivno
apps/erpnext/erpnext/config/accounting.py,Accounting journal entries.,Računovodski vnosi v dnevnik.
DocType: Buying Settings,Purchase Order Required,Zahtevana je bila naročilnica
DocType: Program Enrollment Tool,New Student Batch,Nova študentska serija
DocType: Account,Account Type,Vrsta računa
DocType: Terms and Conditions,Applicable Modules,Uporabni moduli
DocType: Vehicle,Fuel Type,Vrsta goriva
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Email sent to {0},"E-poštno sporočilo, poslano na {0}"
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Change Release Date,Spremeni datum izdaje
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Default BOM for {0} not found,Privzeta BOM za {0} ni bila najdena
,HSN-wise-summary of outward supplies,HSN-povzetek izhodnih dobav
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py,Appointments and Encounters,Imenovanja in srečanja
DocType: Tax Withholding Category,Tax Withholding Category,Kategorija zadržanja davka
DocType: Agriculture Analysis Criteria,Linked Doctype,Povezan Doctype
DocType: Account,Cost of Goods Sold,Cena prodanega blaga
DocType: Quality Inspection Reading,Reading 3,Branje 3
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Voucher,Skupina z vavčerjem
,Delivered Items To Be Billed,"Dostavljene postavke, ki jih je treba zaračunati"
DocType: Employee Transfer,Employee Transfer Details,Podrobnosti prenosa zaposlenih
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Registrske številke podjetja za vašo referenco. Davčne številke itd.
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Warehouse {1},Zaporedna št. {0} ne pripada skladišču {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 lahko določite vse naloge, ki jih morate opraviti za ta pridelek. Dansko polje se uporablja za navedbo dneva, ko je treba opraviti nalogo, pri čemer je 1 dan prvi dan itd."
DocType: Asset Maintenance Log,Task,Naloga
DocType: Naming Series,Help HTML,Pomoč HTML
DocType: Drug Prescription,Dosage by time interval,Doziranje po časovnem intervalu
DocType: Batch,Batch Description,Opis serije
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py,Please set associated account in Tax Withholding Category {0} against Company {1},Nastavite povezani račun v kategoriji zadržanja davka {0} proti podjetju {1}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Needs Analysis,Analiza potreb
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Allocated Leaves,Dodeljeni listi
DocType: Payment Request,Transaction Details,Podrobnosti o transakciji
DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.","Objavi &quot;Na zalogi&quot; ali &quot;Ni na zalogi&quot; na vozlišču glede na zalogo, ki je na voljo v tem skladišču."
apps/erpnext/erpnext/setup/doctype/company/company.js,Company name not same,Ime podjetja ni isto
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Employee Promotion cannot be submitted before Promotion Date ,Promocije zaposlenih ne morete oddati pred datumom promocije
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Not allowed to update stock transactions older than {0},"Ni dovoljeno posodabljati transakcij z zalogami, starejših od {0}"
DocType: Employee Checkin,Employee Checkin,Zaposleni Checkin
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Start date should be less than end date for Item {0},Začetni datum mora biti manjši od končnega datuma za element {0}
apps/erpnext/erpnext/utilities/activation.py,Create customer quotes,Ustvarite ponudbe strank
DocType: Buying Settings,Buying Settings,Nastavitve za nakup
DocType: Restaurant Menu Item,Restaurant Menu Item,Meni restavracije
DocType: Appraisal,Calculate Total Score,Izračunaj skupni rezultat
DocType: Issue,Issue Type,Vrsta težave
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Balance Value,Stanje bilance
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Groups,Skupine
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Target warehouse in row {0} must be same as Work Order,Ciljno skladišče v vrstici {0} mora biti enako kot delovni nalog
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Serial Number: {0} is already referenced in Sales Invoice: {1},Serijska številka: {0} je že navedena v računu za prodajo: {1}
DocType: Shopify Settings,"If Shopify not contains a customer in Order, then while syncing Orders, the system will consider default customer for order","Če Shopify ne vsebuje stranke v naročilu, potem bo med sinhronizacijo naročil sistem upošteval privzeto naročilo"
DocType: Shopify Settings,Shopify Tax Account,Davčni račun Shopify
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.,"Prepričajte se, da res želite izbrisati vse transakcije za to podjetje. Vaši glavni podatki bodo ostali taki, kot so. Tega dejanja ni mogoče razveljaviti."
DocType: Purchase Receipt,Auto Repeat Detail,Podrobnosti o samodejnem ponavljanju
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Please supply the specified items at the best possible rates,"Prosimo, navedite navedene izdelke po najboljših možnih cenah"
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} in row {1},{0} v vrstici {1}
DocType: Job Card Time Log,Job Card Time Log,Dnevnik časovne kartice delovnega mesta
DocType: Patient,Patient Demographics,Demografija bolnikov
DocType: Share Transfer,To Folio No,Na Folio št
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Operations,Denarni tok iz poslovanja
DocType: Employee Checkin,Log Type,Vrsta dnevnika
DocType: Stock Settings,Allow Negative Stock,Dovoli negativno zalogo
DocType: Call Log,Ringing,Zvonjenje
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,None of the items have any change in quantity or value.,Nobena od postavk ne spreminja količine ali vrednosti.
DocType: Asset,Purchase Date,Datum nakupa
DocType: Bank Statement Transaction Settings Item,Bank Statement Transaction Settings Item,Postavka transakcijskih postavk bančnega izpiska
,BOM Stock Report,BOM Poročilo o zalogah
apps/erpnext/erpnext/public/js/payment/pos_payment.html,Write Off,Odpisati
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,"Vrstica {0}: Pričakovana vrednost po tem, ko mora biti uporabna življenjska doba nižja od bruto zneska nakupa"
DocType: Employee,Personal Bio,Osebni Bio
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Duplicate Entry. Please check Authorization Rule {0},Podvoji vnos. Preverite Avtorizacijsko pravilo {0}
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py,IBAN is not valid,IBAN ni veljaven
apps/erpnext/erpnext/hr/doctype/shift_assignment/shift_assignment.py,Employee {0} has already applied for {1} on {2} : ,Zaposleni {0} se je že prijavil za {1} dne {2}:
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Selling,Standardna prodaja
DocType: Clinical Procedure,Invoiced,Fakturirano
apps/erpnext/erpnext/education/doctype/guardian/guardian.py,User {0} already exists,Uporabnik {0} že obstaja
DocType: Account,Profit and Loss,Profit in izguba
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Diff Qty,Količina dif
DocType: Asset Finance Book,Written Down Value,Zapisana vrednost
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Opening Balance Equity,Začetni bilančni kapital
DocType: GSTR 3B Report,April,April
DocType: Supplier,Credit Limit,Kreditni limit
apps/erpnext/erpnext/public/js/setup_wizard.js,Distribution,Distribucija
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,debit_note_amt,debit_note_amt
DocType: Quality Inspection,Inspected By,Pregledano z
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get Items from Product Bundle,Prenesite izdelke iz paketa izdelkov
DocType: Employee Benefit Claim,Employee Benefit Claim,Zahtevek za zaslužke zaposlenih
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date not mentioned,Datum potrditve ni naveden
DocType: Company,Default Receivable Account,Privzeti račun terjatev
DocType: Location,Check if it is a hydroponic unit,"Preverite, ali je hidroponska enota"
DocType: Student Guardian,Others,Drugi
DocType: Patient Appointment,Patient Appointment,Imenovanje bolnika
DocType: Inpatient Record,AB Positive,AB Pozitivno
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py,Depreciation Date,Datum amortizacije
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Upcoming Calendar Events,Prihajajoči dogodki v koledarju
apps/erpnext/erpnext/utilities/activation.py,Create Student Batch,Ustvarite študentsko pakiranje
DocType: Travel Itinerary,Travel Advance Required,Potrebno je potovanje
apps/erpnext/erpnext/config/manufacturing.py,Orders released for production.,"Naročila, izdana za proizvodnjo."
DocType: Loyalty Program,Collection Rules,Pravila zbiranja
DocType: Asset Settings,Disable CWIP Accounting,Onemogoči obračunavanje CWIP
DocType: Homepage Section,Section Based On,Odsek temelji na
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,{0} already allocated for Employee {1} for period {2} to {3},{0} je že dodeljeno za zaposlenega {1} za obdobje {2} do {3}
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0}: From Time and To Time of {1} is overlapping with {2},Vrstica {0}: od časa do časa {1} se prekriva z {2}
DocType: Vital Signs,Very Hyper,Zelo Hyper
apps/erpnext/erpnext/public/js/setup_wizard.js,Select the nature of your business.,Izberite naravo svojega podjetja.
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Only .csv and .xlsx files are supported currently,Trenutno so podprte samo datoteke .csv in .xlsx
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Are you sure you want to make debit note?,"Ali ste prepričani, da želite dati bremenitev?"
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Please select month and year,Izberite mesec in leto
DocType: Service Level,Default Priority,Privzeta prioriteta
DocType: Student Log,Student Log,Študentski dnevnik
DocType: Shopping Cart Settings,Enable Checkout,Omogoči Checkout
apps/erpnext/erpnext/config/settings.py,Human Resources,Človeški viri
DocType: Stock Entry,Total Value Difference (Out - In),Skupna razlika vrednosti (Out - In)
DocType: Work Order Operation,Actual End Time,Dejanski čas konca
apps/erpnext/erpnext/config/help.py,Setting up Taxes,Postavitev davkov
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Investing,Neto denar od naložb
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Accounting Ledger,Knjigovodska knjiga
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,Item Group Tree,Drevo skupine elementov
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,'Total',»Skupaj«
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 1,Točka 1
apps/erpnext/erpnext/utilities/user_progress.py,Student Batches,Študentske serije
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Priložite datoteko .csv z dvema stolpcema, eno za staro ime in drugo za novo ime"
DocType: Bank Statement Transaction Payment Item,outstanding_amount,outstanding_amount
apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Občutljivo
DocType: Purchase Invoice,Total (Company Currency),Skupaj (valuta podjetja)
DocType: Item,Website Content,Vsebina spletne strani
DocType: Driver,Driving License Category,Kategorija vozniškega dovoljenja
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Vrstica # {0}: pričakovani datum dobave ne more biti pred datumom naročila
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Make Payment,Izvedi plačilo
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Vrsta stranke je obvezna
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The fields From Shareholder and To Shareholder cannot be blank,Polja Od delničarja in Za delničarja ne moreta biti prazna
DocType: Customer Feedback,Quality Management,Upravljanje kakovosti
DocType: BOM,Transfer Material Against,Prenos materiala proti
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,Temporarily on Hold,Začasno na čakanju
apps/erpnext/erpnext/config/integrations.py,Connect Shopify with ERPNext,Povežite Shopify z ERPNext
DocType: Homepage Section Card,Subtitle,Podnaslov
DocType: Soil Texture,Loam,Loam
DocType: BOM,Scrap Material Cost(Company Currency),Stroški materiala za odpadke (valuta podjetja)
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Delivery Note {0} must not be submitted,Opomba za dostavo {0} ne sme biti poslana
DocType: Task,Actual Start Date (via Time Sheet),Dejanski datum začetka (prek časovnega lista)
DocType: Sales Order,Delivery Date,Datum dostave
,Item Shortage Report,Poročilo o pomanjkanju postavke
DocType: Subscription Plan,Price Determination,Določanje cen
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Retail & Wholesale,Maloprodaja in veleprodaja
DocType: Project,Twice Daily,Dvakrat dnevno
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Integrated Tax,Integrirani davek
DocType: Payment Entry,Deductions or Loss,Odbitki ali izguba
apps/erpnext/erpnext/regional/italy/utils.py,"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","Fiskalni režim je obvezen, prijazno določite fiskalno ureditev v podjetju {0}"
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Time slots added,Dodane časovne reže
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leaves must be allocated in multiples of 0.5,"Listi morajo biti razporejeni v večkratnikih 0,5"
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} deducted against {2},Znesek {0} {1} je odštet od {2}
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Plačilo za poravnavo plačil
apps/erpnext/erpnext/config/buying.py,Template of terms or contract.,Predloga pogojev ali pogodbe.
DocType: Item,Barcodes,Črtne kode
DocType: Course Enrollment,Enrollment Date,Datum vpisa
DocType: Holiday List,Clear Table,Počisti tabelo
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Setting up company,Ustanovitev podjetja
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Free item code is not selected,Koda proste postavke ni izbrana
apps/erpnext/erpnext/public/js/utils.js,Total Unpaid: {0},Skupno neplačano: {0}
DocType: Account,Balance must be,Ravnovesje mora biti
DocType: Supplier,Default Bank Account,Privzeti bančni račun
apps/erpnext/erpnext/regional/india/utils.py,Transport Receipt No and Date are mandatory for your chosen Mode of Transport,Številka prevoza in datum sta obvezna za izbrani način prevoza
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Creating Fees,Ustvarjanje pristojbin
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select Qty against item {0},Izberite količino proti elementu {0}
DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,"Ne potrdite, ali je sestanek ustvarjen za isti dan"
DocType: Loan,Repaid/Closed,Vrnjeno / zaprto
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Vrstica {0}: {1} Zahtevane serijske številke za element {2}. Vnesli ste {3}.
DocType: Exchange Rate Revaluation Account,Gain/Loss,Dobiček / izguba
DocType: POS Profile,Sales Invoice Payment,Plačilo s fakturo prodaje
DocType: Timesheet,Payslip,Payslip
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,HSN,HSN
apps/erpnext/erpnext/config/buying.py,Request for quotation.,Zahteva za ponudbo.
,Procurement Tracker,Spremljanje naročil
DocType: Employee Tax Exemption Proof Submission Detail,Type of Proof,Vrsta dokazila
DocType: Purchase Receipt,Vehicle Date,Datum vozila
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Reconcile Entries,Vnosi usklajevanja
DocType: Delivery Settings,Dispatch Settings,Nastavitve pošiljanja
DocType: Task,Dependencies,Odvisnosti
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js,Lost,Izgubljeno
DocType: BOM Update Tool,Replace BOM,Zamenjajte BOM
DocType: Patient,Marital Status,Zakonski status
DocType: HR Settings,Enter retirement age in years,Starost za upokojitev vnesite v letih
apps/erpnext/erpnext/templates/generators/item_group.html,No items listed,Ni navedenih elementov
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,No data to export,Ni podatkov za izvoz
DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,"Če želite vključiti preostanek preteklega proračunskega leta v to poslovno leto, izberite možnost Prenesi naprej"
apps/erpnext/erpnext/config/help.py,Opening Stock Balance,Začetno stanje zalog
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave Blocked,Zapusti blokirano
apps/erpnext/erpnext/stock/doctype/item/item.py,Asset Category is mandatory for Fixed Asset item,Kategorija sredstva je obvezna za postavko osnovnih sredstev
DocType: Purchase Receipt Item,Required By,Zahtevano z
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Add to Details,Dodaj v podrobnosti
,Inactive Customers,Neaktivni uporabniki
DocType: Drug Prescription,Dosage,Doziranje
DocType: Cheque Print Template,Starting position from top edge,Začetni položaj od zgornjega roba
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Appointment Duration (mins),Trajanje sestanka (min)
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,This employee already has a log with the same timestamp.{0},Ta zaposleni že ima dnevnik z istim časovnim žigom. {0}
DocType: Accounting Dimension,Disable,Onemogoči
DocType: Email Digest,Purchase Orders to Receive,Naročila za nakup
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Productions Orders cannot be raised for:,Naročil ni mogoče povečati za:
DocType: Projects Settings,Ignore Employee Time Overlap,Prezri prekrivanje časa zaposlenega
DocType: Employee Skill Map,Trainings,Treningi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Lost Reasons,Izgubljeni razlogi
DocType: Inpatient Record,A Positive,Pozitivno
DocType: Quality Inspection Reading,Reading 7,Branje 7
DocType: Purchase Invoice Item,Serial No,Serijska številka
DocType: Material Request Plan Item,Required Quantity,Zahtevana količina
DocType: Location,Parent Location,Nadrejena lokacija
DocType: Production Plan,Material Requests,Zahtevki za material
DocType: Buying Settings,Material Transferred for Subcontract,"Material, prenesen za podizvajalce"
DocType: Job Card,Timing Detail,Podrobno merjenje časa
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html,Required On,Zahtevano Vklopljeno
DocType: Job Offer Term,Job Offer Term,Trajanje ponudbe dela
DocType: SMS Center,All Contact,Vsi stiki
DocType: Item Barcode,Item Barcode,Postavka Črtna koda
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Levels,Ravni zalog
DocType: Vital Signs,Height (In Meter),Višina (v metrih)
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Value,Vrednost naročila
DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Vse prodajne transakcije so lahko označene z več ** prodajnimi osebami **, tako da lahko nastavite in spremljate cilje."
apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Izbrali ste že elemente iz {0} {1}
DocType: Request for Quotation,Get Suppliers,Pridobite dobavitelje
DocType: Sales Team,Contribution (%),Prispevek (%)
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Cannot set a received RFQ to No Quote,Prejetega RFQ ni mogoče nastaviti na No Quote
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Sales Order,Ustvarite prodajni nalog
apps/erpnext/erpnext/accounts/general_ledger.py,Account: {0} can only be updated via Stock Transactions,Račun: {0} je mogoče posodobiti samo prek transakcij z zalogami
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} Request for {1},{0} Zahteva za {1}
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js,Please select a value for {0} quotation_to {1},Izberite vrednost za {0} quotation_to {1}
DocType: Opportunity,Opportunity Date,Datum priložnosti
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Next Steps,Naslednji koraki
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Feedback,Povratne informacije o usposabljanju
DocType: Purchase Invoice,ACC-PINV-.YYYY.-,ACC-PINV-.YYYY.-
DocType: Holiday List,Total Holidays,Skupni prazniki
DocType: Fertilizer,Fertilizer Name,Ime gnojila
apps/erpnext/erpnext/regional/india/utils.py,House rented dates required for exemption calculation,"Datumi najema hiše, potrebni za izračun oprostitve"
,Expiring Memberships,Prenehanje članstva
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Supplier(s),Dobavitelj (i)
DocType: GL Entry,To Rename,Preimenovanje
apps/erpnext/erpnext/templates/generators/item/item_configure.html,Contact Us,Kontaktiraj nas
DocType: POS Closing Voucher,Cashier,Blagajnik
DocType: Drug Prescription,Hour,Ura
DocType: Support Settings,Show Latest Forum Posts,Pokaži najnovejše objave v forumu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Distributor,Distributer
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","Prosimo, dodajte preostale koristi {0} vlogi kot sorazmerno komponento"
DocType: Invoice Discounting,Short Term Loan Account,Kratkoročni kreditni račun
DocType: Cash Flow Mapper,Section Subtotal,Vmesni seštevek oddelka
apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Zahteva za material za naročilo
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CESS Amount,Znesek CESS
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Not authorized to edit frozen Account {0},Ni dovoljeno urejati zamrznjenega računa {0}
DocType: POS Closing Voucher Details,Expected Amount,Pričakovani znesek
DocType: Customer,Default Price List,Privzeti cenik
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,No Items selected for transfer,Za prenos ni izbranih elementov
DocType: Payment Schedule,Payment Amount,Znesek plačila
DocType: Grant Application,Assessment  Manager,Vodja ocenjevanja
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Chemical,Chemical
apps/erpnext/erpnext/config/education.py,Assessment Reports,Poročila o oceni
DocType: C-Form,IV,IV
DocType: Student Log,Academic,Akademski
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item {0} is not setup for Serial Nos. Check Item master,Element {0} ni nastavljen za serijske številke
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From State,Od države
DocType: Leave Type,Maximum Continuous Days Applicable,Največja veljavna neprekinjena dneva
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Please enter company name first,Najprej vnesite ime podjetja
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Import Successful,Uvoz je uspešen
DocType: Guardian,Alternate Number,Nadomestna številka
apps/erpnext/erpnext/patches/v11_0/create_department_records_for_each_company.py,All Departments,Vsi oddelki
apps/erpnext/erpnext/config/projects.py,Make project from a template.,Izdelajte projekt iz predloge.
DocType: Purchase Order,Inter Company Order Reference,Referenca naročil med podjetji
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Work Order {0} must be cancelled before cancelling this Sales Order,"Delovni nalog {0} je treba preklicati, preden prekličete ta prodajni nalog"
DocType: Education Settings,Employee Number,Številka zaposlenega
DocType: Manufacturing Settings,Capacity Planning For (Days),Načrtovanje zmogljivosti za (dneve)
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,From value must be less than to value in row {0},Iz vrednosti mora biti manjša od vrednosti v vrstici {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select BOM and Qty for Production,Izberite BOM in Qty for Production
DocType: Price List Country,Price List Country,Država Cenik
apps/erpnext/erpnext/setup/doctype/company/company.js,Create Tax Template,Ustvari predlogo za davek
DocType: Item Attribute,Numeric Values,Številske vrednosti
DocType: Delivery Note,Instructions,Navodila
DocType: Blanket Order Item,Blanket Order Item,Po naročilu
DocType: Accounting Dimension,Mandatory For Profit and Loss Account,Obvezno za izkaz poslovnega izida
apps/erpnext/erpnext/controllers/selling_controller.py,Commission rate cannot be greater than 100,Stopnja Komisije ne sme biti večja od 100
DocType: Course Topic,Course Topic,Tema tečaja
DocType: Employee,This will restrict user access to other employee records,To bo omejilo dostop uporabnikov do drugih zapisov zaposlenih
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Please create Customer from Lead {0},Ustvarite stranko Lead {0}
DocType: QuickBooks Migrator,Company Settings,Nastavitve podjetja
DocType: Travel Itinerary,Vegetarian,Vegetarijanska
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","Postavka obstaja z istim imenom ({0}), spremenite ime skupine ali preimenujte element"
DocType: Hotel Room,Hotel Room Type,Vrsta hotelske sobe
,Cash Flow,Denarni tok
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Plačilo za {0} {1} ne more biti večje od neporavnanega zneska {2}
DocType: Student Log,Achievement,Dosežek
apps/erpnext/erpnext/projects/doctype/task/task_tree.js,Add Multiple Tasks,Dodaj več nalog
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant {0} already exists with same attributes,Postavka Variant {0} že obstaja z enakimi atributi
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Invoice {0} no longer exists,Račun {0} ne obstaja več
DocType: Item,Will also apply for variants unless overrridden,"Uporabljale se bodo tudi za variante, razen če so prekoračene"
DocType: Cash Flow Mapping Accounts,Account,račun
DocType: Sales Order,To Deliver,Dostaviti
,Customers Without Any Sales Transactions,Stranke brez prodajnih transakcij
DocType: Maintenance Visit Purpose,Against Document No,Proti dokumentu št
apps/erpnext/erpnext/config/education.py,Content Masters,Mojstri vsebine
apps/erpnext/erpnext/config/accounting.py,Subscription Management,Upravljanje naročnin
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Get customers from,Pridobite uporabnike
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,{0} Digest,{0} Digest
DocType: Employee,Reports to,Poročila
DocType: Video,YouTube,YouTube
DocType: Party Account,Party Account,Račun stranke
DocType: Assessment Plan,Schedule,Urnik
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please enter ,"Prosim, vstopite"
DocType: Lead,Channel Partner,Partner kanala
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Invoiced Amount,Obračunani znesek
DocType: Project,From Template,Iz predloge
,DATEV,DATEV
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,Subscriptions,Naročnine
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Quantity to Make,Količina za izdelavo
DocType: Quality Review Table,Achieved,Doseženo
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution Amount,Prispevek Znesek
DocType: Budget,Fiscal Year,Poslovno leto
DocType: Supplier,Prevent RFQs,Prevent RFQs
DocType: Company,Discount Received Account,Račun za popust
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py, (Half Day),(Poldnevni)
DocType: Email Digest,Email Digest,E-poštni povzetek
DocType: Crop,Crop,Crop
DocType: Email Digest,Profit & Loss,Dobiček in izguba
DocType: Homepage Section,Section Order,Naročilo oddelka
DocType: Healthcare Settings,Result Printed,Rezultat natisnjen
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js,Student Group,Študentska 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.","Standardna davčna predloga, ki jo lahko uporabite za vse transakcije nakupa. Ta predloga lahko vsebuje seznam davčnih glav in tudi drugih vodij stroškov, kot so &quot;Shipping&quot;, &quot;Insurance&quot;, &quot;Handling&quot; itd. #### Opomba Tukaj določena davčna stopnja bo standardna davčna stopnja za vse ** postavke * *. Če obstajajo ** postavke **, ki imajo različne stopnje, jih je treba dodati v tabelo ** Item Tax ** v glavnem elementu ** Item **. #### Opis stolpcev 1. Vrsta izračuna: - To je lahko na ** Neto Skupaj ** (to je vsota osnovnega zneska). - ** Na prejšnji vrstici Skupaj / znesek ** (za kumulativne davke ali stroške). Če izberete to možnost, se bo davek uporabljal kot odstotek od prejšnje vrstice (v davčni tabeli) ali skupnega zneska. - ** Dejansko ** (kot je navedeno). 2. Vodja računa: Knjigovodska knjiga, po kateri bo ta davek knjižen. 3. Stroškovno mesto: Če je davek / davek dohodek (kot je ladijski promet) ali strošek, ga je treba knjižiti na stroškovnem mestu. 4. Opis: Opis davka (ki bo natisnjen v računih / ponudbah). 5. Stopnja: Stopnja davka. 6. Znesek: Znesek davka. 7. Skupaj: Kumulativna vsota do te točke. 8. Vnesite vrstico: Če na podlagi &quot;Prejšnja vrstica skupaj&quot; izberete številko vrstice, ki bo vzeta kot osnova za ta izračun (privzeta je prejšnja vrstica). 9. Razmislite o davku ali dajatvi za: V tem razdelku lahko določite, ali je davek / davek samo za vrednotenje (ne del celotnega zneska) ali samo za skupno (ne dodaja vrednosti postavke) ali za oboje. 10. Dodaj ali odštej: Ali želiš dodati ali odšteti davek."
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Connect to Quickbooks,Povežite se s QuickBooks
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root cannot be edited.,Korenine ni mogoče urejati.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Engineer,Inženir
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Item added,Vrstica # {0}: element je dodan
DocType: Student Admission,Eligibility and Details,Upravičenost in podrobnosti
DocType: Staffing Plan,Staffing Plan Detail,Podrobnosti o kadrovskem načrtu
DocType: Shift Type,Late Entry Grace Period,Pozna vhodna prehodna doba
DocType: Email Digest,Annual Income,Letni prihodek
DocType: Journal Entry,Subscription Section,Oddelek za naročnino
DocType: Salary Slip,Payment Days,Dnevi plačila
apps/erpnext/erpnext/config/non_profit.py,Volunteer information.,Informacije o prostovoljcih.
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py,`Freeze Stocks Older Than` should be smaller than %d days.,&quot;Starejše zaloge starejše od&quot; morajo biti manjše od% d dni.
DocType: Bank Reconciliation,Total Amount,Skupni znesek
DocType: Certification Application,Non Profit,Neprofitna dejavnost
DocType: Subscription Settings,Cancel Invoice After Grace Period,Prekliči račun po plačilu
DocType: Loyalty Point Entry,Loyalty Points,Točke zvestobe
DocType: Bank Account,Change this date manually to setup the next synchronization start date,"Ročno spremenite ta datum, da nastavite naslednji datum začetka sinhronizacije"
DocType: Purchase Order,Set Target Warehouse,Nastavite ciljno skladišče
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} ima trenutno {1} Stanje kazalnika dobaviteljev, RFQ-ji tega dobavitelja pa morajo biti izdani previdno."
DocType: Travel Itinerary,Check-in Date,Datum prijave
DocType: Tally Migration,Round Off Account,Račun zaokroži
DocType: Serial No,Warranty Period (Days),Garancijsko obdobje (dnevi)
DocType: Expense Claim Detail,Expense Claim Detail,Podrobnosti zahtevka za stroške
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Program: ,Program:
DocType: Patient Medical Record,Patient Medical Record,Zdravniška evidenca bolnika
DocType: Item,Variant Based On,Variant Based On
DocType: Vehicle Service,Brake Oil,Zavorno olje
DocType: Employee,Create User,Ustvari uporabnika
DocType: Codification Table,Codification Table,Kodifikacijska tabela
DocType: Training Event Employee,Optional,Neobvezno
DocType: HR Settings,Show Leaves Of All Department Members In Calendar,Pokaži liste vseh članov oddelka v koledarju
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","Prenesenega predmeta {0} v delovnem nalogu {1} ni bilo mogoče najti, element, ki ni bil dodan v vnos v zalogi"
apps/erpnext/erpnext/templates/pages/help.html,See all open tickets,Oglejte si vse odprte vstopnice
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Operations cannot be left blank,Operacij ni mogoče pustiti prazne
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,At least one mode of payment is required for POS invoice.,Za POS račun je potreben vsaj en način plačila.
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Email ID,ID skrbnika1
DocType: Sales Order Item,Supplier delivers to Customer,Dobavitelj dostavi naročniku
DocType: Procedure Prescription,Appointment Booked,Imenovanje rezervirano
DocType: Crop,Target Warehouse,Ciljno skladišče
DocType: Accounts Settings,Stale Days,Stalni dnevi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Credit entry can not be linked with a {1},Vrstica {0}: vnosa kreditne točke ni mogoče povezati z {1}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Healthcare Practitioner {0} not available on {1},Zdravstveni delavec {0} ni na voljo v {1}
DocType: SMS Center,All Customer Contact,Vsi stiki s strankami
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} Ohranitev vzorca temelji na seriji, prosimo, preverite Ali ima paket št., Da obdržite vzorec izdelka"
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Disc,Disk
DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Naredite računovodski vnos za vsako gibanje zalog
DocType: Travel Itinerary,Check-out Date,Datum odjave
DocType: Agriculture Analysis Criteria,Fertilizer,Gnojilo
DocType: Supplier,Default Tax Withholding Config,Privzeta konfig
DocType: Production Plan,Total Produced Qty,Skupna proizvedena količina
DocType: Leave Allocation,Leave Period,Obdobje dopusta
apps/erpnext/erpnext/education/doctype/fees/fees.py,Payment request {0} created,Ustvarjena je bila zahteva za plačilo {0}
DocType: Healthcare Service Unit Type,UOM Conversion in Hours,Pretvorba UOM v urah
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Avg. Selling Price List Rate,Povp. Cena prodajne cene
apps/erpnext/erpnext/config/manufacturing.py,Generate Material Requests (MRP) and Work Orders.,Ustvarite zahteve za material (MRP) in delovne naloge.
DocType: Journal Entry Account,Account Balance,Stanje na računu
DocType: Asset Maintenance Log,Periodicity,Periodičnost
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Medical Record,Zdravstvena evidenca
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,Log Type is required for check-ins falling in the shift: {0}.,"Vrsta dnevnika je potrebna za prijavo, ki pade v premik: {0}."
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Execution,Izvajanje
DocType: Item,Valuation Method,Metoda vrednotenja
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Invoice {1},{0} proti računu za prodajo {1}
DocType: Quiz Activity,Pass,Pass
DocType: Sales Partner,Sales Partner Target,Cilj prodajnega partnerja
DocType: Patient Appointment,Referring Practitioner,Referenčni zdravnik
DocType: Account,Expenses Included In Asset Valuation,Odhodki so vključeni v vrednotenje sredstev
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Publishing,Založništvo
DocType: Production Plan,Sales Orders Detail,Podrobnosti prodajnih nalogov
DocType: Salary Slip,Total Deduction,Skupni odbitek
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.js,Select a company,Izberite podjetje
apps/erpnext/erpnext/hr/report/loan_repayment/loan_repayment.py,EMI,EMI
DocType: Naming Series,Set prefix for numbering series on your transactions,V transakcijah nastavite predpono za zaporedje številk
apps/erpnext/erpnext/accounts/utils.py,Journal Entries {0} are un-linked,Vnosi dnevnika {0} niso povezani
apps/erpnext/erpnext/config/buying.py,Other Reports,Druga poročila
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,All items have already been invoiced,Vsi elementi so že zaračunani
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset scrapped via Journal Entry {0},"Sredstvo, izločeno prek vnosa v dnevnik, {0}"
DocType: Employee,Prefered Email,Preferred Email
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","Metode vrednotenja ni mogoče spremeniti, saj so transakcije z nekaterimi postavkami brez lastne metode vrednotenja"
DocType: Cash Flow Mapper,Section Name,Ime razdelka
DocType: Packed Item,Packed Item,Embalaža
DocType: Issue,Reset Service Level Agreement,Ponastavitev sporazuma o ravni storitev
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: znesek plačila ali kredita je potreben za {2}
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Submitting Salary Slips...,Pošiljanje plačnih vložkov ...
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,No Action,Brez akcije
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Proračuna ni mogoče dodeliti za {0}, ker ni račun za prihodke ali stroške"
DocType: Quality Procedure Table,Responsible Individual,Odgovorna oseba
apps/erpnext/erpnext/education/doctype/course/course.py,Total Weightage of all Assessment Criteria must be 100%,Skupna teža vseh meril za ocenjevanje mora biti 100%
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,An error occurred during the update process,Med postopkom posodabljanja je prišlo do napake
DocType: Sales Invoice,Customer Name,Ime stranke
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Amount should not be less than zero.,Znesek ne sme biti manjši od nič.
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Average Age,Povprečna starost
DocType: Shopping Cart Settings,Show Price,Prikaži ceno
DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Študent orodja za včlanitev v program
DocType: Tax Rule,Shipping State,Država pošiljanja
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.js,Please set Company,Nastavite podjetje
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Balance (Dr - Cr),Stanje (Dr - Cr)
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Supply Type,Vrsta napajanja
DocType: Healthcare Settings,Create documents for sample collection,Ustvarite dokumente za zbiranje vzorcev
DocType: Selling Settings,Close Opportunity After Days,Zapri priložnost po nekaj dneh
DocType: Item Customer Detail,Ref Code,Ref Code
DocType: Employee,Widowed,Vdova
DocType: Tally Migration,ERPNext Company,Podjetje ERPNext
DocType: Delivery Settings,Leave blank to use the standard Delivery Note format,"Pustite prazno, da uporabite standardni format dobavnice"
DocType: Purchase Invoice Item,Accepted Qty,Sprejeto količ
DocType: Pricing Rule,Apply Rule On Brand,Uporabi pravilo o blagovni znamki
DocType: Products Settings,Show Availability Status,Prikaži stanje razpoložljivosti
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Import Successfull,Uvoz uspešno
DocType: Agriculture Analysis Criteria,Soil Texture,Tekstura tal
DocType: Maintenance Schedule Item,No of Visits,Št. Obiskov
DocType: Customer Feedback Table,Qualitative Feedback,Kvalitativne povratne informacije
DocType: Support Settings,Service Level Agreements,Sporazumi o ravni storitev
DocType: Service Level,Response and Resoution Time,Odzivni čas in čas ponovnega obiska
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Expiring On,Preteče On
apps/erpnext/erpnext/education/utils.py,Student with email {0} does not exist,Študent z e-pošto {0} ne obstaja
DocType: Supplier Scorecard,Scorecard Actions,Akcije kazalnikov
DocType: Account,Stock Adjustment,Prilagoditev zalog
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Health Care,Skrb za zdravje
DocType: Restaurant Table,No of Seats,Št. Sedežev
apps/erpnext/erpnext/setup/doctype/company/company.js,Delete all the Transactions for this Company,Izbrišite vse transakcije za to podjetje
,Lead Details,Podrobnosti o svincu
DocType: Service Level Agreement,Default Service Level Agreement,Privzeta pogodba o ravni storitev
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""",Polja filtra Vrstica # {0}: Ime polja <b>{1}</b> mora biti tipa &quot;Link&quot; ali &quot;MultiSelect tabele&quot;
DocType: Lead,Suggestions,Predlogi
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Get from,Dobiti od
DocType: Tax Rule,Tax Rule,Davčno pravilo
DocType: Payment Entry,Payment Order Status,Stanje plačilnega naloga
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Duplicate entry,Podvojen vnos
apps/erpnext/erpnext/utilities/user_progress.py,Example: Masters in Computer Science,Primer: magisterij iz računalništva
DocType: Purchase Invoice Item,Purchase Invoice Item,Izdelek na računu za nakup
apps/erpnext/erpnext/projects/doctype/project/project.py,Status must be Cancelled or Completed,Stanje mora biti preklicano ali dokončano
apps/erpnext/erpnext/crm/doctype/utils.py,Call Summary by {0}: {1},Povzetek klica do {0}: {1}
DocType: Certified Consultant,Non Profit Manager,Upravitelj dobička
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,For Warehouse is required before Submit,Za skladišče je potrebno pred pošiljanjem
DocType: Authorization Rule,Applicable To (User),Uporabno za (uporabnik)
DocType: Appraisal Goal,Appraisal Goal,Cilj ocenjevanja
DocType: Supplier Scorecard,Warn for new Purchase Orders,Opozori na nove naročilnice
apps/erpnext/erpnext/public/js/setup_wizard.js,View Chart of Accounts,Ogled kontnega plana
apps/erpnext/erpnext/templates/pages/rfq.html,Quotations: ,Ponudbe:
DocType: Opportunity,To Discuss,Razpravljati
DocType: Quality Inspection Reading,Reading 9,Branje 9
DocType: Authorization Rule,Applicable To (Role),Velja za (vloga)
DocType: Quotation Item,Additional Notes,Dodatne opombe
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} can not be negative,{0} ne more biti negativna
apps/erpnext/erpnext/utilities/activation.py,Create Purchase Orders,Ustvarite naročila za nakup
DocType: Staffing Plan Detail,Estimated Cost Per Position,Ocenjena cena na položaj
DocType: Loan Type,Loan Name,Ime posojila
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Set default mode of payment,Nastavi privzeti način plačila
DocType: Quality Goal,Revision,Revizija
DocType: Shift Type,The time before the shift end time when check-out is considered as early (in minutes).,"Čas pred koncem izmene, ko se odjava šteje kot zgodnja (v minutah)."
DocType: Healthcare Service Unit,Service Unit Type,Vrsta servisne enote
DocType: Purchase Invoice,Return Against Purchase Invoice,Povračilo računa za nakup
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Generate Secret,Ustvari skrivnost
DocType: Loyalty Program Collection,Loyalty Program Collection,Zbirka programov zvestobe
apps/erpnext/erpnext/config/crm.py,Send mass SMS to your contacts,Pošljite masovni SMS svojim stikom
apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js,Create Fee Schedule,Ustvarite cenik
DocType: Rename Tool,File to Rename,Preimenuj datoteko
apps/erpnext/erpnext/public/js/projects/timer.js,Timer exceeded the given hours.,Časovnik je presegel dane ure.
DocType: Shopify Tax Account,ERPNext Account,ERPNext račun
DocType: Item Supplier,Item Supplier,Dobavitelj blaga
apps/erpnext/erpnext/stock/get_item_details.py,Price List {0} is disabled or does not exist,Cenik {0} je onemogočen ali pa ne obstaja
DocType: Sales Invoice Item,Deferred Revenue Account,Račun z odloženim prihodkom
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py,Soil compositions do not add up to 100,Sestava tal ne dosega 100
DocType: Salary Slip,Salary Slip Timesheet,Zapisnica o plačah
DocType: Budget,Warn,Opozori
DocType: Grant Application,Email Notification Sent,E-poštno obvestilo je poslano
DocType: Work Order,Planned End Date,Načrtovani končni datum
DocType: QuickBooks Migrator,Quickbooks Company ID,ID podjetja podjetja QuickBooks
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Skladišča ni mogoče spremeniti za serijsko številko
DocType: Loan Type,Rate of Interest (%) Yearly,Obrestna mera (%) Letno
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Scrapped Asset,Stroški izločenega sredstva
apps/erpnext/erpnext/regional/italy/utils.py,Please set an Address on the Company '%s',Nastavite naslov v podjetju »% s«
DocType: Patient Encounter,Encounter Date,Datum srečanja
DocType: Shopify Settings,Webhooks,Spletne zavore
apps/erpnext/erpnext/config/non_profit.py,Memebership Type Details,Podrobnosti o tipu članstva
apps/erpnext/erpnext/healthcare/setup.py,Resistant,Odporna
DocType: Hotel Room Package,Hotel Room Package,Paket hotelskih sob
DocType: Sales Team,Contribution to Net Total,Prispevek k skupnemu znesku
DocType: Customer,"Reselect, if the chosen contact is edited after save","Ponovno izberite, če je izbrani stik urejen po shranjevanju"
DocType: Employee Tax Exemption Sub Category,Employee Tax Exemption Sub Category,Podskupina za oprostitev davka na zaposlene
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Row {0}# Paid Amount cannot be greater than requested advance amount,Vrstica {0} # Plačan znesek ne sme biti višji od zahtevanega zneska predplačila
DocType: Asset Settings,This value is used for pro-rata temporis calculation,Ta vrednost se uporablja za izračun sorazmerne časovne porazdelitve
DocType: Company,Change Abbreviation,Spremeni okrajšavo
DocType: Project,Total Consumed Material Cost  (via Stock Entry),Skupni porabljeni materialni stroški (prek vpisa delnic)
DocType: Purchase Invoice,Raw Materials Supplied,Dobavljene surovine
DocType: Salary Detail,Condition and Formula Help,Pomoč za stanje in formulo
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Balance ({0}),Stanje ({0})
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student ID: ,Študentski ID:
DocType: Leave Control Panel,New Leaves Allocated (In Days),Dodeljeni novi listi (v dnevih)
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py,To Datetime,V Datetime
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab result datetime cannot be before testing datetime,Podatkovni čas rezultatov laboratorija ne more biti pred preskusom datetime
apps/erpnext/erpnext/setup/doctype/company/company.js,Please re-type company name to confirm,Za potrditev ponovno vnesite ime podjetja
DocType: Subscription,Subscription Period,Obdobje naročnine
DocType: Cash Flow Mapper,Position,Položaj
DocType: Student,Sibling Details,Podrobnosti o sestri
DocType: Cash Flow Mapping,Is Finance Cost Adjustment,Je finančna prilagoditev stroškov
DocType: Patient Encounter,Encounter Impression,Encounter Impression
DocType: Contract,N/A,N / A
DocType: Lab Test,Lab Technician,Laboratorijski tehnik
apps/erpnext/erpnext/stock/get_item_details.py,"Item {0} is a template, please select one of its variants","Element {0} je predloga, izberite eno od njegovih različic"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,How Pricing Rule is applied?,Kako se uporablja pravilo za določanje cen?
DocType: Email Digest,Email Digest Settings,Nastavitve e-poštnega sporočila
DocType: Journal Entry,Inter Company Journal Entry,Vnos v medpodjetniški dnevnik
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Create Delivery Trip,Ustvari izlet za dostavo
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Vrstica # {0}: serijska številka {1} se ne ujema z {2} {3}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Sales Order required for Item {0},Zahteva za prodajno naročilo za element {0}
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Connected,Pokličite povezavo
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_proof_submission/employee_tax_exemption_proof_submission.js,Get Details From Declaration,Pridobite podrobnosti iz deklaracije
,Support Hour Distribution,Distribucija ur podpore
DocType: Company,Allow Account Creation Against Child Company,Dovoli ustvarjanje računa proti podjetju za otroke
DocType: Payment Entry,Company Bank Account,Bančni račun podjetja
DocType: Amazon MWS Settings,UK,UK
DocType: Normal Test Items,Normal Test Items,Normalne preskusne postavke
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).,Element {0}: naročeno število {1} ne sme biti manjše od najmanjše naročilnice {2} (definirano v postavki).
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,Not in Stock,Ni na zalogi
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Voziček
DocType: Course Activity,Course Activity,Dejavnost tečaja
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Thank you for your business!,Hvala za vaš posel!
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Against Journal Entry {0} is already adjusted against some other voucher,Proti vnosu dnevnika {0} je že nastavljen proti drugemu kuponu
DocType: Journal Entry,Bill Date,Datum obračuna
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please enter Write Off Account,Vnesite račun za izpis
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Biotechnology,Biotehnologija
apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py,Setup your Institute in ERPNext,Namestite svoj inštitut v ERPNext
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} does not exist,Element {0} ne obstaja
DocType: Asset Maintenance Log,Asset Maintenance Log,Dnevnik vzdrževanja sredstva
DocType: Accounts Settings,Settings for Accounts,Nastavitve za račune
DocType: Bank Guarantee,Reference Document Name,Ime referenčnega dokumenta
DocType: Warehouse,"If blank, parent Warehouse Account or company default will be considered","Če bo prazen, bo upoštevan nadrejeni račun Warehouse ali podjetje"
DocType: BOM,Rate Of Materials Based On,Hitrost materialov na osnovi
DocType: Water Analysis,Container,Posoda
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Available slots,Razpoložljive reže
DocType: Quiz,Max Attempts,Največji poskus
apps/erpnext/erpnext/public/js/financial_statements.js,Cash Flow Statement,Izkaz denarnih tokov
DocType: Loyalty Point Entry,Redeem Against,Izkoristi
DocType: Sales Invoice,Offline POS Name,Offline POS ime
DocType: Crop Cycle,ISO 8601 standard,ISO 8601 standard
DocType: Purchase Taxes and Charges,Deduct,Odbit
DocType: C-Form Invoice Detail,C-Form Invoice Detail,Podrobnosti računa iz obrazca C
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Inventory,Neto sprememba zalog
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 je mogoče ustvariti samo iz predloženega dokumenta
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Amount during the period,Amortizacija Znesek v obdobju
DocType: Shopify Settings,App Type,Vrsta aplikacije
DocType: Lead,Blog Subscriber,Blog naročnik
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,[Error],[Napaka]
DocType: Restaurant,Active Menu,Aktivni meni
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Transactions against the company already exist! ,Transakcije z družbo že obstajajo!
DocType: Customer,Sales Partner and Commission,Prodajni partner in Komisija
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Goals cannot be empty,Cilji ne smejo biti prazni
DocType: Work Order,Warehouses,Skladišča
DocType: Bank Transaction,ACC-BTN-.YYYY.-,ACC-BTN-.YYYY.-
DocType: Crop Cycle,Detected Diseases,Odkrite bolezni
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the Bank Guarantee Number before submittting.,Pred oddajo vnesite številko bančne garancije.
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Items and UOMs,Postavke obdelave in UOM-i
DocType: Payment Request,Is a Subscription,Je naročnina
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Prenesi kot Json
,Appointment Analytics,Imenovanje Analytics
DocType: Quality Inspection,Inspection Type,Vrsta pregleda
DocType: Sales Invoice,Sales Taxes and Charges,Davki in pristojbine za prodajo
DocType: Employee,Health Insurance Provider,Ponudnik zdravstvenega zavarovanja
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,This is a root item group and cannot be edited.,To je skupina korenskih elementov in je ni mogoče urejati.
DocType: Production Plan,Projected Qty Formula,Predvidena formula za količino
DocType: Payment Order,Payment Order Reference,Referenca plačilnega naloga
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Tree Type,Vrsta drevesa
DocType: Activity Type,Default Costing Rate,Privzeta cena
DocType: Vital Signs,Constipated,Zaprt
DocType: Salary Detail,Default Amount,Privzeti znesek
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,Budget List,Seznam proračuna
DocType: Job Offer,Awaiting Response,Čakanje na odziv
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.py,Not permitted. Please disable the Procedure Template,Ni dovoljeno. Onemogočite predlogo postopka
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant creation has been queued.,Ustvarjanje variant je bilo v čakalni vrsti.
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}","Znesek {0} je že zahteval za komponento {1}, določil znesek, enak ali večji od {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,Preostale koristi {0} dodajte kateri koli obstoječi komponenti
DocType: Vehicle Log,Odometer,Odometer
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Transaction currency must be same as Payment Gateway currency,Valuta transakcije mora biti enaka valuti plačilnega prehoda
apps/erpnext/erpnext/controllers/status_updater.py,"For an item {0}, quantity must be negative number",Za postavko {0} mora biti količina negativna
DocType: Additional Salary,Payroll Date,Datum plače
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Mode of payment is required to make a payment,Način plačila je potreben za plačilo
DocType: BOM,Materials,Materiali
DocType: Delivery Note Item,Against Sales Order,Proti prodajnemu nalogu
DocType: Supplier Quotation,PUR-SQTN-.YYYY.-,PUR-SQTN-.YYYY.-
DocType: Delivery Note Item,Against Sales Order Item,Proti predmetu prodajnega naloga
DocType: Appraisal,Goals,Cilji
DocType: Employee,ERPNext User,ERPNext uporabnik
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Available Leaves,Na voljo so listi
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root Account must be a group,Korenski račun mora biti skupina
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Email Reminders will be sent to all parties with email contacts,E-poštni opomniki bodo poslani vsem strankam z e-poštnimi stiki
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Type...,Izberite Vrsta ...
DocType: Workstation Working Hour,Workstation Working Hour,Delovni čas delovne postaje
apps/erpnext/erpnext/config/agriculture.py,Analytics,Analytics
DocType: Maintenance Team Member,Maintenance Role,Vloga vzdrževanja
apps/erpnext/erpnext/config/buying.py,Terms and Conditions Template,Predloga in pogoji
apps/erpnext/erpnext/controllers/status_updater.py,"To allow over billing, update ""Over Billing Allowance"" in Accounts Settings or the Item.","Če želite omogočiti več zaračunavanja, posodobite »Nadomestilo za obračunavanje« v nastavitvah računov ali elementu."
DocType: Fee Schedule Program,Fee Schedule Program,Program plačil
DocType: Production Plan Item,Production Plan Item,Postavka proizvodnega načrta
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Total Student,Skupaj študent
DocType: Packing Slip,From Package No.,Iz paketa št.
DocType: Accounts Settings,Shipping Address,naslov za pošiljanje
DocType: Vehicle Service,Clutch Plate,Plošča sklopke
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} does not linked to Item {2},Vrstica # {0}: Sredstvo {1} ni povezano z elementom {2}
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Entry {0} created,Vnos stanj {0} je ustvarjen
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Date,Datum naročila
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Company currencies of both the companies should match for Inter Company Transactions.,Valute družb obeh družb bi se morale ujemati za medpodjetniške transakcije.
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Shortage Qty,Količina pomanjkanja
DocType: Employee Attendance Tool,Marked Attendance,Označena prisotnost
DocType: Pricing Rule,System will notify to increase or decrease quantity or amount ,Sistem bo obvestil o povečanju ali zmanjšanju količine ali količine
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čite to možnost, če želite uporabnika prisiliti, da pred shranjevanjem izbere serijo. Privzeta nastavitev ne bo, če to preverite."
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,No issue raised by the customer.,Stranka ni izpostavila vprašanja.
DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Uporabniki s to vlogo lahko nastavijo zamrznjene račune in ustvarijo / spremenijo računovodske vnose za zamrznjene račune
DocType: Expense Claim,Total Claimed Amount,Skupni zahtevani znesek
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Unable to find Time Slot in the next {0} days for Operation {1},V naslednjih {0} dneh za delovanje {1} časovne reže ni mogoče najti
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Wrapping up,Zavijanje
DocType: Bank,Plaid Access Token,Žeton za dostop do kritja
apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,"Podaljšate lahko samo, če vaše članstvo poteče v 30 dneh"
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Value must be between {0} and {1},Vrednost mora biti med {0} in {1}
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Choose a corresponding payment,Izberite ustrezno plačilo
DocType: Quality Feedback,Parameters,Parametri
DocType: Shift Type,Auto Attendance Settings,Nastavitve samodejne prisotnosti
,Sales Partner Transaction Summary,Povzetek transakcijskih prodajnih partnerjev
DocType: Asset Maintenance,Maintenance Manager Name,Ime upravljavca vzdrževanja
apps/erpnext/erpnext/public/js/controllers/transaction.js,It is needed to fetch Item Details.,"Potrebno je, da prenesete podrobnosti elementa."
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,This is based on stock movement. See {0} for details,To temelji na gibanju zalog. Za podrobnosti si oglejte {0}
DocType: Clinical Procedure,Appointment,Imenovanje
apps/erpnext/erpnext/public/js/utils/party.js,Please enter {0} first,Najprej vnesite {0}
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM #{0}: Raw material cannot be same as main Item,BOM # {0}: Surovine ne morejo biti enake kot glavna postavka
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Following accounts might be selected in GST Settings:,V nastavitvah GST lahko izberete naslednje račune:
DocType: Item,You can use any valid Bootstrap 4 markup in this field. It will be shown on your Item Page.,V tem polju lahko uporabite katero koli veljavno oznako Bootstrap 4. Prikazana bo na strani predmeta.
DocType: Serial No,Incoming Rate,Dohodna stopnja
DocType: Cashier Closing,POS-CLO-,POS-CLO-
DocType: Invoice Discounting,Accounts Receivable Discounted Account,Račun z diskontiranimi računi za terjatve
DocType: Tally Migration,Tally Debtors Account,Obračun računa dolžnikov
DocType: Grant Application,Has any past Grant Record,Je že v preteklosti
DocType: POS Closing Voucher,Amount in Custody,Znesek v skrbništvu
DocType: Drug Prescription,Interval,Interval
DocType: Warehouse,Parent Warehouse,Nadrejeno skladišče
apps/erpnext/erpnext/stock/reorder_item.py,Auto Material Requests Generated,Ustvarjen je bil samodejno zahtevo za material
apps/erpnext/erpnext/controllers/stock_controller.py,Row {0}: Quality Inspection rejected for item {1},Vrstica {0}: zavrnitev pregleda kakovosti za element {1}
DocType: Vehicle,Additional Details,Dodatne podrobnosti
DocType: Sales Partner Type,Sales Partner Type,Vrsta prodajnega partnerja
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,"Select BOM, Qty and For Warehouse","Izberite BOM, Qty in For Warehouse"
DocType: Asset Maintenance Log,Maintenance Type,Tip vzdrževanja
DocType: Homepage Section,Use this field to render any custom HTML in the section.,To polje uporabite za upodabljanje HTML-ja po meri v razdelku.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,"Appointment cancelled, Please review and cancel the invoice {0}","Dogovor je bil preklican. Prosimo, preglejte in prekličite račun {0}"
DocType: Sales Invoice,Time Sheet List,Seznam časovnih listov
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Bill {1} dated {2},{0} zoper račun {1} z dne {2}
DocType: Shopify Settings,For Company,Za podjetje
DocType: Linked Soil Analysis,Linked Soil Analysis,Povezana analiza tal
DocType: Project,Day to Send,Dan za pošiljanje
DocType: Salary Component,Is Tax Applicable,Je davek
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Purchase Order number required for Item {0},Številka naročilnice za element {0}
DocType: Item Tax Template,Tax Rates,Davčne stopnje
apps/erpnext/erpnext/templates/pages/search_help.py,Help Results for,Rezultati pomoči za
DocType: Student Admission,Student Admission,Sprejem študentov
DocType: Designation Skill,Skill,Spretnost
DocType: Budget Account,Budget Account,Račun proračuna
DocType: Employee Transfer,Create New Employee Id,Ustvari nov ID zaposlenega
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} is required for 'Profit and Loss' account {1}.,{0} je potreben za račun &quot;Dobiček in izguba&quot; {1}.
apps/erpnext/erpnext/config/accounting.py,Goods and Services Tax (GST India),Davek na blago in storitve (GST India)
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Creating Salary Slips...,Ustvarjanje plače ...
DocType: Employee Skill,Employee Skill,Spretnost zaposlenih
DocType: Pricing Rule,Apply Rule On Item Code,Uporabi pravilo o kodi postavke
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,'Update Stock' can not be checked because items are not delivered via {0},"»Posodobitev zaloge« ni mogoče preveriti, ker elementi niso dostavljeni prek {0}"
DocType: Journal Entry,Stock Entry,Vnos zalog
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Nastavite številske serije za Prisotnost prek Nastavitve&gt; Številčne serije
apps/erpnext/erpnext/regional/india/utils.py,House rent paid days overlapping with {0},"Hišna najemnina za dneve, ki se prekrivajo z {0}"
DocType: Employee,Current Address Is,Trenutni naslov je
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Analyst,Analitik
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,No records found in the Payment table,V tabeli plačil ni najdenih nobenih zapisov
DocType: Email Digest,Sales Orders to Deliver,Prodajni nalogi za dostavo
DocType: Item,Units of Measure,Merske enote
DocType: Leave Block List,Block Days,Block Days
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Quantity must not be more than {0},Količina ne sme biti večja od {0}
apps/erpnext/erpnext/public/js/utils/item_selector.js,Add Items,Dodaj elemente
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Dodani davki in stroški (valuta podjetja)
DocType: Accounts Settings,Currency Exchange Settings,Nastavitve za menjavo valut
DocType: Taxable Salary Slab,From Amount,Iz zneska
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Warehouse is mandatory,Skladišče je obvezno
apps/erpnext/erpnext/utilities/user_progress.py,Add Students,Dodaj študente
DocType: Payment Entry,Account Paid From,Račun plačan iz
DocType: Employee Attendance Tool,Marked Attendance HTML,Označeni HTML navzočnosti
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} has been disabled,Element {0} je onemogočen
DocType: Cheque Print Template,Amount In Figure,Znesek na sliki
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Cannot produce more Item {0} than Sales Order quantity {1},Ni mogoče ustvariti več elementa {0} kot količina naročila za prodajo {1}
DocType: Purchase Invoice,Return,Vrnitev
apps/erpnext/erpnext/stock/doctype/batch/batch.py,The selected item cannot have Batch,Izbrani element ne more imeti paketa
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.js,Print IRS 1099 Forms,Natisni obrazce IRS 1099
apps/erpnext/erpnext/controllers/accounts_controller.py,'Update Stock' cannot be checked for fixed asset sale,&quot;Posodobitev zaloge&quot; ni mogoče preveriti za prodajo osnovnih sredstev
DocType: Asset,Depreciation Schedule,Amortizacijski načrt
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule not applicable for country {0},Pravilo pošiljanja se ne uporablja za državo {0}
DocType: Purchase Receipt,Time at which materials were received,Čas prejema gradiva
DocType: Tax Rule,Billing Country,Država za obračunavanje
DocType: Journal Entry Account,Sales Order,Prodajni nalog
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Vrednost manjka
apps/erpnext/erpnext/stock/doctype/item/item.py,Stores,Trgovine
DocType: Exchange Rate Revaluation Account,New Balance In Base Currency,Novo stanje v osnovni valuti
DocType: POS Profile,Price List,Cenik
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Synchronize this account,Sinhronizirajte ta račun
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Invalid {0}: {1},Neveljaven {0}: {1}
DocType: Article,Article,Člen
apps/erpnext/erpnext/public/js/setup_wizard.js,The name of the institute for which you are setting up this system.,"Ime inštituta, za katerega nastavljate ta sistem."
apps/erpnext/erpnext/utilities/user_progress.py,A Product,Izdelek
DocType: Crop,Crop Name,Ime obrezovanja
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,'From Date' is required,Zahteva se »Od datuma«
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select a BOM,Izberite BOM
DocType: Travel Itinerary,Travel Itinerary,Načrt potovanja
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Birthday Reminder,Opomnik za rojstni dan
apps/erpnext/erpnext/utilities/user_progress.py,Pair,Par
apps/erpnext/erpnext/stock/get_item_details.py,Item Price added for {0} in Price List {1},Cena elementa dodana za {0} v ceniku {1}
DocType: Pricing Rule,Validate Applied Rule,Potrdite uporabljeno pravilo
DocType: Job Card Item,Job Card Item,Postavka zaposlitvene kartice
DocType: Homepage,Company Tagline for website homepage,Podpora podjetja za domačo stran spletnega mesta
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Set Response Time and Resolution for Priority {0} at index {1}.,Nastavite odzivni čas in ločljivost za prednost {0} na indeksu {1}.
DocType: Company,Round Off Cost Center,Okrogli center stroškov
DocType: Supplier Scorecard Criteria,Criteria Weight,Teža meril
DocType: Asset,Depreciation Schedules,Urniki amortizacije
DocType: Subscription,Discounts,Popusti
DocType: Shipping Rule,Shipping Rule Conditions,Pogoji za dostavo
DocType: Subscription,Cancelation Date,Datum preklica
DocType: Payment Entry,Party Bank Account,Bančni račun stranke
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,New Cost Center Name,Novo ime stroškovnega mesta
DocType: Promotional Scheme Price Discount,Max Amount,Najvišji znesek
DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Po zaključku plačila preusmerite uporabnika na izbrano stran.
DocType: Salary Slip,Total Loan Repayment,Celotno odplačilo posojila
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,To Fiscal Year,Do fiskalnega leta
DocType: Delivery Note,Return Against Delivery Note,Vračilo proti dobavnici
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,"Edit in full page for more options like assets, serial nos, batches etc.","Uredite na celotni strani za več možnosti, kot so sredstva, zaporedne številke, paketi itd."
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Allocate Payment Amount,Dodeli znesek plačila
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Returned Item {1} does not exists in {2} {3},Vrstica # {0}: Vrnjena postavka {1} ne obstaja v {2} {3}
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js,Enrolling students,Vpis študentov
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,"Dovoli uporabniku, da uredi cenik v transakcijah"
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Please select the document type first,Najprej izberite vrsto dokumenta
DocType: Hotel Room Reservation,Hotel Room Reservation,Rezervacija hotelske sobe
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Researcher,Raziskovalec
apps/erpnext/erpnext/accounts/party.py,{0} {1} is frozen,{0} {1} je zamrznjeno
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item Code cannot be changed for Serial No.,Koda postavke ni mogoče spremeniti za Serial No.
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Skupni davki in stroški (valuta podjetja)
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Rule Conflicts with {0},Konflikti davčnega pravila z {0}
DocType: Fiscal Year,Year End Date,Datum konca leta
apps/erpnext/erpnext/utilities/activation.py,Create Leads,Ustvari vodi
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js,Show zero values,Pokaži ničelne vrednosti
DocType: Employee Onboarding,Employee Onboarding,Zaposleni Onboarding
DocType: POS Closing Voucher,Period End Date,Datum konca obdobja
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Passing Score value should be between 0 and 100,Vrednost Passing Score mora biti med 0 in 100
DocType: Department,The first Leave Approver in the list will be set as the default Leave Approver.,Prva odobritev dopusta na seznamu bo nastavljena kot privzeti odobritev opustitve.
DocType: POS Settings,POS Settings,Nastavitve POS
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,All Accounts,Vsi računi
DocType: Hotel Room,Hotel Manager,Hotel Manager
DocType: Opportunity,With Items,S postavkami
DocType: GL Entry,Is Advance,Je napredna
DocType: Membership,Membership Status,Status članstva
apps/erpnext/erpnext/config/crm.py,Sales campaigns.,Prodajne akcije.
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Default BOM not found for Item {0} and Project {1},Privzeta BOM ni bila najdena za element {0} in projekt {1}
DocType: Leave Type,Encashment Threshold Days,Dnevi mejnih vrednosti za unovčenje
apps/erpnext/erpnext/stock/report/item_prices/item_prices.js,Items Filter,Elementi Filter
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} je na čakanju do {1}
DocType: Clinical Procedure Item,Invoice Separately as Consumables,"Račun, ločeno od potrošnega materiala"
DocType: Subscription,Days Until Due,Dnevi do zapadlosti
apps/erpnext/erpnext/templates/pages/projects.js,Show Completed,Pokaži dokončano
apps/erpnext/erpnext/accounts/doctype/bank/bank_dashboard.py,Bank Deatils,Bank Deatils
apps/erpnext/erpnext/utilities/transaction_base.py,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Vrstica # {0}: hitrost mora biti enaka kot {1}: {2} ({3} / {4})
DocType: Clinical Procedure,HLC-CPR-.YYYY.-,HLC-CPR-.LLLL.-
DocType: Healthcare Settings,Healthcare Service Items,Izdelki zdravstvene oskrbe
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 3,Območje staranja 3
DocType: Vital Signs,Blood Pressure,Krvni pritisk
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/sales_partner_target_variance_based_on_item_group.js,Target On,Target on
apps/erpnext/erpnext/patches/v11_0/add_healthcare_service_unit_tree_root.py,All Healthcare Service Units,Vse enote zdravstvenih služb
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Program,Obvezno polje - Program
apps/erpnext/erpnext/public/js/projects/timer.js,Timer,Časovnik
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Nastavi {0} v kategoriji sredstev {1} ali v podjetju {2}
DocType: Bank Statement Settings Item,Bank Header,Glava banke
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Not eligible for the admission in this program as per DOB,Ni primerno za sprejem v ta program kot na DOB
DocType: Assessment Criteria,Assessment Criteria Group,Skupina meril za ocenjevanje
DocType: Options,Is Correct,Je pravilen
apps/erpnext/erpnext/utilities/user_progress.py,user@example.com,user@example.com
DocType: Department,Parent Department,Nadrejeni oddelek
DocType: Employee Internal Work History,Employee Internal Work History,Interna delovna zgodovina zaposlenih
DocType: Supplier,Warn POs,Opozoriti PO
DocType: Employee,Offer Date,Datum ponudbe
DocType: Sales Invoice,Product Bundle Help,Pomoč za paket izdelkov
DocType: Stock Reconciliation,Stock Reconciliation,Usklajevanje zalog
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Accounting Entry for Stock,Računovodski vnos za zalogo
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.","Sestanek se prekriva z {0}. <br> {1} ima predvideno sestanek z {2} ob {3}, ki traja {4} minut."
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with child nodes cannot be converted to ledger,Skladišča z otrokovimi vozlišči ni mogoče pretvoriti v knjigo
DocType: Project,Projects Manager,Vodja projektov
apps/erpnext/erpnext/hr/doctype/training_event/training_event.py,End time cannot be before start time,Končni čas ne more biti pred začetkom
DocType: UOM,UOM Name,Ime UOM
DocType: Vital Signs,BMI,ITM
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Hours,Ure
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} {2} {3},Znesek {0} {1} {2} {3}
,Supplier Ledger Summary,Povzetek glavne knjige dobavitelja
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Email ID,ID e-pošte študenta
apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,Mandat SEPA brez GoCard
DocType: Bank Account,IBAN,IBAN
DocType: Restaurant Reservation,No of People,Število ljudi
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,From Date and To Date lie in different Fiscal Year,Od datuma in do datuma je v različnem davčnem letu
apps/erpnext/erpnext/healthcare/utils.py,The Patient {0} do not have customer refrence to invoice,Bolnik {0} nima računa odjemalca do računa
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in condition: {0},Napaka v sintaksi: {0}
DocType: Bank Transaction,Transaction ID,Številka transakcije
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Please enter message before sending,Pred pošiljanjem vnesite sporočilo
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Ref Date,Ref Date
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Opomba: To stroškovno mesto je skupina. Računovodskih vnosov za skupine ni mogoče ustvariti.
DocType: Soil Analysis,Soil Analysis Criterias,Kriteriji za analizo tal
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Packing Slip(s) cancelled,Paketni listki so bili preklicani
DocType: Company,Existing Company,Obstoječe podjetje
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batches,Paketi
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Defense,Obramba
DocType: Item,Has Batch No,Ima serijsko št
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Delayed Days,Zapozneli dnevi
DocType: Lead,Person Name,Ime osebe
DocType: Item Variant,Item Variant,Postavka Variant
DocType: Training Event Employee,Invited,Povabljen
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Najvišji upravičeni znesek za komponento {0} presega {1}
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py,Amount to Bill,Znesek za Bill
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"For {0}, only debit accounts can be linked against another credit entry",Za {0} je mogoče povezati samo debetne račune z drugim kreditnim vnosom
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py,Creating Dimensions...,Ustvarjanje dimenzij ...
DocType: Bank Statement Transaction Entry,Payable Account,Obračunski račun
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Navedite število potrebnih obiskov
DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,"Izberite samo, če imate nastavljene dokumente za kartiranje denarnega toka"
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} is a company holiday,{0} je praznik podjetja
DocType: Item,Items with higher weightage will be shown higher,Postavke z višjo utežjo bodo prikazane višje
DocType: Project,Project will be accessible on the website to these users,Projekt bo tem uporabnikom dostopen na spletni strani
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute table is mandatory,Tabela atributov je obvezna
DocType: Salary Slip,Total Working Hours,Skupno število delovnih ur
DocType: Crop,Planting UOM,Sajenje UOM
DocType: Inpatient Record,O Negative,O Negativno
DocType: Purchase Order,To Receive and Bill,Za sprejem in Bill
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Začetni in končni datumi, ki niso v veljavnem obdobju plačil, ne morejo izračunati {0}."
DocType: POS Profile,Only show Customer of these Customer Groups,Kupca lahko prikažete samo za te skupine strank
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select items to save the invoice,"Izberite elemente, ki jih želite shraniti"
DocType: Service Level Priority,Resolution Time,Čas ločljivosti
DocType: Grading Scale Interval,Grade Description,Opis stopnje
DocType: Homepage Section,Cards,Kartice
DocType: Quality Meeting Minutes,Quality Meeting Minutes,Zapisnik o kakovostnem sestanku
DocType: Linked Plant Analysis,Linked Plant Analysis,Povezana analiza rastlin
apps/erpnext/erpnext/public/js/controllers/transaction.js,Service Stop Date cannot be after Service End Date,Datum servisnega postanka ne more biti po datumu konca storitve
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Please set B2C Limit in GST Settings.,V nastavitvah GST nastavite omejitev B2C.
DocType: Member,Member Name,Ime člana
DocType: Account,Payable,Plačljivo
DocType: Job Card,For Quantity,Za količino
DocType: Territory,For reference,Za referenco
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Add to Cart,Dodaj v voziček
DocType: Global Defaults,Global Defaults,Globalne privzete nastavitve
DocType: Leave Application,Follow via Email,Sledite po e-pošti
DocType: Leave Allocation,Total Leaves Allocated,Skupaj dodeljenih listov
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Raw Material,Surovina
DocType: Manufacturer,Limited to 12 characters,Omejeno na 12 znakov
DocType: Selling Settings,Customer Naming By,Odjemalec imenuje uporabnika
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Packed quantity must equal quantity for Item {0} in row {1},Pakirana količina mora biti enaka količini za element {0} v vrstici {1}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js,New Sales Person Name,Ime nove prodajne osebe
DocType: Amazon MWS Settings,Amazon will synch data updated after this date,"Amazon bo sinhroniziral podatke, posodobljene po tem datumu"
DocType: Service Day,Service Day,Dan službe
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Odbitki davkov in dajatev (valuta podjetja)
DocType: Project,Gross Margin %,Bruto marža%
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Bank Statement balance as per General Ledger,Stanje bančnega izpiska v skladu z glavno knjigo
apps/erpnext/erpnext/public/js/setup_wizard.js,Healthcare (beta),Zdravstveno varstvo (beta)
DocType: Shopify Settings,Default Warehouse to to create Sales Order and Delivery Note,Privzeto skladišče za ustvarjanje prodajnega naloga in dobavnice
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Response Time for {0} at index {1} can't be greater than Resolution Time.,Odzivni čas za {0} pri indeksu {1} ne sme biti večji od časa za resolucijo.
DocType: Opportunity,Customer / Lead Name,Stranka / ime vodje
DocType: Student,EDU-STU-.YYYY.-,EDU-STU-.YYYY.-
DocType: Expense Claim Advance,Unclaimed amount,Nezahtevani znesek
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Source and target warehouse cannot be same for row {0},Vir in ciljno skladišče ne moreta biti enaka za vrstico {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},Vrstica amortizacije {0}: pričakovana vrednost po življenjski dobi mora biti večja ali enaka {1}
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Please select date,Izberite datum
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Salary Structure should have flexible benefit component(s) to dispense benefit amount,Struktura plač bi morala imeti fleksibilno (-e) komponento (-e) za izplačilo zneska pomoči
DocType: Employee Attendance Tool,Employee Attendance Tool,Orodje za udeležbo zaposlenih
DocType: Employee,Educational Qualification,Izobraževalna kvalifikacija
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Accessable Value,Dostopna vrednost
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Sample quantity {0} cannot be more than received quantity {1},Količina vzorca {0} ne more biti več kot prejeta količina {1}
DocType: POS Profile,Taxes and Charges,Davki in pristojbine
DocType: Opportunity,Contact Mobile No,Kontakt Mobile No
DocType: Employee,Joining Details,Podrobnosti o pridružitvi
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Start Job,Začni delo
DocType: Quality Action Table,Quality Action Table,Tabela ukrepov kakovosti
DocType: Healthcare Practitioner,Phone (Office),Telefon (Office)
DocType: Timesheet Detail,Operation ID,ID operacije
DocType: Soil Texture,Silt Loam,Muljna ilovica
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please set the Default Cost Center in {0} company.,Nastavite privzeto središče stroškov v podjetju {0}.
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Update Email Group,Posodobite skupino e-poštnih sporočil
DocType: Employee Promotion,Employee Promotion Detail,Podrobnosti o promociji zaposlenih
DocType: Loan Application,Repayment Info,Informacije o povračilu
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Show unclosed fiscal year's P&L balances,Prikažite neporabljena stanja poslovnega izida
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, da {1} ne bo navedel navedbe, vendar so bile navedene vse postavke. Posodabljanje statusa ponudb za RFQ."
DocType: Asset,Finance Books,Knjige financ
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,"Buying must be checked, if Applicable For is selected as {0}","Nakup mora biti preverjen, če je izbrano za možnost {0}"
DocType: Stock Settings,Role Allowed to edit frozen stock,Vloga Dovoljena za urejanje zamrznjenih zalog
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication Date,Datum zadnje komunikacije
DocType: Activity Cost,Costing Rate,Stopnja obračunavanja stroškov
DocType: Shipping Rule,example: Next Day Shipping,Primer: Naslednji dan
DocType: Bank Statement Transaction Entry,Payment Invoice Items,Postavke računa za plačilo
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py,Tasks have been created for managing the {0} disease (on row {1}),Opravljene so bile naloge za upravljanje bolezni {0} (v vrstici {1})
DocType: Healthcare Settings,Confirmation Message,Potrditveno sporočilo
DocType: Lab Test UOM,Lab Test UOM,Laboratorijski test UOM
DocType: Leave Type,Earned Leave Frequency,Pridobljena frekvenca odhoda
DocType: Loyalty Program,Loyalty Program Type,Vrsta programa zvestobe
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,"Shipping Address does not have country, which is required for this Shipping Rule","Naslov za pošiljanje nima države, ki je potrebna za to pravilo pošiljanja"
DocType: POS Profile,Terms and Conditions,Pogoji
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule',"Prosimo, kliknite &#39;Ustvari razpored&#39;"
DocType: Sales Invoice,Total Qty,Skupna količina
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,All other ITC,Vse druge ITC
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Parties and Addresses,Uvoznice in naslovi
DocType: Item,List this Item in multiple groups on the website.,Navedite ta element v več skupinah na spletnem mestu.
DocType: Request for Quotation,Message for Supplier,Sporočilo za dobavitelja
DocType: Healthcare Practitioner,Phone (R),Telefon (R)
DocType: Maintenance Team Member,Team Member,Član ekipe
DocType: Issue,Service Level Agreement Creation,Ustvarjanje sporazuma o ravni storitev
DocType: Asset Category Account,Asset Category Account,Račun kategorije sredstev
,Team Updates,Posodobitve skupine
DocType: Bank Account,Party,Zabava
DocType: Soil Analysis,Ca/Mg,Ca / Mg
DocType: Purchase Invoice,Write Off Amount (Company Currency),Odpiši znesek (Valuta podjetja)
DocType: Stock Entry,Including items for sub assemblies,Vključno s postavkami za podsklopove
DocType: Course Topic,Topic Name,Ime teme
DocType: Budget,Applicable on booking actual expenses,Velja za rezervacije dejanskih stroškov
DocType: Purchase Invoice,Start date of current invoice's period,Začetni datum trenutnega računa
apps/erpnext/erpnext/utilities/user_progress.py,Litre,Liter
DocType: Marketplace Settings,Hub Seller Name,Ime prodajalca vozlišča
DocType: Stock Entry,Total Outgoing Value,Skupna izhodna vrednost
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill already exists for this document,Za ta dokument že obstaja e-Way Bill
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Auto repeat document updated,Posodobljen je dokument za samodejno ponavljanje
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","Za vrstico {0} v {1}. Če želite vključiti {2} v količino postavke, morajo biti vključene tudi vrstice {3}"
apps/erpnext/erpnext/config/stock.py,Serial No and Batch,Serijska št. In serija
DocType: Contract,Fulfilment Deadline,Rok izpolnitve
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Ustvari Job kartico
,Sales Person Commission Summary,Povzetek komisije za prodajne osebe
apps/erpnext/erpnext/education/utils.py,Quiz {0} does not exist,Kviz {0} ne obstaja
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,"Cannot process route, since Google Maps Settings is disabled.","Pot ni mogoče obdelati, ker so nastavitve za Google Zemljevide onemogočene."
apps/erpnext/erpnext/utilities/user_progress.py,Go to Items,Pojdi na elemente
DocType: Asset Value Adjustment,Current Asset Value,Trenutna vrednost sredstva
DocType: Support Search Source,Result Preview Field,Polje za predogled rezultatov
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please enter serial numbers for serialized item ,Vnesite serijske številke za serijsko postavko
DocType: GL Entry,Against Voucher Type,Vrsta proti kuponu
DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Pogoji za izpolnitev predloge pogodbe
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Allocating leaves...,Dodeljevanje listov ...
DocType: Student Applicant,Admitted,Sprejeto
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Get Updates,Pridobite posodobitve
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Black,Črna
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Year start date or end date is overlapping with {0}. To avoid please set company,"Datum začetka ali končni datum leta se prekrivata z {0}. Da bi se izognili, prosimo določite podjetje"
apps/erpnext/erpnext/templates/pages/projects.html,Show closed,Pokaži zaprto
DocType: Sample Collection,No. of print,Št
DocType: Sample Collection,HLC-SC-.YYYY.-,HLC-SC-.YYYY.-
