diff --git a/erpnext/translations/sl.csv b/erpnext/translations/sl.csv
index d114a06..7fbee52 100644
--- a/erpnext/translations/sl.csv
+++ b/erpnext/translations/sl.csv
@@ -1,5858 +1,5845 @@
-DocType: Employee,Salary Mode,Način plače
-DocType: Patient,Divorced,Ločen
-DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Dovoli da se artikel večkrat  doda v transakciji.
-apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Opusti Material obisk {0} pred preklicem te garancije
-apps/erpnext/erpnext/config/education.py +118,Assessment Reports,Poročila o oceni
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19,Consumer Products,Consumer Products
-DocType: Purchase Receipt,Subscription Detail,Podrobnosti o naročnini
-DocType: Supplier Scorecard,Notify Supplier,Obvesti dobavitelja
-DocType: Item,Customer Items,Artikli stranke
-DocType: Project,Costing and Billing,Obračunavanje stroškov in plačevanja
-apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: Parent account {1} can not be a ledger,Račun {0}: Matični račun {1} ne more biti Glavna knjiga
-DocType: Item,Publish Item to hub.erpnext.com,Objavite element na hub.erpnext.com
-apps/erpnext/erpnext/config/setup.py +88,Email Notifications,E-poštna obvestila
-apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26,Evaluation,vrednotenje
-DocType: Item,Default Unit of Measure,Privzeto mersko enoto
-DocType: SMS Center,All Sales Partner Contact,Vse Sales Partner Kontakt
-DocType: Employee,Leave Approvers,Pustite Approvers
-DocType: Sales Partner,Dealer,Trgovec
-DocType: Consultation,Investigations,Preiskave
-DocType: Restaurant Order Entry,Click Enter To Add,Kliknite Enter za dodajanje
-DocType: Employee,Rented,Najemu
-DocType: Purchase Order,PO-,po-
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +225,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Ustavljen Proizvodnja naročite ni mogoče preklicati, ga najprej Odčepiti preklicati"
-DocType: Vehicle Service,Mileage,Kilometrina
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +253,Do you really want to scrap this asset?,"Ali res želite, da ostanki ta sredstva?"
-DocType: Drug Prescription,Update Schedule,Posodobi urnik
-apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44,Select Default Supplier,Izberite Privzeta Dobavitelj
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37,Currency is required for Price List {0},Valuta je potrebna za tečajnico {0}
-DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Bo izračunano v transakciji.
-DocType: Purchase Order,Customer Contact,Stranka Kontakt
-DocType: Patient Appointment,Check availability,Preveri razpoložljivost
-DocType: Job Applicant,Job Applicant,Job Predlagatelj
-apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,Ta temelji na transakcijah proti temu dobavitelju. Oglejte si časovnico spodaj za podrobnosti
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120,Legal,Pravna
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191,Actual type tax cannot be included in Item rate in row {0},Dejanska davčna vrsta ne more biti vključen v ceno postavko v vrstici {0}
-DocType: Bank Guarantee,Customer,Stranka
-DocType: Purchase Receipt Item,Required By,Zahtevani Z
-DocType: Delivery Note,Return Against Delivery Note,Vrni Proti dobavnica
-DocType: Purchase Order,% Billed,% zaračunano
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43,Exchange Rate must be same as {0} {1} ({2}),Menjalni tečaj mora biti enaka kot {0} {1} ({2})
-DocType: Sales Invoice,Customer Name,Ime stranke
-DocType: Vehicle,Natural Gas,Zemeljski plin
-apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64,Bank account cannot be named as {0},Bančni račun ne more biti imenovan kot {0}
-DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,Glave (ali skupine) po katerih so narejene vknjižbe in se ohranjajo bilance.
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196,Outstanding for {0} cannot be less than zero ({1}),Izjemna za {0} ne more biti manjša od nič ({1})
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +343,There are no submitted Salary Slips to process.,Za obdelavo ni predloženih plačljivih lističev.
-DocType: Manufacturing Settings,Default 10 mins,Privzeto 10 minut
-DocType: Leave Type,Leave Type Name,Pustite Tip Ime
-apps/erpnext/erpnext/templates/pages/projects.js +62,Show open,Prikaži odprte
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8,It is necessary to take this action today itself for the above mentioned recurring,To akcijo je treba sprejeti sam danes za zgoraj omenjeno ponavljajoče se obdobje
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.py +24,Diagnosis and Complaints cannot be left blank,Diagnoze in pritožbe ni mogoče pustiti prazno
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +151,Series Updated Successfully,Zaporedje uspešno posodobljeno
-apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6,Checkout,Naročilo
-DocType: Pricing Rule,Apply On,Nanesite na
-DocType: Item Price,Multiple Item prices.,Več cene postavko.
-,Purchase Order Items To Be Received,Naročilnica Postavke da bodo prejete
-DocType: SMS Center,All Supplier Contact,Vse Dobavitelj Kontakt
-DocType: Support Settings,Support Settings,Nastavitve podpora
-apps/erpnext/erpnext/projects/doctype/project/project.py +74,Expected End Date can not be less than Expected Start Date,Pričakuje Končni datum ne more biti manjši od pričakovanega začetka Datum
-apps/erpnext/erpnext/utilities/transaction_base.py +117,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Vrstica # {0}: Stopnja mora biti enaka kot {1}: {2} ({3} / {4})
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +241,New Leave Application,New Leave Application
-,Batch Item Expiry Status,Serija Točka preteka Status
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184,Bank Draft,Bank Osnutek
-DocType: Membership,membership validaty section,članstvo veljaven oddelek
-DocType: Mode of Payment Account,Mode of Payment Account,Način plačilnega računa
-DocType: Consultation,Consultation,Posvetovanje
-DocType: Accounts Settings,Show Payment Schedule in Print,Prikaži čas plačila v tisku
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19,Sales and Returns,Prodaja in vrnitev
-apps/erpnext/erpnext/stock/doctype/item/item.js +56,Show Variants,Prikaži Variante
-DocType: Academic Term,Academic Term,Academic Term
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,Material
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66,Making website,Izdelava spletne strani
-DocType: Opening Invoice Creation Tool Item,Quantity,Količina
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546,Accounts table cannot be blank.,Predstavlja tabela ne more biti prazno.
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154,Loans (Liabilities),Posojili (obveznosti)
-DocType: Employee Education,Year of Passing,"Leto, ki poteka"
-DocType: Item,Country of Origin,Država izvora
-DocType: Soil Texture,Soil Texture Criteria,Kriteriji za teksturo tal
-apps/erpnext/erpnext/templates/includes/product_page.js +24,In Stock,Na zalogi
-apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16,Primary Contact Details,Primarni kontaktni podatki
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,odprta vprašanja
-DocType: Production Order,Production Plan Item,Proizvodni načrt Postavka
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +149,User {0} is already assigned to Employee {1},Uporabnik {0} je že dodeljen Employee {1}
-DocType: Lab Test Groups,Add new line,Dodaj novo vrstico
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31,Health Care,Zdravstvo
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,Delay in payment (Days),Zamuda pri plačilu (dnevi)
-DocType: Payment Terms Template Detail,Payment Terms Template Detail,Podrobnosti o predlogi za plačila
-DocType: Hotel Room Reservation,Guest Name,Ime gosta
-DocType: Lab Prescription,Lab Prescription,Laboratorijski recept
-,Delay Days,Dnevi zamude
-apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26,Service Expense,Service Expense
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +899,Serial Number: {0} is already referenced in Sales Invoice: {1},Serijska številka: {0} že naveden v prodajne fakture: {1}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +880,Invoice,Račun
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +145,Make Retention Stock Entry,Naredite zadrževalni zalogi
-DocType: Purchase Invoice Item,Item Weight Details,Element Teža Podrobnosti
-DocType: Asset Maintenance Log,Periodicity,Periodičnost
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Poslovno leto {0} je potrebno
-DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,Najmanjša razdalja med vrstami rastlin za optimalno rast
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21,Defense,Obramba
-DocType: Salary Component,Abbr,Abbr
-DocType: Appraisal Goal,Score (0-5),Ocena (0-5)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +225,Row {0}: {1} {2} does not match with {3},Vrstica {0}: {1} {2} ne ujema s {3}
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +77,Row # {0}:,Vrstica # {0}:
-DocType: Timesheet,Total Costing Amount,Skupaj Stanejo Znesek
-DocType: Delivery Note,Vehicle No,Nobeno vozilo
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +162,Please select Price List,Izberite Cenik
-DocType: Accounts Settings,Currency Exchange Settings,Nastavitve menjave valut
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +78,Row #{0}: Payment document is required to complete the trasaction,Vrstica # {0}: Plačilo dokument je potreben za dokončanje trasaction
-DocType: Production Order Operation,Work In Progress,V razvoju
-apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13,Please select date,Izberite datum
-DocType: Daily Work Summary Group,Holiday List,Seznam praznikov
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127,Accountant,Računovodja
-DocType: Hub Settings,Selling Price List,Prodajni cenik
-DocType: Patient,Tobacco Current Use,Trenutna uporaba tobaka
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +56,Selling Rate,Prodajna cena
-DocType: Cost Center,Stock User,Stock Uporabnik
-DocType: Soil Analysis,(Ca+Mg)/K,(Ca+Mg)/K
-DocType: Company,Phone No,Telefon
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +239,New {0}: #{1},Nov {0}: # {1}
-DocType: Delivery Trip,Initial Email Notification Sent,Poslano je poslano obvestilo o e-pošti
-,Sales Partners Commission,Partnerji Sales Komisija
-DocType: Soil Texture,Sandy Clay Loam,Sandy Clay Loam
-DocType: Purchase Invoice,Rounding Adjustment,Prilagajanje zaokroževanja
-apps/erpnext/erpnext/setup/doctype/company/company.py +46,Abbreviation cannot have more than 5 characters,Kratica ne more imeti več kot 5 znakov
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Stranka&gt; Skupina strank&gt; Teritorija
-DocType: Physician Schedule Time Slot,Physician Schedule Time Slot,Časovni razpored zdravnika
-DocType: Payment Request,Payment Request,Plačilni Nalog
-DocType: Asset,Value After Depreciation,Vrednost po amortizaciji
-DocType: Student,O+,O +
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8,Related,Podobni
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43,Attendance date can not be less than employee's joining date,Datum udeležba ne sme biti manjša od povezuje datumu zaposlenega
-DocType: Grading Scale,Grading Scale Name,Ocenjevalna lestvica Ime
-DocType: Subscription,Repeat on Day,Ponovi na dan
-apps/erpnext/erpnext/accounts/doctype/account/account.js +41,This is a root account and cannot be edited.,To je račun root in jih ni mogoče urejati.
-DocType: Sales Invoice,Company Address,Naslov podjetja
-DocType: BOM,Operations,Operacije
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38,Cannot set authorization on basis of Discount for {0},Ni mogoče nastaviti dovoljenja na podlagi popust za {0}
-DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Pripni datoteko .csv z dvema stolpcema, eno za staro ime in enega za novim imenom"
-apps/erpnext/erpnext/accounts/utils.py +73,{0} {1} not in any active Fiscal Year.,{0} {1} ni v nobenem poslovnem letu
-DocType: Packed Item,Parent Detail docname,Parent Detail docname
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: {0}, Item Code: {1} and Customer: {2}",Referenca: {0} Oznaka: {1} in stranke: {2}
-apps/erpnext/erpnext/utilities/user_progress.py +143,Kg,Kg
-apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Odpiranje za službo.
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +114,BOM is not specified for subcontracting item {0} at row {1},BOM ni določen za podizvajalsko postavko {0} v vrstici {1}
-apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149,{0} Result submittted,{0} vloženo
-DocType: Item Attribute,Increment,Prirastek
-apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74,Timespan,Časovni razpon
-apps/erpnext/erpnext/public/js/stock_analytics.js +61,Select Warehouse...,Izberite Skladišče ...
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6,Advertising,Oglaševanje
-apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,Ista družba je vpisana več kot enkrat
-DocType: Patient,Married,Poročen
-apps/erpnext/erpnext/accounts/party.py +42,Not permitted for {0},Ni dovoljeno za {0}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593,Get items from,Pridobi artikle iz
-DocType: Price List,Price Not UOM Dependant,Cena ni odvisna od UOM
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +467,Stock cannot be updated against Delivery Note {0},Stock ni mogoče posodobiti proti dobavnica {0}
-apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Izdelek {0}
-apps/erpnext/erpnext/templates/generators/item_group.html +43,No items listed,"Ni elementov, navedenih"
-DocType: Asset Repair,Error Description,Opis napake
-DocType: Payment Reconciliation,Reconcile,Uskladitev
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30,Grocery,Trgovina z živili
-DocType: Quality Inspection Reading,Reading 1,Branje 1
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40,Pension Funds,Pokojninski skladi
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +91,Next Depreciation Date cannot be before Purchase Date,Naslednja Amortizacija datum ne more biti pred Nakup Datum
-DocType: Crop,Perennial,Trajen
-DocType: Consultation,Consultation Date,Datum posvetovanja
-DocType: Accounts Settings,Use Custom Cash Flow Format,Uporabite obliko prilagojenega denarnega toka
-DocType: SMS Center,All Sales Person,Vse Sales oseba
-DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"**Mesečna razporeditev** vam pomaga razporejati proračun/cilje po mesecih, če imate sezonskost v vaši dejavnosti."
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1752,Not items found,Ni najdenih predmetov
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183,Salary Structure Missing,Plača Struktura Missing
-DocType: Lead,Person Name,Ime oseba
-DocType: Sales Invoice Item,Sales Invoice Item,Artikel na računu
-DocType: Account,Credit,Credit
-DocType: POS Profile,Write Off Cost Center,Napišite Off stroškovni center
-apps/erpnext/erpnext/public/js/setup_wizard.js +117,"e.g. ""Primary School"" or ""University""",npr &quot;Osnovna šola&quot; ali &quot;University&quot;
-apps/erpnext/erpnext/config/stock.py +28,Stock Reports,Poročila o zalogi
-DocType: Warehouse,Warehouse Detail,Skladišče Detail
-apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33,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.,"Izraz Končni datum ne more biti najpozneje do leta End Datum študijskem letu, v katerem je izraz povezan (študijsko leto {}). Popravite datum in poskusite znova."
-apps/erpnext/erpnext/stock/doctype/item/item.py +268,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","""Ali je osnovno sredstvo"" ne more biti neizbrano, saj obstaja evidenca sredstev po postavki"
-DocType: Delivery Trip,Departure Time,Čas odhoda
-DocType: Vehicle Service,Brake Oil,Zavorna olja
-DocType: Tax Rule,Tax Type,Davčna Type
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +581,Taxable Amount,Davčna osnova
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160,You are not authorized to add or update entries before {0},Nimate dovoljenja za dodajanje ali posodobitev vnose pred {0}
-DocType: BOM,Item Image (if not slideshow),Postavka Image (če ne slideshow)
-DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Urna postavka / 60) * Dejanski  čas operacije
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1076,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Vrstica # {0}: Referenčni dokument mora biti eden od zahtevkov za stroške ali vpisa v dnevnik
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +966,Select BOM,Izberite BOM
-DocType: SMS Log,SMS Log,SMS Log
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Nabavna vrednost dobavljenega predmeta
-apps/erpnext/erpnext/config/hr.py +127,Manage advance amount given to the Employee,"Upravljajte znesek vnaprej, ki ga dobite zaposleni"
-apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38,The holiday on {0} is not between From Date and To Date,"Praznik na {0} ni med Od datuma, do sedaj"
-DocType: Student Log,Student Log,študent Log
-apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Predloge dobaviteljevega položaja.
-DocType: Lead,Interested,Zanima
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +216,Opening,Otvoritev
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32,From {0} to {1},Od {0} do {1}
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50,Failed to setup taxes,Nastavitev davkov ni uspela
-DocType: Item,Copy From Item Group,Kopiranje iz postavke skupine
-DocType: Delivery Trip,Delivery Notification,Obvestilo o dostavi
-DocType: Journal Entry,Opening Entry,Otvoritev Začetek
-apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Račun Pay samo
-DocType: Employee Loan,Repay Over Number of Periods,Odplačilo Over število obdobij
-DocType: Stock Entry,Additional Costs,Dodatni stroški
-apps/erpnext/erpnext/accounts/doctype/account/account.py +138,Account with existing transaction can not be converted to group.,Račun z obstoječim poslom ni mogoče pretvoriti v skupini.
-DocType: Lead,Product Enquiry,Povpraševanje izdelek
-DocType: Education Settings,Validate Batch for Students in Student Group,Potrdite Batch za študente v študentskih skupine
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,No leave record found for employee {0} for {1},Št odsotnost zapisa dalo za delavca {0} za {1}
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23,Please enter company first,"Prosimo, da najprej vnesete podjetje"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +365,Please select Company first,"Prosimo, izberite Company najprej"
-DocType: Employee Education,Under Graduate,Pod Graduate
-apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,Ciljna Na
-DocType: BOM,Total Cost,Skupni stroški
-DocType: Soil Analysis,Ca/K,Ca / K
-DocType: Journal Entry Account,Employee Loan,zaposlenih Loan
-DocType: Fee Schedule,Send Payment Request Email,Pošlji e-pošto za plačilni zahtevek
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +269,Item {0} does not exist in the system or has expired,Element {0} ne obstaja v sistemu ali je potekla
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44,Real Estate,Nepremičnina
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Izkaz računa
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41,Pharmaceuticals,Farmacevtski izdelki
-DocType: Purchase Invoice Item,Is Fixed Asset,Je osnovno sredstvo
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +260,"Available qty is {0}, you need {1}","Preberi je {0}, morate {1}"
-DocType: Expense Claim Detail,Claim Amount,Trditev Znesek
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56,Duplicate customer group found in the cutomer group table,Dvojnik skupina kupcev so v tabeli cutomer skupine
-apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Type / Supplier,Dobavitelj Vrsta / dobavitelj
-DocType: Naming Series,Prefix,Predpona
-apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7,Event Location,Lokacija dogodka
-DocType: Asset Settings,Asset Settings,Nastavitve sredstva
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68,Consumable,Potrošni
-DocType: Student,B-,B-
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +98,Successfully unregistered.,Uspešno neregistriran.
-DocType: Assessment Result,Grade,razred
-DocType: Restaurant Table,No of Seats,Število sedežev
-DocType: Subscription,"To add dynamic subject, use jinja tags like
-
-<div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>","Če želite dodati dinamični predmet, uporabite oznake z oznako <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>"
-DocType: Sales Invoice Item,Delivered By Supplier,Delivered dobavitelj
-DocType: Asset Maintenance Task,Asset Maintenance Task,Naloga vzdrževanja sredstev
-DocType: SMS Center,All Contact,Vse Kontakt
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +954,Production Order already created for all items with BOM,Proizvodnja naročite že ustvarili za vse postavke s BOM
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +231,Annual Salary,Letne plače
-DocType: Daily Work Summary,Daily Work Summary,Dnevni Delo Povzetek
-DocType: Period Closing Voucher,Closing Fiscal Year,Zapiranje poslovno leto
-apps/erpnext/erpnext/accounts/party.py +393,{0} {1} is frozen,{0} {1} je zamrznjeno
-apps/erpnext/erpnext/setup/doctype/company/company.py +140,Please select Existing Company for creating Chart of Accounts,Izberite obstoječo družbo za ustvarjanje kontnem načrtu
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80,Stock Expenses,Zaloga Stroški
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +111,Select Target Warehouse,Izberite Target Skladišče
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +111,Select Target Warehouse,Izberite Target Skladišče
-apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,Vnesite Želeni Kontakt Email
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45,CompAuxNum,CompAuxNum
-DocType: Journal Entry,Contra Entry,Contra Začetek
-DocType: Journal Entry Account,Credit in Company Currency,Kredit v podjetju valuti
-DocType: Lab Test UOM,Lab Test UOM,Lab Test UOM
-DocType: Delivery Note,Installation Status,Namestitev Status
-DocType: BOM,Quality Inspection Template,Obrazec za pregled kakovosti
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135,"Do you want to update attendance?<br>Present: {0}\
-					<br>Absent: {1}",Ali želite posodobiti prisotnost? <br> Sedanje: {0} \ <br> Odsoten: {1}
-apps/erpnext/erpnext/controllers/buying_controller.py +344,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Sprejeta + Zavrnjeno Količina mora biti enaka Prejeto količini za postavko {0}
-DocType: Request for Quotation,RFQ-,RFQ-
-DocType: Item,Supply Raw Materials for Purchase,Dobava surovine za nakup
-DocType: Agriculture Analysis Criteria,Fertilizer,Gnojilo
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +152,At least one mode of payment is required for POS invoice.,za POS računa je potreben vsaj en način plačila.
-DocType: Products Settings,Show Products as a List,Prikaži izdelke na seznamu
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +519,Item {0} is not active or end of life has been reached,Postavka {0} ni aktiven ali je bil dosežen konec življenja
-DocType: Student Admission Program,Minimum Age,Najnižja starost
-apps/erpnext/erpnext/utilities/user_progress.py +187,Example: Basic Mathematics,Primer: Osnovna matematika
-DocType: Customer,Primary Address,Primarni naslov
-DocType: Production Plan,Material Request Detail,Materialna zahteva Podrobnosti
-DocType: Selling Settings,Default Quotation Validity Days,Privzeti dnevi veljavnosti ponudbe
-apps/erpnext/erpnext/controllers/accounts_controller.py +793,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Da vključujejo davek v vrstici {0} v stopnji Element, davki v vrsticah {1} je treba vključiti tudi"
-apps/erpnext/erpnext/config/hr.py +223,Settings for HR Module,Nastavitve za HR modula
-DocType: SMS Center,SMS Center,SMS center
-DocType: Sales Invoice,Change Amount,Znesek spremembe
-DocType: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,"Nastavite vrednost računa za B2C. B2CL in B2CS, izračunano na podlagi te fakture."
-DocType: BOM Update Tool,New BOM,New BOM
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,Show only POS,Prikaži samo POS
-DocType: Driver,Driving License Categories,Kategorije vozniških dovoljenj
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118,Please enter Delivery Date,Vnesite datum dostave
-DocType: Depreciation Schedule,Make Depreciation Entry,Naj Amortizacija Začetek
-DocType: Appraisal Template Goal,KRA,KRA
-DocType: Lead,Request Type,Zahteva Type
-apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +17,Make Employee,Naj Zaposleni
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,Broadcasting
-apps/erpnext/erpnext/config/accounts.py +313,Setup mode of POS (Online / Offline),Način nastavitve POS (Online / Offline)
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191,Execution,Izvedba
-apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Podrobnosti o poslovanju izvajajo.
-DocType: Asset Maintenance Log,Maintenance Status,Status vzdrževanje
-apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10,Membership Details,Podrobnosti o članstvu
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}: zahtevan je Dobavitelj za račun izdatkov {2}
-apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Predmeti in Pricing
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},Skupno število ur: {0}
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,From Date should be within the Fiscal Year. Assuming From Date = {0},Od datuma mora biti v poslovnem letu. Ob predpostavki Od datuma = {0}
-DocType: Drug Prescription,Interval,Interval
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +252,Preference,Prednost
-DocType: Grant Application,Individual,Individualno
-DocType: Academic Term,Academics User,akademiki Uporabnik
-DocType: Cheque Print Template,Amount In Figure,Znesek v sliki
-DocType: Employee Loan Application,Loan Info,posojilo Info
-apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Načrt za vzdrževanje obiskov.
-DocType: Supplier Scorecard Period,Supplier Scorecard Period,Period ocenjevanja dobaviteljev
-DocType: Share Transfer,Share Transfer,Prenos delnic
-DocType: POS Profile,Customer Groups,Skupine uporabnikov
-apps/erpnext/erpnext/public/js/financial_statements.js +51,Financial Statements,Finančne izjave
-DocType: Guardian,Students,študenti
-apps/erpnext/erpnext/config/selling.py +91,Rules for applying pricing and discount.,Pravila za uporabo cene in popust.
-DocType: Daily Work Summary,Daily Work Summary Group,Skupina dnevnih del
-DocType: Physician Schedule,Time Slots,Časovne reže
-apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,Cenik mora biti primerno za nakup ali prodajo
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79,Installation date cannot be before delivery date for Item {0},Datum namestitve ne more biti pred datumom dostave za postavko {0}
-DocType: Pricing Rule,Discount on Price List Rate (%),Popust na ceno iz cenika Stopnja (%)
-apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112,Item Template,Predloga postavke
-apps/erpnext/erpnext/healthcare/setup.py +215,Biochemistry,Biokemija
-DocType: Job Offer,Select Terms and Conditions,Izberite Pogoji
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72,Out Value,iz Vrednost
-DocType: Production Plan,Sales Orders,Naročila Kupcev
-DocType: Purchase Taxes and Charges,Valuation,Vrednotenje
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +386,Set as Default,Nastavi kot privzeto
-DocType: Production Plan,PLN-,PLN-
-,Purchase Order Trends,Naročilnica Trendi
-apps/erpnext/erpnext/utilities/user_progress.py +75,Go to Customers,Pojdi na stranke
-DocType: Hotel Room Reservation,Late Checkin,Pozno preverjanje
-apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,The request for quotation can be accessed by clicking on the following link,Zahteva za ponudbo lahko dostopate s klikom na spodnjo povezavo
-apps/erpnext/erpnext/config/hr.py +81,Allocate leaves for the year.,Dodeli liste za leto.
-DocType: SG Creation Tool Course,SG Creation Tool Course,SG ustvarjanja orodje za golf
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +262,Insufficient Stock,nezadostna Stock
-DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Onemogoči Capacity Planning and Time Tracking
-DocType: Email Digest,New Sales Orders,Novi prodajni nalogi
-DocType: Bank Guarantee,Bank Account,Bančni račun
-DocType: Leave Type,Allow Negative Balance,Dovoli negativni saldo
-apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',Ne morete izbrisati vrste projekta &quot;Zunanji&quot;
-DocType: Employee,Create User,Ustvari uporabnika
-DocType: Selling Settings,Default Territory,Privzeto Territory
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53,Television,Televizija
-DocType: Production Order Operation,Updated via 'Time Log',Posodobljeno preko &quot;Čas Logu&quot;
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +430,Advance amount cannot be greater than {0} {1},Advance znesek ne sme biti večja od {0} {1}
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42,JournalCode,JournalCode
-DocType: Naming Series,Series List for this Transaction,Seznam zaporedij za to transakcijo
-DocType: Company,Enable Perpetual Inventory,Omogoči nepretrganega popisovanja
-DocType: Company,Default Payroll Payable Account,Privzeto Plače plačljivo račun
-apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51,Update Email Group,Posodobitev e-Group
-DocType: Sales Invoice,Is Opening Entry,Je vstopna odprtina
-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č ga lahko uporabite pri ustvarjanju skupinskih testov."
-DocType: Customer Group,Mention if non-standard receivable account applicable,"Omemba če nestandardni terjatve račun, ki se uporablja"
-DocType: Course Schedule,Instructor Name,inštruktor Ime
-DocType: Supplier Scorecard,Criteria Setup,Nastavitev meril
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +206,For Warehouse is required before Submit,Za skladišče je pred potreben Submit
-apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8,Received On,Prejetih Na
-DocType: Sales Partner,Reseller,Reseller
-DocType: Codification Table,Medical Code,Zdravstvena koda
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20,Please enter Company,Vnesite Company
-DocType: Delivery Note Item,Against Sales Invoice Item,Proti Sales računa Postavka
-DocType: Agriculture Analysis Criteria,Linked Doctype,Povezani Doctype
-,Production Orders in Progress,Proizvodna naročila v teku
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +44,Net Cash from Financing,Neto denarni tokovi pri financiranju
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2359,"LocalStorage is full , did not save","Lokalno shrambo je polna, ni shranil"
-DocType: Lead,Address & Contact,Naslov in kontakt
-DocType: Leave Allocation,Add unused leaves from previous allocations,Dodaj neuporabljene liste iz prejšnjih dodelitev
-DocType: Sales Partner,Partner website,spletna stran partnerja
-DocType: Restaurant Order Entry,Add Item,Dodaj predmet
-DocType: Lab Test,Custom Result,Rezultat po meri
-DocType: Delivery Stop,Contact Name,Kontaktno ime
-DocType: Course Assessment Criteria,Course Assessment Criteria,Merila ocenjevanja tečaj
-DocType: POS Customer Group,POS Customer Group,POS Group stranke
-DocType: Land Unit,Land Unit describing various land assets,"Land enota, ki opisuje različna zemljišča"
-DocType: Cheque Print Template,Line spacing for amount in words,Razmik med vrsticami za znesek z besedami
-DocType: Vehicle,Additional Details,Dodatne podrobnosti
-apps/erpnext/erpnext/templates/generators/bom.html +85,No description given,Opis ni dana
-apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,Zaprosi za nakup.
-DocType: Lab Test,Submitted Date,Datum predložitve
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,Ta temelji na časovnih preglednicah ustvarjenih pred tem projektu
-DocType: Payment Term,Credit Months,Kreditni meseci
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +408,Net Pay cannot be less than 0,Neto plača ne sme biti manjši od 0
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,"To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription","Če želite prenehati pošiljati ponavljajoča obvestila o napakah iz sistema, smo v naročnini označili polje Disabled"
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +121,Relieving Date must be greater than Date of Joining,Lajšanje Datum mora biti večja od Datum pridružitve
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239,Leaves per Year,Listi na leto
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Vrstica {0}: Prosimo, preverite &quot;Je Advance&quot; proti račun {1}, če je to predujem vnos."
-apps/erpnext/erpnext/stock/utils.py +219,Warehouse {0} does not belong to company {1},Skladišče {0} ne pripada podjetju {1}
-DocType: Email Digest,Profit & Loss,Profit &amp; Loss
-apps/erpnext/erpnext/utilities/user_progress.py +144,Litre,Liter
-DocType: Task,Total Costing Amount (via Time Sheet),Skupaj Costing Znesek (preko Čas lista)
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +69,Please setup Students under Student Groups,"Prosimo, nastavite Študente v študentskih skupinah"
-DocType: Item Website Specification,Item Website Specification,Element Spletna stran Specifikacija
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +449,Leave Blocked,Pustite blokiranih
-apps/erpnext/erpnext/stock/doctype/item/item.py +739,Item {0} has reached its end of life on {1},Postavka {0} je konec življenja na {1}
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +83,Bank Entries,bančni vnosi
-DocType: Crop,Annual,Letno
-DocType: Stock Reconciliation Item,Stock Reconciliation Item,Stock Sprava Postavka
-DocType: Stock Entry,Sales Invoice No,Prodaja Račun Ne
-DocType: Material Request Item,Min Order Qty,Min naročilo Kol
-DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Orodje za oblikovanje študent Group tečaj
-DocType: Lead,Do Not Contact,Ne Pišite
-apps/erpnext/erpnext/utilities/user_progress.py +207,People who teach at your organisation,"Ljudje, ki poučujejo v vaši organizaciji"
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135,Software Developer,Razvijalec programske opreme
-DocType: Item,Minimum Order Qty,Najmanjše naročilo Kol
-DocType: Pricing Rule,Supplier Type,Dobavitelj Type
-DocType: Course Scheduling Tool,Course Start Date,Datum začetka predmeta
-,Student Batch-Wise Attendance,Študent šaržno in postrežbo
-DocType: POS Profile,Allow user to edit Rate,"Dovoli uporabniku, da uredite Razmerje"
-DocType: Item,Publish in Hub,Objavite v Hub
-DocType: Student Admission,Student Admission,študent Sprejem
-,Terretory,Terretory
-apps/erpnext/erpnext/stock/doctype/item/item.py +761,Item {0} is cancelled,Postavka {0} je odpovedan
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1055,Material Request,Zahteva za material
-DocType: Bank Reconciliation,Update Clearance Date,Posodobitev Potrditev Datum
-,GSTR-2,GSTR-2
-DocType: Item,Purchase Details,Nakup Podrobnosti
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +394,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},"Postavka {0} ni bilo mogoče najti v &quot;surovin, dobavljenih&quot; mizo v narocilo {1}"
-DocType: Salary Slip,Total Principal Amount,Skupni glavni znesek
-DocType: Student Guardian,Relation,Razmerje
-DocType: Student Guardian,Mother,mati
-DocType: Restaurant Reservation,Reservation End Time,Končni čas rezervacije
-DocType: Crop,Biennial,Bienale
-apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Potrjena naročila od strank.
-DocType: Purchase Receipt Item,Rejected Quantity,Zavrnjeno Količina
-apps/erpnext/erpnext/education/doctype/fees/fees.py +80,Payment request {0} created,Zahtevek za plačilo {0} je bil ustvarjen
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Open Orders,Odprta naročila
-apps/erpnext/erpnext/healthcare/setup.py +255,Low Sensitivity,Nizka občutljivost
-DocType: Notification Control,Notification Control,Nadzor obvestilo
-apps/erpnext/erpnext/templates/emails/training_event.html +17,Please confirm once you have completed your training,"Potrdite, ko ste končali usposabljanje"
-DocType: Lead,Suggestions,Predlogi
-DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Set Postavka proračuni Skupina pametno na tem ozemlju. Lahko tudi sezonske z nastavitvijo Distribution.
-DocType: Payment Term,Payment Term Name,Ime izraza za plačilo
-DocType: Healthcare Settings,Create documents for sample collection,Ustvarite dokumente za zbiranje vzorcev
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Plačilo pred {0} {1} ne sme biti večja od neporavnanega zneska {2}
-DocType: Shareholder,Address HTML,Naslov HTML
-DocType: Lead,Mobile No.,Mobilni No.
-DocType: Maintenance Schedule,Generate Schedule,Ustvarjajo Urnik
-DocType: Purchase Invoice Item,Expense Head,Expense Head
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +138,Please select Charge Type first,"Prosimo, izberite Charge Vrsta najprej"
-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.. ","Določite lahko vse naloge, ki jih je treba izvesti za ta pridelek tukaj. Dansko polje se uporablja za navedbo dneva, ko je naloga treba opraviti, 1 je 1. dan itd."
-DocType: Student Group Student,Student Group Student,Študentska skupina Študent
-apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Zadnje
-DocType: Asset Maintenance Task,2 Yearly,2 letno
-DocType: Education Settings,Education Settings,Nastavitve izobraževanja
-DocType: Vehicle Service,Inspection,inšpekcija
-DocType: Supplier Scorecard Scoring Standing,Max Grade,Max razred
-DocType: Email Digest,New Quotations,Nove ponudbe
-DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,"E-pošta plačilni list na zaposlenega, ki temelji na prednostni e-pošti izbrani na zaposlenega"
-DocType: Employee,The first Leave Approver in the list will be set as the default Leave Approver,"Prvi Leave odobritelj na seznamu, bo nastavljen kot privzeti Leave odobritelja"
-DocType: Tax Rule,Shipping County,Dostava County
-apps/erpnext/erpnext/config/desktop.py +167,Learn,Naučite
-DocType: Asset,Next Depreciation Date,Naslednja Amortizacija Datum
-apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Stroški dejavnost na zaposlenega
-DocType: Accounts Settings,Settings for Accounts,Nastavitve za račune
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +673,Supplier Invoice No exists in Purchase Invoice {0},Dobavitelj računa ni v računu o nakupu obstaja {0}
-apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Upravljanje drevesa prodajalca.
-DocType: Job Applicant,Cover Letter,Cover Letter
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Neporavnani čeki in depoziti želite počistiti
-DocType: Item,Synced With Hub,Sinhronizirano Z Hub
-DocType: Driver,Fleet Manager,Fleet Manager
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542,Row #{0}: {1} can not be negative for item {2},Vrstica # {0} {1} ne more biti negativna za element {2}
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59,Wrong Password,Napačno geslo
-DocType: Item,Variant Of,Varianta
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +406,Completed Qty can not be greater than 'Qty to Manufacture',Dopolnil Količina ne sme biti večja od &quot;Kol za Izdelava&quot;
-DocType: Period Closing Voucher,Closing Account Head,Zapiranje računa Head
-DocType: Employee,External Work History,Zunanji Delo Zgodovina
-DocType: Physician,Time per Appointment,Čas na imenovanje
-apps/erpnext/erpnext/projects/doctype/task/task.py +110,Circular Reference Error,Krožna Reference Error
-DocType: Appointment Type,Is Inpatient,Je bolnišnična
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Ime Guardian1
-DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,"Z besedami (izvoz) bo viden, ko boste shranite dobavnici."
-DocType: Cheque Print Template,Distance from left edge,Oddaljenost od levega roba
-apps/erpnext/erpnext/utilities/bot.py +29,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} enot [{1}] (#Obrazec/Postavka/{1}) najden v [{2}] (#Obrazec/Skladišče/{2})
-DocType: Lead,Industry,Industrija
-DocType: Employee,Job Profile,Job profila
-DocType: BOM Item,Rate & Amount,Stopnja in znesek
-apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6,This is based on transactions against this Company. See timeline below for details,To temelji na transakcijah zoper to družbo. Za podrobnosti si oglejte časovni načrt spodaj
-DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Obvesti po e-pošti na ustvarjanje avtomatičnega Material dogovoru
-apps/erpnext/erpnext/healthcare/setup.py +259,Resistant,Odporen
-apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77,Please set Hotel Room Rate on {},"Prosimo, nastavite hotelsko sobo na {"
-DocType: Journal Entry,Multi Currency,Multi Valuta
-DocType: Opening Invoice Creation Tool,Invoice Type,Račun Type
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +939,Delivery Note,Poročilo o dostavi
-DocType: Consultation,Encounter Impression,Ujemanje prikaza
-apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,Postavitev Davki
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134,Cost of Sold Asset,Stroški Prodano sredstvi
-DocType: Volunteer,Morning,Jutro
-apps/erpnext/erpnext/accounts/utils.py +350,Payment Entry has been modified after you pulled it. Please pull it again.,"Začetek Plačilo je bil spremenjen, ko je potegnil. Prosimo, še enkrat vleči."
-DocType: Program Enrollment Tool,New Student Batch,Nova študentska serija
-apps/erpnext/erpnext/stock/doctype/item/item.py +478,{0} entered twice in Item Tax,{0} dvakrat vpisano v davčni postavki
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,Summary for this week and pending activities,Povzetek za ta teden in ki potekajo dejavnosti
-DocType: Student Applicant,Admitted,priznal
-DocType: Workstation,Rent Cost,Najem Stroški
-apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81,Amount After Depreciation,Znesek Po amortizacijo
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,Prihajajoči Koledar dogodkov
-apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1,Variant Attributes,Atributi atributov
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85,Please select month and year,"Prosimo, izberite mesec in leto"
-DocType: Employee,Company Email,Družba E-pošta
-DocType: GL Entry,Debit Amount in Account Currency,Debetno Znesek v Valuta računa
-DocType: Supplier Scorecard,Scoring Standings,Točkovno točkovanje
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,Vrednost naročila
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,Vrednost naročila
-apps/erpnext/erpnext/config/accounts.py +27,Bank/Cash transactions against party or for internal transfer,Bank / denarni posli proti osebi ali za notranjo prerazporeditvijo
-DocType: Shipping Rule,Valid for Countries,Velja za države
-apps/erpnext/erpnext/stock/doctype/item/item.js +55,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 postavka bodo kopirali več kot v različicah, razen če je nastavljeno &quot;Ne Kopiraj«"
-DocType: Grant Application,Grant Application,Grant Application
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Skupaj naročite Upoštevani
-apps/erpnext/erpnext/config/hr.py +243,"Employee designation (e.g. CEO, Director etc.).","Oznaka zaposleni (npr CEO, direktor itd.)"
-DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,"Stopnjo, po kateri je naročnik Valuta pretvori v osnovni valuti kupca"
-DocType: Course Scheduling Tool,Course Scheduling Tool,Seveda razporejanje orodje
-apps/erpnext/erpnext/controllers/accounts_controller.py +622,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Row # {0}: Nakup računa ni mogoče sklepati na podlagi obstoječega sredstva {1}
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +257,[Urgent] Error while creating recurring %s for %s,[Nujno] Napaka med ustvarjanjem ponavljajočega  %s za %s
-DocType: Land Unit,LInked Analysis,LInked analiza
-DocType: Item Tax,Tax Rate,Davčna stopnja
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +74,Application period cannot be across two allocation records,Obdobje uporabe ne more biti v dveh evidencah dodelitve
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59,{0} already allocated for Employee {1} for period {2} to {3},{0} že dodeljeno za zaposlenega {1} za obdobje {2} do {3}
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +141,Purchase Invoice {0} is already submitted,Nakup Račun {0} je že predložila
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +91,Row # {0}: Batch No must be same as {1} {2},Vrstica # {0}: mora Serija Ne biti enaka kot {1} {2}
-DocType: Material Request Plan Item,Material Request Plan Item,Postavka načrta materialne zahteve
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,"Pretvarjanje, da non-Group"
-DocType: C-Form Invoice Detail,Invoice Date,Datum računa
-DocType: GL Entry,Debit Amount,Debetni Znesek
-apps/erpnext/erpnext/accounts/party.py +249,There can only be 1 Account per Company in {0} {1},"Ne more biti samo 1 račun na podjetje, v {0} {1}"
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +425,Please see attachment,Glej prilogo
-DocType: Purchase Order,% Received,% Prejeto
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Ustvarjanje skupin študentov
-DocType: Volunteer,Weekends,Vikendi
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +113,Credit Note Amount,Credit Opomba Znesek
-DocType: Setup Progress Action,Action Document,Akcijski dokument
-DocType: Chapter Member,Website URL,Spletna stran URL
-,Finished Goods,"Končnih izdelkov,"
-DocType: Delivery Note,Instructions,Navodila
-DocType: Quality Inspection,Inspected By,Pregledajo
-DocType: Asset Maintenance Log,Maintenance Type,Vzdrževanje Type
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45,{0} - {1} is not enrolled in the Course {2},{0} - {1} ni vpisan v smer {2}
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},Serijska št {0} ne pripada dobavnica {1}
-apps/erpnext/erpnext/templates/pages/demo.html +47,ERPNext Demo,ERPNext Demo
-apps/erpnext/erpnext/public/js/utils/item_selector.js +20,Add Items,Dodaj artikel
-DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Postavka Inšpekcijski parametrov kakovosti
-DocType: Depreciation Schedule,Schedule Date,Urnik Datum
-apps/erpnext/erpnext/config/hr.py +116,"Earnings, Deductions and other Salary components","Plače, Odbitki in druge komponente plač"
-DocType: Packed Item,Packed Item,Pakirani Postavka
-DocType: Job Offer Term,Job Offer Term,Job Offer Term
-apps/erpnext/erpnext/config/buying.py +65,Default settings for buying transactions.,Privzete nastavitve za nabavo
-apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},Obstaja Stroški dejavnosti za Employee {0} proti vrsti dejavnosti - {1}
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15,Mandatory field - Get Students From,Obvezno polje - Get študentov iz
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15,Mandatory field - Get Students From,Obvezno polje - Get študentov iz
-DocType: Program Enrollment,Enrolled courses,vpisani tečaji
-DocType: Program Enrollment,Enrolled courses,vpisani tečaji
-DocType: Currency Exchange,Currency Exchange,Menjalnica
-DocType: Opening Invoice Creation Tool Item,Item Name,Ime izdelka
-DocType: Authorization Rule,Approving User  (above authorized value),Odobritvi uporabnik (zgoraj pooblaščeni vrednosti)
-DocType: Email Digest,Credit Balance,Credit Balance
-DocType: Employee,Widowed,Ovdovela
-DocType: Request for Quotation,Request for Quotation,Zahteva za ponudbo
-DocType: Healthcare Settings,Require Lab Test Approval,Zahtevajte odobritev testa za laboratorij
-DocType: Salary Slip Timesheet,Working Hours,Delovni čas
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +54,Total Outstanding,Skupaj izjemen
-DocType: Naming Series,Change the starting / current sequence number of an existing series.,Spremenite izhodiščno / trenutno zaporedno številko obstoječega zaporedja.
-DocType: Dosage Strength,Strength,Moč
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1533,Create a new Customer,Ustvari novo stranko
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Če je več Rules Cenik še naprej prevladovala, so pozvane, da nastavite Priority ročno za reševanje morebitnih sporov."
-apps/erpnext/erpnext/utilities/activation.py +90,Create Purchase Orders,Ustvari naročilnice
-,Purchase Register,Nakup Register
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +119,Patient not found,Bolnik ni najden
-DocType: Scheduling Tool,Rechedule,Rechedule
-DocType: Landed Cost Item,Applicable Charges,Veljavnih cenah
-DocType: Workstation,Consumable Cost,Potrošni stroški
-DocType: Purchase Receipt,Vehicle Date,Datum vozilo
-DocType: Student Log,Medical,Medical
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175,Reason for losing,Razlog za izgubo
-apps/erpnext/erpnext/accounts/doctype/account/account.js +52,Update Account Number,Posodobi številko računa
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +42,Lead Owner cannot be same as the Lead,Svinec Lastnik ne more biti isto kot vodilni
-apps/erpnext/erpnext/accounts/utils.py +356,Allocated amount can not greater than unadjusted amount,Dodeljen znesek ne more večja od neprilagojene zneska
-DocType: Announcement,Receiver,sprejemnik
-apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,Workstation is closed on the following dates as per Holiday List: {0},Workstation je zaprt na naslednje datume kot na Holiday Seznam: {0}
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32,Opportunities,Priložnosti
-DocType: Lab Test Template,Single,Samski
-DocType: Salary Slip,Total Loan Repayment,Skupaj posojila Povračilo
-DocType: Account,Cost of Goods Sold,Nabavna vrednost prodanega blaga
-DocType: Subscription,Yearly,Letni
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230,Please enter Cost Center,Vnesite stroškovni center
-DocType: Drug Prescription,Dosage,Odmerjanje
-DocType: Journal Entry Account,Sales Order,Naročilo
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69,Avg. Selling Rate,Avg. Prodajni tečaj
-DocType: Assessment Plan,Examiner Name,Ime Examiner
-DocType: Lab Test Template,No Result,Ne Rezultat
-DocType: Purchase Invoice Item,Quantity and Rate,Količina in stopnja
-DocType: Delivery Note,% Installed,% nameščeno
-apps/erpnext/erpnext/utilities/user_progress.py +227,Classrooms/ Laboratories etc where lectures can be scheduled.,"Učilnice / Laboratories itd, kjer se lahko načrtovana predavanja."
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Please enter company name first,"Prosimo, da najprej vpišete ime podjetja"
-DocType: Purchase Invoice,Supplier Name,Dobavitelj Name
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25,Read the ERPNext Manual,Preberite priročnik ERPNext
-DocType: Purchase Invoice,01-Sales Return,01-Prodaja Vrnitev
-DocType: Account,Is Group,Is Group
-DocType: Email Digest,Pending Purchase Orders,Dokler naročilnice
-DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Samodejno nastavi Serijska št temelji na FIFO
-DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Preverite Dobavitelj Številka računa Edinstvenost
-apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34,Primary Address Details,Osnovni podatki o naslovu
-DocType: Vehicle Service,Oil Change,Menjava olja
-DocType: Asset Maintenance Log,Asset Maintenance Log,Dnevnik o vzdrževanju sredstev
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.','Do št. primera' ne more biti nižja od 'Od št. primera'
-DocType: Chapter,Non Profit,Non Profit
-DocType: Production Order,Not Started,Ni začelo
-DocType: Lead,Channel Partner,Channel Partner
-DocType: Account,Old Parent,Stara Parent
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19,Mandatory field - Academic Year,Obvezno polje - študijsko leto
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19,Mandatory field - Academic Year,Obvezno polje - študijsko leto
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +215,{0} {1} is not associated with {2} {3},{0} {1} ni povezan z {2} {3}
-DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,"Prilagodite uvodno besedilo, ki gre kot del te e-pošte. Vsaka transakcija ima ločeno uvodno besedilo."
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +174,Please set default payable account for the company {0},"Prosimo, nastavite privzeto se plača račun za podjetje {0}"
-DocType: Setup Progress Action,Min Doc Count,Min Doc Count
-apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Globalne nastavitve za vseh proizvodnih procesov.
-DocType: Accounts Settings,Accounts Frozen Upto,Računi Zamrznjena Stanuje
-DocType: SMS Log,Sent On,Pošlje On
-apps/erpnext/erpnext/stock/doctype/item/item.py +699,Attribute {0} selected multiple times in Attributes Table,Lastnost {0} izbrana večkrat v atributih tabeli
-DocType: HR Settings,Employee record is created using selected field. ,Evidenco o zaposlenih delavcih je ustvarjena s pomočjo izbrano polje.
-DocType: Sales Order,Not Applicable,Se ne uporablja
-apps/erpnext/erpnext/config/hr.py +70,Holiday master.,Upravnik praznikov
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +85,Opening Invoice Item,Odpiranje računa
-DocType: Request for Quotation Item,Required Date,Zahtevani Datum
-DocType: Delivery Note,Billing Address,Naslov za pošiljanje računa
-DocType: BOM,Costing,Stanejo
-DocType: Tax Rule,Billing County,County obračun
-DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Če je omogočeno, se bo štela za znesek davka, kot je že vključena v Print Oceni / Print Znesek"
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46,PieceRef,PieceRef
-DocType: Request for Quotation,Message for Supplier,Sporočilo za dobavitelja
-DocType: Driver,DRIVER-.#####,DRIVER -. #####
-DocType: Sales Invoice,Total Qty,Skupaj Kol
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Skrbnika2 E-ID
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Skrbnika2 E-ID
-DocType: Item,Show in Website (Variant),Prikaži na spletni strani (Variant)
-DocType: Employee,Health Concerns,Zdravje
-DocType: Payroll Entry,Select Payroll Period,Izberite izplačane Obdobje
-DocType: Purchase Invoice,Unpaid,Neplačan
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49,Reserved for sale,Rezervirano za prodajo
-DocType: Packing Slip,From Package No.,Od paketa No.
-DocType: Item Attribute,To Range,Da Domet
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29,Securities and Deposits,Vrednostne papirje in depozite
-apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","ne more spremeniti metode vrednotenja, kot so transakcije pred nekaj elementov, ki ga ne imeti svojo lastno metodo vrednotenja"
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82,Total leaves allocated is mandatory,Skupaj listi dodeljena je obvezna
-DocType: Patient,AB Positive,AB pozitivno
-DocType: Job Opening,Description of a Job Opening,Opis službo Otvoritev
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110,Pending activities for today,V čakanju na aktivnosti za danes
-apps/erpnext/erpnext/config/hr.py +24,Attendance record.,Šivih.
-DocType: Salary Structure,Salary Component for timesheet based payroll.,"Plača Komponenta za Timesheet na izplačane plače, ki temelji."
-DocType: Sales Order Item,Used for Production Plan,Uporablja se za proizvodnjo načrta
-DocType: Employee Loan,Total Payment,Skupaj plačila
-DocType: Manufacturing Settings,Time Between Operations (in mins),Čas med dejavnostmi (v minutah)
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +132,{0} {1} is cancelled so the action cannot be completed,"{0} {1} je preklican, dejanje ne more biti dokončano"
-DocType: Customer,Buyer of Goods and Services.,Kupec blaga in storitev.
-DocType: Journal Entry,Accounts Payable,Računi se plačuje
-DocType: Patient,Allergies,Alergije
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +33,The selected BOMs are not for the same item,Izbrani BOMs niso na isti točki
-DocType: Supplier Scorecard Standing,Notify Other,Obvesti drugo
-DocType: Vital Signs,Blood Pressure (systolic),Krvni tlak (sistolični)
-DocType: Pricing Rule,Valid Upto,Valid Stanuje
-DocType: Training Event,Workshop,Delavnica
-DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Opozori na naročila za nakup
-apps/erpnext/erpnext/utilities/user_progress.py +64,List a few of your customers. They could be organizations or individuals.,Naštejte nekaj vaših strank. Ti bi se lahko organizacije ali posamezniki.
-apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +23,Enough Parts to Build,Dovolj deli za izgradnjo
-DocType: POS Profile User,POS Profile User,POS profil uporabnika
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128,Direct Income,Neposredne dohodkovne
-DocType: Patient Appointment,Date TIme,Datum čas
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +45,"Can not filter based on Account, if grouped by Account","Filter ne more temeljiti na račun, če je združena s račun"
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130,Administrative Officer,Upravni uradnik
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39,Setting up company and taxes,Ustanovitev podjetja in davkov
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,Izberite tečaj
-DocType: Codification Table,Codification Table,Tabela kodifikacije
-DocType: Timesheet Detail,Hrs,Ur
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +349,Please select Company,"Prosimo, izberite Company"
-DocType: Stock Entry Detail,Difference Account,Razlika račun
-DocType: Purchase Invoice,Supplier GSTIN,Dobavitelj GSTIN
-apps/erpnext/erpnext/projects/doctype/task/task.py +47,Cannot close task as its dependant task {0} is not closed.,"Ne more blizu naloga, saj je njena odvisna Naloga {0} ni zaprt."
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +435,Please enter Warehouse for which Material Request will be raised,"Vnesite skladišče, za katere se bo dvignjeno Material Zahteva"
-DocType: Production Order,Additional Operating Cost,Dodatne operacijski stroškov
-DocType: Lab Test Template,Lab Routine,Lab Routine
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20,Cosmetics,Kozmetika
-apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18,Please select Completion Date for Completed Asset Maintenance Log,"Prosimo, izberite Datum zaključka za zaključen dnevnik vzdrževanja sredstev"
-apps/erpnext/erpnext/stock/doctype/item/item.py +551,"To merge, following properties must be same for both items","Za pripojitev, mora naslednje lastnosti biti enaka za oba predmetov"
-DocType: Shipping Rule,Net Weight,Neto teža
-DocType: Employee,Emergency Phone,Zasilna Telefon
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82,{0} {1} does not exist.,{0} {1} ne obstaja.
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,Nakup
-,Serial No Warranty Expiry,Zaporedna številka Garancija preteka
-DocType: Sales Invoice,Offline POS Name,Offline POS Ime
-apps/erpnext/erpnext/utilities/user_progress.py +177,Student Application,Študijska aplikacija
-apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,"Prosimo, določite stopnjo za praga 0%"
-apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,"Prosimo, določite stopnjo za praga 0%"
-DocType: Sales Order,To Deliver,Dostaviti
-DocType: Purchase Invoice Item,Item,Postavka
-apps/erpnext/erpnext/healthcare/setup.py +256,High Sensitivity,Visoka občutljivost
-apps/erpnext/erpnext/config/non_profit.py +48,Volunteer Type information.,Informacije o prostovoljcih.
-DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Predloga za preslikavo denarnega toka
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2539,Serial no item cannot be a fraction,Serijska št postavka ne more biti del
-DocType: Journal Entry,Difference (Dr - Cr),Razlika (Dr - Cr)
-DocType: Account,Profit and Loss,Dobiček in izguba
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +104,"Not permitted, configure Lab Test Template as required","Ni dovoljeno, če je potrebno, konfigurirate preskusno različico Lab Labels"
-DocType: Patient,Risk Factors,Dejavniki tveganja
-DocType: Patient,Occupational Hazards and Environmental Factors,Poklicne nevarnosti in dejavniki okolja
-DocType: Vital Signs,Respiratory rate,Stopnja dihanja
-apps/erpnext/erpnext/config/stock.py +334,Managing Subcontracting,Upravljanje Podizvajalci
-DocType: Vital Signs,Body Temperature,Temperatura telesa
-DocType: Project,Project will be accessible on the website to these users,Projekt bo na voljo na spletni strani teh uporabnikov
-DocType: Detected Disease,Disease,Bolezen
-apps/erpnext/erpnext/config/projects.py +24,Define Project type.,Določite vrsto projekta.
-DocType: Supplier Scorecard,Weighting Function,Tehtalna funkcija
-DocType: Physician,OP Consulting Charge,OP Consulting Charge
-apps/erpnext/erpnext/utilities/user_progress.py +25,Setup your ,Nastavite svoje
-DocType: Quotation,Rate at which Price list currency is converted to company's base currency,"Obrestna mera, po kateri Cenik valuti, se pretvori v osnovni valuti družbe"
-apps/erpnext/erpnext/setup/doctype/company/company.py +70,Account {0} does not belong to company: {1},Račun {0} ne pripada podjetju: {1}
-apps/erpnext/erpnext/setup/doctype/company/company.py +52,Abbreviation already used for another company,Kratica že uporabljena za druge družbe
-DocType: Selling Settings,Default Customer Group,Privzeta skupina kupcev
-DocType: Asset Repair,ARLOG-,ARLOG-
-DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Če onemogočiti, polje &quot;zaokrožena Skupaj &#39;ne bo viden v vsakem poslu"
-DocType: BOM,Operating Cost,Obratovalni stroški
-DocType: Crop,Produced Items,Proizvedeni elementi
-DocType: Sales Order Item,Gross Profit,Bruto dobiček
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,Prirastek ne more biti 0
-DocType: Company,Delete Company Transactions,Izbriši transakcije družbe
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +357,Reference No and Reference Date is mandatory for Bank transaction,Referenčna številka in referenčni datum je obvezna za banke transakcijo
-DocType: Purchase Receipt,Add / Edit Taxes and Charges,Dodaj / Uredi davkov in dajatev
-DocType: Payment Entry Reference,Supplier Invoice No,Dobavitelj Račun Ne
-DocType: Territory,For reference,Za sklic
-DocType: Healthcare Settings,Appointment Confirmation,Potrditev imenovanja
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"Cannot delete Serial No {0}, as it is used in stock transactions","Ne morem izbrisati Serijska št {0}, saj je uporabljen v transakcijah zalogi"
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +256,Closing (Cr),Zapiranje (Cr)
-apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1,Hello,Pozdravljeni
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118,Move Item,Move Item
-DocType: Serial No,Warranty Period (Days),Garancijski rok (dni)
-DocType: Installation Note Item,Installation Note Item,Namestitev Opomba Postavka
-DocType: Production Plan Item,Pending Qty,Pending Kol
-DocType: Budget,Ignore,Ignoriraj
-apps/erpnext/erpnext/accounts/party.py +397,{0} {1} is not active,{0} {1} ni aktiven
-apps/erpnext/erpnext/config/accounts.py +272,Setup cheque dimensions for printing,Preverite nastavitve za dimenzije za tiskanje
-DocType: Salary Slip,Salary Slip Timesheet,Plača Slip Timesheet
-apps/erpnext/erpnext/controllers/buying_controller.py +160,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dobavitelj Skladišče obvezno za podizvajalcev Potrdilo o nakupu
-DocType: Pricing Rule,Valid From,Velja od
-DocType: Sales Invoice,Total Commission,Skupaj Komisija
-DocType: Pricing Rule,Sales Partner,Prodaja Partner
-apps/erpnext/erpnext/config/buying.py +150,All Supplier scorecards.,Vse ocenjevalne table dobaviteljev.
-DocType: Buying Settings,Purchase Receipt Required,Potrdilo o nakupu Obvezno
-apps/erpnext/erpnext/stock/doctype/item/item.py +154,Valuation Rate is mandatory if Opening Stock entered,"Oceni Vrednotenje je obvezna, če je začel Odpiranje Stock"
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +143,No records found in the Invoice table,Ni najdenih v tabeli računa zapisov
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +34,Please select Company and Party Type first,Izberite podjetja in Zabava Vrsta najprej
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31,"Already set default in pos profile {0} for user {1}, kindly disabled default","Že nastavljeno privzeto v profilu pos {0} za uporabnika {1}, prijazno onemogočeno privzeto"
-apps/erpnext/erpnext/config/accounts.py +293,Financial / accounting year.,Finančni / računovodstvo leto.
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,nakopičene Vrednosti
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"Sorry, Serial Nos cannot be merged","Oprostite, Serijska št ni mogoče združiti"
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72,Territory is Required in POS Profile,Ozemlje je obvezno v profilu POS
-DocType: Supplier,Prevent RFQs,Preprečite RFQ-je
-apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Naredite Sales Order
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168,Salary Slip submitted for period from {0} to {1},Plačilo za plačilo je oddano za obdobje od {0} do {1}
-DocType: Project Task,Project Task,Project Task
-,Lead Id,ID Ponudbe
-DocType: C-Form Invoice Detail,Grand Total,Skupna vsota
-DocType: Assessment Plan,Course,Tečaj
-DocType: Timesheet,Payslip,Payslip
-apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,Točka košarico
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Fiskalna Leto Datum začetka ne sme biti večja od poslovnega leta End Datum
-DocType: Issue,Resolution,Ločljivost
-DocType: C-Form,IV,IV
-apps/erpnext/erpnext/templates/pages/order.html +76,Delivered: {0},Dobava: {0}
-DocType: Expense Claim,Payable Account,Plačljivo račun
-DocType: Payment Entry,Type of Payment,Vrsta plačila
-DocType: Sales Order,Billing and Delivery Status,Zaračunavanje in Delivery Status
-DocType: Job Applicant,Resume Attachment,Nadaljuj Attachment
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Ponovite Stranke
-DocType: Leave Control Panel,Allocate,Dodeli
-apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108,Create Variant,Ustvari varianto
-DocType: Sales Invoice,Shipping Bill Date,Datum pošiljanja
-DocType: Production Order,Production Plan,Načrt proizvodnje
-DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Odpiranje orodja za ustvarjanje računov
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +853,Sales Return,Prodaja Return
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96,Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,Opomba: Skupna dodeljena listi {0} ne sme biti manjši od že odobrene listov {1} za obdobje
-,Total Stock Summary,Skupaj Stock Povzetek
-DocType: Announcement,Posted By,Avtor
-DocType: Item,Delivered by Supplier (Drop Ship),Dostavi dobavitelja (Drop Ship)
-DocType: Healthcare Settings,Confirmation Message,Potrditveno sporočilo
-apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,Podatkovna baza potencialnih strank.
-DocType: Authorization Rule,Customer or Item,Stranka ali Artikel
-apps/erpnext/erpnext/config/selling.py +28,Customer database.,Baza podatkov o strankah.
-DocType: Quotation,Quotation To,Ponudba za
-DocType: Lead,Middle Income,Bližnji Prihodki
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +228,Opening (Cr),Odprtino (Cr)
-apps/erpnext/erpnext/stock/doctype/item/item.py +871,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.,"Privzeto mersko enoto za postavko {0} ni mogoče neposredno spremeniti, ker ste že naredili nekaj transakcije (-e) z drugo UOM. Boste morali ustvariti nov element, da uporabi drugačno Privzeti UOM."
-apps/erpnext/erpnext/accounts/utils.py +354,Allocated amount can not be negative,Dodeljen znesek ne more biti negativna
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Nastavite Company
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Nastavite Company
-DocType: Share Balance,Share Balance,Deljeno stanje
-DocType: Purchase Order Item,Billed Amt,Bremenjenega Amt
-DocType: Training Result Employee,Training Result Employee,Usposabljanje Rezultat zaposlenih
-DocType: Warehouse,A logical Warehouse against which stock entries are made.,"Logično Warehouse, zoper katerega so narejeni vnosov zalog."
-DocType: Repayment Schedule,Principal Amount,glavni Znesek
-DocType: Employee Loan Application,Total Payable Interest,Skupaj plačljivo Obresti
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +60,Total Outstanding: {0},Skupno izjemno: {0}
-DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Prodaja Račun Timesheet
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118,Reference No & Reference Date is required for {0},Referenčna št &amp; Referenčni datum je potrebna za {0}
-DocType: Payroll Entry,Select Payment Account to make Bank Entry,"Izberite Plačilo računa, da bo Bank Entry"
-DocType: Hotel Settings,Default Invoice Naming Series,Privzeto imenovanje računov
-apps/erpnext/erpnext/utilities/activation.py +136,"Create Employee records to manage leaves, expense claims and payroll","Ustvarjanje zapisov zaposlencev za upravljanje listje, odhodkov terjatev in na izplačane plače"
-DocType: Restaurant Reservation,Restaurant Reservation,Rezervacija restavracij
-DocType: Land Unit,Land Unit Name,Ime enote zemljišča
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190,Proposal Writing,Predlog Pisanje
-DocType: Payment Entry Deduction,Payment Entry Deduction,Plačilo Začetek odštevanja
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14,Wrapping up,Zavijanje
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35,Notify Customers via Email,Obvesti stranke po e-pošti
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,Obstaja še ena Sales Oseba {0} z enako id zaposlenih
-DocType: Employee Advance,Claimed Amount,Zahtevani znesek
-apps/erpnext/erpnext/config/education.py +176,Masters,Masters
-DocType: Assessment Plan,Maximum Assessment Score,Najvišja ocena Ocena
-apps/erpnext/erpnext/config/accounts.py +138,Update Bank Transaction Dates,Update banka transakcijske Termini
-apps/erpnext/erpnext/config/projects.py +36,Time Tracking,sledenje čas
-DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DVOJNIK ZA TRANSPORTER
-apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49,Row {0}# Paid Amount cannot be greater than requested advance amount,Vrstica {0} # Plačan znesek ne sme biti večji od zahtevanega zneska predplačila
-DocType: Fiscal Year Company,Fiscal Year Company,Fiskalna Leto Company
-DocType: Packing Slip Item,DN Detail,DN Detail
-DocType: Training Event,Conference,Konferenca
-DocType: Timesheet,Billed,Zaračunavajo
-DocType: Batch,Batch Description,Serija Opis
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Ustvarjanje študentskih skupin
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Ustvarjanje študentskih skupin
-apps/erpnext/erpnext/accounts/utils.py +727,"Payment Gateway Account not created, please create one manually.","Plačilo Gateway računa ni ustvaril, si ustvariti ročno."
-DocType: Supplier Scorecard,Per Year,Letno
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,Ni upravičen do sprejema v tem programu kot na DOB
-DocType: Sales Invoice,Sales Taxes and Charges,Prodajne Davki in dajatve
-DocType: Employee,Organization Profile,Organizacija Profil
-DocType: Vital Signs,Height (In Meter),Višina (v metrih)
-DocType: Student,Sibling Details,sorodstvena Podrobnosti
-DocType: Vehicle Service,Vehicle Service,servis vozila
-apps/erpnext/erpnext/config/setup.py +101,Automatically triggers the feedback request based on conditions.,"Samodejno sproži zahteva povratne informacije, ki temeljijo na pogojih."
-DocType: Employee,Reason for Resignation,Razlog za odstop
-apps/erpnext/erpnext/config/hr.py +152,Template for performance appraisals.,Predloga za izvajanje cenitve.
-DocType: Sales Invoice,Credit Note Issued,Credit Note Izdano
-DocType: Project Task,Weight,Teža
-DocType: Payment Reconciliation,Invoice/Journal Entry Details,Račun / Journal Entry Podrobnosti
-apps/erpnext/erpnext/accounts/utils.py +83,{0} '{1}' not in Fiscal Year {2},{0} {1} &quot;ni v proračunskem letu {2}
-DocType: Buying Settings,Settings for Buying Module,Nastavitve za modul nabava
-apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21,Asset {0} does not belong to company {1},Sredstvo {0} ne pripada družbi {1}
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70,Please enter Purchase Receipt first,"Prosimo, da najprej vnesete Potrdilo o nakupu"
-DocType: Buying Settings,Supplier Naming By,Dobavitelj Imenovanje Z
-DocType: Activity Type,Default Costing Rate,Privzeto Costing Rate
-DocType: Maintenance Schedule,Maintenance Schedule,Vzdrževanje Urnik
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Potem Označevanje cen Pravila se filtrirajo temeljijo na stranke, skupine kupcev, ozemlje, dobavitelja, dobavitelj Type, kampanje, prodajnemu partnerju itd"
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +29,Net Change in Inventory,Neto sprememba v popisu
-apps/erpnext/erpnext/config/hr.py +162,Employee Loan Management,Posojilo Employee Management
-DocType: Employee,Passport Number,Številka potnega lista
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Povezava z skrbnika2
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124,Manager,Manager
-DocType: Payment Entry,Payment From / To,Plačilo Od / Do
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +177,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Nova kreditna meja je nižja od trenutne neporavnani znesek za stranko. Kreditno linijo mora biti atleast {0}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +428,Please set account in Warehouse {0},Nastavite račun v Galeriji {0}
-apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,"""Na podlagi"" in ""Združi po"" ne more biti enaka"
-DocType: Sales Person,Sales Person Targets,Prodaja Osebni cilji
-DocType: Installation Note,IN-,TEKMOVANJU
-DocType: Production Order Operation,In minutes,V minutah
-DocType: Issue,Resolution Date,Resolucija Datum
-DocType: Lab Test Template,Compound,Spojina
-DocType: Student Batch Name,Batch Name,serija Ime
-DocType: Fee Validity,Max number of visit,Največje število obiska
-,Hotel Room Occupancy,Hotelske sobe
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +358,Timesheet created:,Timesheet ustvaril:
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +931,Please set default Cash or Bank account in Mode of Payment {0},"Prosim, nastavite privzeto gotovinski ali bančni račun v načinu plačevanja {0}"
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24,Enroll,včlanite se
-DocType: GST Settings,GST Settings,GST Nastavitve
-DocType: Selling Settings,Customer Naming By,Stranka Imenovanje Z
-DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,"Bo pokazal študenta, kot so v Študentski Mesečno poročilo navzočih"
-DocType: Depreciation Schedule,Depreciation Amount,Amortizacija Znesek
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56,Convert to Group,Pretvarjanje skupini
-DocType: Delivery Trip,TOUR-.#####,TOUR -. #####
-DocType: Activity Cost,Activity Type,Vrsta dejavnosti
-DocType: Request for Quotation,For individual supplier,Za posameznega dobavitelja
-DocType: BOM Operation,Base Hour Rate(Company Currency),Osnovna urni tečaj (družba Valuta)
-apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,Delivered Znesek
-DocType: Quotation Item,Item Balance,Bilančne postavke
-DocType: Sales Invoice,Packing List,Seznam pakiranja
-apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Naročila dati dobaviteljev.
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43,Publishing,Založništvo
-DocType: Accounts Settings,Report Settings,Poročanje nastavitev
-DocType: Activity Cost,Projects User,Projekti Uporabnik
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,Porabljeno
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158,{0}: {1} not found in Invoice Details table,{0}: {1} ni mogoče najti v tabeli podrobnosti računov
-DocType: Asset,Asset Owner Company,Družba z lastniki sredstev
-DocType: Company,Round Off Cost Center,Zaokrožen stroškovni center
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Vzdrževanje obisk {0} je treba odpovedati pred preklicem te Sales Order
-DocType: Asset Maintenance Log,AML-,AML-
-DocType: Item,Material Transfer,Prenos materialov
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24,Could not find path for ,Pot ni mogla najti
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +221,Opening (Dr),Odprtje (Dr)
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39,Posting timestamp must be after {0},Napotitev žig mora biti po {0}
-apps/erpnext/erpnext/config/accounts.py +39,To make recurring documents,Za ponavljajoče se dokumente
-,GST Itemised Purchase Register,DDV Razčlenjeni Nakup Registracija
-DocType: Course Scheduling Tool,Reschedule,Ponovni premik
-DocType: Employee Loan,Total Interest Payable,Skupaj Obresti plačljivo
-DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Iztovorjeni stroškov Davki in prispevki
-DocType: Production Order Operation,Actual Start Time,Actual Start Time
-DocType: BOM Operation,Operation Time,Operacija čas
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +316,Finish,Finish
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412,Base,Osnovna
-DocType: Timesheet,Total Billed Hours,Skupaj Obračunane ure
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1526,Write Off Amount,Napišite enkratnem znesku
-DocType: Leave Block List Allow,Allow User,Dovoli Uporabnik
-DocType: Journal Entry,Bill No,Bill Ne
-DocType: Company,Gain/Loss Account on Asset Disposal,Dobiček / izguba račun o odlaganju sredstev
-DocType: Vehicle Log,Service Details,storitev Podrobnosti
-DocType: Vehicle Log,Service Details,storitev Podrobnosti
-DocType: Subscription,Quarterly,Četrtletno
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +47,EcritureLib,EcritureLib
-DocType: Lab Test Template,Grouped,Združeno
-DocType: Selling Settings,Delivery Note Required,Dostava Opomba Obvezno
-DocType: Bank Guarantee,Bank Guarantee Number,Bančna garancija Število
-DocType: Bank Guarantee,Bank Guarantee Number,Bančna garancija Število
-DocType: Assessment Criteria,Assessment Criteria,Merila ocenjevanja
-DocType: BOM Item,Basic Rate (Company Currency),Basic Rate (družba Valuta)
-DocType: Student Attendance,Student Attendance,študent Udeležba
-DocType: Sales Invoice Timesheet,Time Sheet,čas Sheet
-DocType: Manufacturing Settings,Backflush Raw Materials Based On,"Backflush Surovine, ki temelji na"
-DocType: Sales Invoice,Port Code,Pristaniška koda
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +948,Reserve Warehouse,Rezervno skladišče
-DocType: Lead,Lead is an Organization,Svinec je organizacija
-DocType: Guardian Interest,Interest,Obresti
-apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,pre Sales
-DocType: Instructor Log,Other Details,Drugi podatki
-apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,suplier
-DocType: Lab Test,Test Template,Preskusna predloga
-DocType: Restaurant Order Entry Item,Served,Servirano
-apps/erpnext/erpnext/config/non_profit.py +13,Chapter information.,Podatki o poglavju.
-DocType: Account,Accounts,Računi
-DocType: Vehicle,Odometer Value (Last),Vrednost števca (Zadnja)
-apps/erpnext/erpnext/config/buying.py +160,Templates of supplier scorecard criteria.,Predloge meril uspešnosti dobaviteljev.
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109,Marketing,Trženje
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +290,Payment Entry is already created,Začetek Plačilo je že ustvarjena
-DocType: Request for Quotation,Get Suppliers,Pridobite dobavitelje
-DocType: Purchase Receipt Item Supplied,Current Stock,Trenutna zaloga
-apps/erpnext/erpnext/controllers/accounts_controller.py +609,Row #{0}: Asset {1} does not linked to Item {2},Row # {0}: Asset {1} ni povezana s postavko {2}
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394,Preview Salary Slip,Predogled Plača listek
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54,Account {0} has been entered multiple times,Račun {0} je bil vpisan večkrat
-DocType: Account,Expenses Included In Valuation,Stroški Vključeno v vrednotenju
-apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +37,You can only renew if your membership expires within 30 days,"Obnovite lahko le, če vaše članstvo poteče v 30 dneh"
-DocType: Land Unit,Longitude,Dolžina
-,Absent Student Report,Odsoten Student Report
-DocType: Crop,Crop Spacing UOM,UOM razmika rastlin
-DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,"Izberite samo, če imate nastavljene dokumente o denarnem toku Mapper"
-DocType: Email Digest,Next email will be sent on:,Naslednje sporočilo bo poslano na:
-DocType: Supplier Scorecard,Per Week,Tedensko
-apps/erpnext/erpnext/stock/doctype/item/item.py +665,Item has variants.,Element ima variante.
-apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Skupaj študent
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,Postavka {0} ni bilo mogoče najti
-DocType: Bin,Stock Value,Stock Value
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +42,Fee records will be created in the background. In case of any error the error message will be updated in the Schedule.,Zapisi o plačilih bodo ustvarjeni v ozadju. V primeru napake se sporočilo o napaki posodablja na seznamu.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +239,Company {0} does not exist,Podjetje {0} ne obstaja
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40,{0} has fee validity till {1},{0} ima veljavnost pristojbine {1}
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +57,Tree Type,Tree Type
-DocType: BOM Explosion Item,Qty Consumed Per Unit,Količina porabljene na enoto
-DocType: GST Account,IGST Account,Račun IGST
-DocType: Serial No,Warranty Expiry Date,Garancija Datum preteka
-DocType: Material Request Item,Quantity and Warehouse,Količina in skladišča
-DocType: Hub Settings,Unregister,Odjavite se
-DocType: Sales Invoice,Commission Rate (%),Komisija Stopnja (%)
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,Izberite program
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,Izberite program
-DocType: Project,Estimated Cost,Ocenjeni strošek
-DocType: Purchase Order,Link to material requests,Povezava na materialne zahteve
-DocType: Hub Settings,Publish,Objavi
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7,Aerospace,Aerospace
-,Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC]
-DocType: Journal Entry,Credit Card Entry,Začetek Credit Card
-apps/erpnext/erpnext/config/accounts.py +57,Company and Accounts,Podjetje in računi
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70,In Value,v vrednosti
-DocType: Asset Settings,Depreciation Options,Možnosti amortizacije
-apps/erpnext/erpnext/utilities/transaction_base.py +35,Invalid Posting Time,Neveljaven čas pošiljanja
-DocType: Lead,Campaign Name,Ime kampanje
-DocType: Hotel Room,Capacity,Zmogljivost
-DocType: Selling Settings,Close Opportunity After Days,Zapri Priložnost Po dnevih
-,Reserved,Rezervirano
-DocType: Driver,License Details,Podrobnosti o licenci
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +85,The field From Shareholder cannot be blank,Polje Od delničarja ne more biti prazno
-DocType: Purchase Order,Supply Raw Materials,Oskrba z Surovine
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Kratkoročna sredstva
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +108,{0} is not a stock Item,{0} ni zaloge artikla
-apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',"Pošljite povratne informacije o usposabljanju, tako da kliknete »Povratne informacije o usposabljanju« in nato »Novo«,"
-DocType: Mode of Payment Account,Default Account,Privzeti račun
-apps/erpnext/erpnext/stock/doctype/item/item.py +272,Please select Sample Retention Warehouse in Stock Settings first,Najprej izberite skladišče za shranjevanje vzorcev v nastavitvah zalog
-DocType: Payment Entry,Received Amount (Company Currency),Prejela znesek (družba Valuta)
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,Lead must be set if Opportunity is made from Lead,"Svinec je treba določiti, če je priložnost narejen iz svinca"
-apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29,Please select weekly off day,"Prosimo, izberite tedensko off dan"
-DocType: Patient,O Negative,O Negativno
-DocType: Production Order Operation,Planned End Time,Načrtovano Končni čas
-,Sales Person Target Variance Item Group-Wise,Prodaja Oseba Target Varianca Postavka Group-Wise
-apps/erpnext/erpnext/accounts/doctype/account/account.py +93,Account with existing transaction cannot be converted to ledger,Račun z obstoječim poslom ni mogoče pretvoriti v knjigo terjatev
-apps/erpnext/erpnext/config/non_profit.py +33,Memebership Type Details,Podatki o tipu memebership
-DocType: Delivery Note,Customer's Purchase Order No,Stranke Naročilo Ne
-DocType: Budget,Budget Against,proračun proti
-DocType: Employee,Cell Number,Število celic
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +445,There's no employee for the given criteria. Check that Salary Slips have not already been created.,"Za določena merila ni nobenega zaposlenega. Preverite, da plačilne liste še niso bile ustvarjene."
-apps/erpnext/erpnext/stock/reorder_item.py +194,Auto Material Requests Generated,Auto Material Zahteve Izdelano
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,Lost
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152,You can not enter current voucher in 'Against Journal Entry' column,"Ne, ne more vstopiti trenutno bon v &quot;Proti listu vstopa&quot; stolpcu"
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Rezervirano za proizvodnjo
-DocType: Soil Texture,Sand,Pesek
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25,Energy,Energy
-DocType: Opportunity,Opportunity From,Priložnost Od
-apps/erpnext/erpnext/config/hr.py +98,Monthly salary statement.,Mesečno poročilo o izplačanih plačah.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +887,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,"Vrstica {0}: {1} Serijske številke, potrebne za postavko {2}. Dali ste {3}."
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79,Please select a table,Izberite tabelo
-DocType: BOM,Website Specifications,Spletna Specifikacije
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78,{0} is an invalid email address in 'Recipients',{0} je neveljaven e-poštni naslov med »Prejemniki«
-DocType: Special Test Items,Particulars,Podrobnosti
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24,{0}: From {0} of type {1},{0}: Od {0} tipa {1}
-DocType: Warranty Claim,CI-,Ci
-apps/erpnext/erpnext/controllers/buying_controller.py +310,Row {0}: Conversion Factor is mandatory,Vrstica {0}: Factor Pretvorba je obvezna
-DocType: Student,A+,A +
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +344,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Več Cena Pravila obstaja z enakimi merili, se rešujejo spore z dodelitvijo prednost. Cena Pravila: {0}"
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +514,Cannot deactivate or cancel BOM as it is linked with other BOMs,Ne more izključiti ali preklicati BOM saj je povezan z drugimi BOMs
-DocType: Asset,Maintenance,Vzdrževanje
-DocType: Item Attribute Value,Item Attribute Value,Postavka Lastnost Vrednost
-DocType: Item,Maximum sample quantity that can be retained,"Največja količina vzorca, ki jo je mogoče obdržati"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +405,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Vrstice {0} # Element {1} ni mogoče prenesti več kot {2} proti naročilnici {3}
-apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Prodajne akcije.
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +117,Make Timesheet,Ustvari evidenco prisotnosti
-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 predlogo, ki se lahko uporablja za vse prodajne transakcije. To predlogo lahko vsebuje seznam davčnih glavami in tudi druge glave strošek / dohodki, kot so &quot;Shipping&quot;, &quot;zavarovanje&quot;, &quot;Ravnanje&quot; itd #### Opomba davčno stopnjo, ki jo določite tu bo standard davčna stopnja za vse ** Postavke **. Če obstajajo ** Items **, ki imajo različne stopnje, ki jih je treba dodati v ** Element davku ** miza v ** Element ** mojstra. #### Opis Stolpci 1. Vrsta Izračun: - To je lahko na ** Net Total ** (to je vsota osnovnega zneska). - ** Na prejšnje vrstice Total / Znesek ** (za kumulativnih davkov ali dajatev). Če izberete to možnost, bo davek treba uporabiti kot odstotek prejšnje vrstice (davčne tabele) znesek ali skupaj. - ** Dejanska ** (kot je omenjeno). 2. Račun Head: The knjiga račun, pod katerimi se bodo rezervirana ta davek 3. stroškovni center: Če davek / pristojbina je prihodek (kot ladijski promet) ali odhodek je treba rezervirana proti centru stroškov. 4. Opis: Opis davka (bo, da se natisne v faktur / narekovajev). 5. stopnja: Davčna stopnja. 6. Znesek: Davčna znesek. 7. Skupaj: Kumulativno do te točke. 8. Vnesite Row: Če je na osnovi &quot;Prejšnji Row Total&quot; lahko izberete številko vrstice, ki bo sprejet kot osnova za ta izračun (privzeta je prejšnja vrstica). 9. Ali je to DDV vključen v osnovni stopnji ?: Če preverite to, to pomeni, da ta davek ne bo prikazan pod tabelo postavk, vendar bodo vključeni v osnovne stopnje v svoji glavni element tabele. To je uporabno, kadar želite dati ravno ceno (vključno z vsemi davki) ceno za kupce."
-DocType: Employee,Bank A/C No.,Bank A / C No.
-DocType: Bank Guarantee,Project,Projekt
-DocType: Quality Inspection Reading,Reading 7,Branje 7
-apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9,Partially Ordered,delno Ž
-DocType: Lab Test,Lab Test,Lab Test
-DocType: Expense Claim Detail,Expense Claim Type,Expense Zahtevek Type
-DocType: Shopping Cart Settings,Default settings for Shopping Cart,Privzete nastavitve za Košarica
-apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +26,Add Timeslots,Dodaj Timeslots
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Sredstvo izločeni preko Journal Entry {0}
-DocType: Employee Loan,Interest Income Account,Prihodki od obresti račun
-apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58,Review Invitation Sent,Povabljeni vabilo
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13,Biotechnology,Biotehnologija
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Office Maintenance Expenses,Pisarniška Vzdrževanje Stroški
-apps/erpnext/erpnext/utilities/user_progress.py +51,Go to ,Pojdi do
-apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Nastavitev e-poštnega računa
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21,Please enter Item first,"Prosimo, da najprej vnesete artikel"
-DocType: Asset Repair,Downtime,Odmore
-DocType: Account,Liability,Odgovornost
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +218,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankcionirano Znesek ne sme biti večja od škodnega Znesek v vrstici {0}.
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Academic Term: ,Akademski izraz:
-DocType: Salary Detail,Do not include in total,Ne vključite v celoti
-DocType: Company,Default Cost of Goods Sold Account,Privzeto Nabavna vrednost prodanega blaga račun
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1005,Sample quantity {0} cannot be more than received quantity {1},Količina vzorca {0} ne sme biti večja od prejete količine {1}
-apps/erpnext/erpnext/stock/get_item_details.py +369,Price List not selected,Cenik ni izbrana
-DocType: Employee,Family Background,Družina Ozadje
-DocType: Request for Quotation Supplier,Send Email,Pošlji e-pošto
-apps/erpnext/erpnext/stock/doctype/item/item.py +227,Warning: Invalid Attachment {0},Opozorilo: Invalid Attachment {0}
-DocType: Item,Max Sample Quantity,Max vzorčna količina
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +766,No Permission,Ne Dovoljenje
-DocType: Vital Signs,Heart Rate / Pulse,Srčni utrip / pulz
-DocType: Company,Default Bank Account,Privzeti bančni račun
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +59,"To filter based on Party, select Party Type first","Za filtriranje, ki temelji na stranke, da izberete Party Vnesite prvi"
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48,'Update Stock' can not be checked because items are not delivered via {0},"'Posodobi zalogo' ne more biti izbrano, saj artikli niso dostavljeni prek {0}"
-DocType: Vehicle,Acquisition Date,pridobitev Datum
-apps/erpnext/erpnext/utilities/user_progress.py +143,Nos,Nos
-DocType: Item,Items with higher weightage will be shown higher,Postavke z višjo weightage bo prikazan višje
-apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests and Vital Signs,Laboratorijski testi in vitalni znaki
-DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Banka Sprava Detail
-apps/erpnext/erpnext/controllers/accounts_controller.py +613,Row #{0}: Asset {1} must be submitted,Row # {0}: Asset {1} je treba predložiti
-apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,Najdenih ni delavec
-DocType: Subscription,Stopped,Ustavljen
-DocType: Item,If subcontracted to a vendor,Če podizvajanje prodajalca
-apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111,Student Group is already updated.,Študent Skupina je že posodobljen.
-apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111,Student Group is already updated.,Študent Skupina je že posodobljen.
-DocType: SMS Center,All Customer Contact,Vse Customer Contact
-DocType: Land Unit,Tree Details,drevo Podrobnosti
-DocType: Training Event,Event Status,Status dogodek
-DocType: Volunteer,Availability Timeslot,Razpoložljivost Timeslot
-,Support Analytics,Podpora Analytics
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +352,"If you have any questions, please get back to us.","Če imate kakršnakoli vprašanja, vas prosimo, da nazaj k nam."
-DocType: Cash Flow Mapper,Cash Flow Mapper,Mapper za denarni tok
-DocType: Item,Website Warehouse,Spletna stran Skladišče
-DocType: Payment Reconciliation,Minimum Invoice Amount,Minimalna Znesek računa
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Stroškovno mesto {2} ne pripada družbi {3}
-apps/erpnext/erpnext/utilities/user_progress.py +89,Upload your letter head (Keep it web friendly as 900px by 100px),Naložite glavo glave (ohranite spletno prijazen kot 900 slikovnih pik za 100 pik)
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88,{0} {1}: Account {2} cannot be a Group,{0} {1}: račun {2} ne more biti skupina
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table,Točka Row {idx} {DOCTYPE} {DOCNAME} ne obstaja v zgoraj &#39;{DOCTYPE} &quot;tabela
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +295,Timesheet {0} is already completed or cancelled,"Timesheet {0}, je že končana ali preklicana"
-apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,ni opravil
-DocType: Item Variant Settings,Copy Fields to Variant,Kopiraj polja v Variant
-DocType: Asset,Opening Accumulated Depreciation,Odpiranje nabrano amortizacijo
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49,Score must be less than or equal to 5,Rezultat mora biti manjša od ali enaka 5
-DocType: Program Enrollment Tool,Program Enrollment Tool,Program Vpis orodje
-apps/erpnext/erpnext/config/accounts.py +335,C-Form records,Zapisi C-Form
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +73,The shares already exist,Delnice že obstajajo
-apps/erpnext/erpnext/config/selling.py +311,Customer and Supplier,Kupec in dobavitelj
-DocType: Email Digest,Email Digest Settings,E-pošta Digest Nastavitve
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +354,Thank you for your business!,Hvala za vaš posel!
-apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Podpora poizvedbe strank.
-DocType: Setup Progress Action,Action Doctype,Dejanje Doctype
-,Production Order Stock Report,Proizvodnja Poročilo o naročilu Stock
-DocType: HR Settings,Retirement Age,upokojitvena starost
-DocType: Bin,Moving Average Rate,Moving Average Rate
-DocType: Production Plan,Select Items,Izberite Items
-DocType: Share Transfer,To Shareholder,Za delničarja
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372,{0} against Bill {1} dated {2},{0} za Račun {1} z dne {2}
-apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Institution,Namestitvena ustanova
-DocType: Program Enrollment,Vehicle/Bus Number,Vozila / Bus številka
-apps/erpnext/erpnext/education/doctype/course/course.js +17,Course Schedule,Razpored za golf
-DocType: Request for Quotation Supplier,Quote Status,Citiraj stanje
-DocType: Maintenance Visit,Completion Status,Zaključek Status
-DocType: Daily Work Summary Group,Select Users,Izberite Uporabniki
-DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,Postavka hotelske sobe
-DocType: HR Settings,Enter retirement age in years,Vnesite upokojitveno starost v letih
-DocType: Crop,Target Warehouse,Ciljna Skladišče
-DocType: Payroll Employee Detail,Payroll Employee Detail,Detajl zaposlenih zaposlenih
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128,Please select a warehouse,Izberite skladišče
-DocType: Cheque Print Template,Starting location from left edge,Izhajajoč lokacijo od levega roba
-DocType: Item,Allow over delivery or receipt upto this percent,Dovoli nad dostavo ali prejem upto tem odstotkov
-DocType: Stock Entry,STE-,STE-
-DocType: Upload Attendance,Import Attendance,Uvoz Udeležba
-apps/erpnext/erpnext/public/js/pos/pos.html +113,All Item Groups,Vse Postavka Skupine
-apps/erpnext/erpnext/config/setup.py +89,Automatically compose message on submission of transactions.,Samodejno sestavite sporočilo o predložitvi transakcij.
-DocType: Production Order,Item To Manufacture,Postavka za izdelavo
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44,CompteLib,CompteLib
-apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} status {2}
-DocType: Water Analysis,Collection Temperature ,Zbirna temperatura
-DocType: Employee,Provide Email Address registered in company,Navedite e-poštni naslov je registriran v podjetju
-DocType: Shopping Cart Settings,Enable Checkout,Omogoči Checkout
-apps/erpnext/erpnext/config/learn.py +202,Purchase Order to Payment,Nakup naročila do plačila
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Predvidoma Kol
-DocType: Sales Invoice,Payment Due Date,Datum zapadlosti
-DocType: Drug Prescription,Interval UOM,Interval UOM
-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.js +492,Item Variant {0} already exists with same attributes,Postavka Variant {0} že obstaja z enakimi atributi
-DocType: Item,Hub Publishing Details,Podrobnosti o objavi vozlišča
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +114,'Opening',&quot;Odpiranje&quot;
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Odpri storiti
-DocType: Notification Control,Delivery Note Message,Dostava Opomba Sporočilo
-DocType: Lab Test Template,Result Format,Format zapisa
-DocType: Expense Claim,Expenses,Stroški
-DocType: Item Variant Attribute,Item Variant Attribute,Postavka Variant Lastnost
-,Purchase Receipt Trends,Nakup Prejem Trendi
-DocType: Payroll Entry,Bimonthly,vsaka dva meseca
-DocType: Vehicle Service,Brake Pad,Brake Pad
-DocType: Fertilizer,Fertilizer Contents,Vsebina gnojil
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119,Research & Development,Raziskave in razvoj
-apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Znesek za Bill
-DocType: Company,Registration Details,Podrobnosti registracije
-DocType: Timesheet,Total Billed Amount,Skupaj zaračunano Znesek
-DocType: Item Reorder,Re-Order Qty,Ponovno naročila Kol
-DocType: Leave Block List Date,Leave Block List Date,Pustite Block List Datum
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +93,BOM #{0}: Raw material cannot be same as main Item,BOM # {0}: Surovina ne more biti enaka kot glavna postavka
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +92,Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Skupaj veljavnih cenah na Potrdilo o nakupu postavke tabele mora biti enaka kot Skupaj davkov in dajatev
-DocType: Sales Team,Incentives,Spodbude
-DocType: SMS Log,Requested Numbers,Zahtevane številke
-DocType: Volunteer,Evening,Večer
-DocType: Customer,Bypass credit limit check at Sales Order,Obvezno preverjanje kreditne omejitve pri prodajni nalogi
-apps/erpnext/erpnext/config/hr.py +147,Performance appraisal.,Cenitev uspešnosti.
-apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +99,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Omogočanje &quot;uporabiti za košarico&quot;, kot je omogočeno Košarica in da mora biti vsaj ena Davčna pravilo za Košarica"
-apps/erpnext/erpnext/controllers/accounts_controller.py +411,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Plačilo Začetek {0} je povezan proti odredbi {1}, preverite, če je treba izvleči, kot prej v tem računu."
-DocType: Sales Invoice Item,Stock Details,Stock Podrobnosti
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Project Value
-apps/erpnext/erpnext/config/selling.py +321,Point-of-Sale,Prodajno mesto
-DocType: Fee Schedule,Fee Creation Status,Status ustvarjanja provizije
-DocType: Vehicle Log,Odometer Reading,Stanje kilometrov
-apps/erpnext/erpnext/accounts/doctype/account/account.py +116,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Stanje na računu je že v ""kredit"", ni dovoljeno nastaviti ""Stanje mora biti"" kot ""bremenitev"""
-DocType: Account,Balance must be,Ravnotežju mora biti
-DocType: Hub Settings,Publish Pricing,Objavite Pricing
-DocType: Notification Control,Expense Claim Rejected Message,Expense zahtevek zavrnjen Sporočilo
-,Available Qty,Na voljo Količina
-DocType: Purchase Taxes and Charges,On Previous Row Total,Na prejšnje vrstice Skupaj
-DocType: Purchase Invoice Item,Rejected Qty,zavrnjen Kol
-DocType: Setup Progress Action,Action Field,Polje delovanja
-DocType: Healthcare Settings,Manage Customer,Upravljajte stranko
-DocType: Delivery Trip,Delivery Stops,Dobavni izklopi
-DocType: Salary Slip,Working Days,Delovni dnevi
-DocType: Serial No,Incoming Rate,Dohodni Rate
-DocType: Packing Slip,Gross Weight,Bruto Teža
-,Final Assessment Grades,Končne ocene
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47,Enable Hub,Omogoči Hub
-apps/erpnext/erpnext/public/js/setup_wizard.js +110,The name of your company for which you are setting up this system.,"Ime vašega podjetja, za katero ste vzpostavitvijo tega sistema."
-DocType: HR Settings,Include holidays in Total no. of Working Days,Vključi počitnice v Total no. delovnih dni
-apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108,Setup your Institute in ERPNext,Nastavite svoj inštitut v ERPNext
-DocType: Agriculture Analysis Criteria,Plant Analysis,Analiza rastlin
-DocType: Job Applicant,Hold,Drži
-DocType: Employee,Date of Joining,Datum pridružitve
-DocType: Naming Series,Update Series,Posodobi zaporedje
-DocType: Supplier Quotation,Is Subcontracted,Je v podizvajanje
-DocType: Restaurant Table,Minimum Seating,Najmanjše število sedežev
-DocType: Item Attribute,Item Attribute Values,Postavka Lastnost Vrednote
-DocType: Examination Result,Examination Result,Preizkus Rezultat
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +845,Purchase Receipt,Potrdilo o nakupu
-,Received Items To Be Billed,Prejete Postavke placevali
-apps/erpnext/erpnext/config/accounts.py +303,Currency exchange rate master.,Menjalnega tečaja valute gospodar.
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +204,Reference Doctype must be one of {0},Referenčna DOCTYPE mora biti eden od {0}
-apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js +46,Filter Total Zero Qty,Filter Total Zero Qty
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +341,Unable to find Time Slot in the next {0} days for Operation {1},Ni mogoče najti terminu v naslednjih {0} dni za delovanje {1}
-DocType: Production Order,Plan material for sub-assemblies,Plan material za sklope
-apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,Prodajni partnerji in ozemelj
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +595,BOM {0} must be active,BOM {0} mora biti aktiven
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +409,No Items available for transfer,Ni razpoložljivih elementov za prenos
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +218,Closing (Opening + Total),Zapiranje (odpiranje + skupno)
-DocType: Journal Entry,Depreciation Entry,Amortizacija Začetek
-apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32,Please select the document type first,"Prosimo, najprej izberite vrsto dokumenta"
-apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Preklic Material Obiski {0} pred preklicem to vzdrževanje obisk
-DocType: Crop Cycle,ISO 8016 standard,ISO 8016 standard
-DocType: Pricing Rule,Rate or Discount,Stopnja ali popust
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,Serial No {0} does not belong to Item {1},Serijska št {0} ne pripada postavki {1}
-DocType: Purchase Receipt Item Supplied,Required Qty,Zahtevani Kol
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +127,Warehouses with existing transaction can not be converted to ledger.,Skladišča z obstoječim poslom ni mogoče pretvoriti v knjigi.
-DocType: Bank Reconciliation,Total Amount,Skupni znesek
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32,Internet Publishing,Internet Založništvo
-DocType: Prescription Duration,Number,Številka
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25,Creating {0} Invoice,Ustvarjanje računa {0}
-DocType: Medical Code,Medical Code Standard,Standard medicinske oznake
-DocType: Soil Texture,Clay Composition (%),Glina Sestava (%)
-apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81,Please save before assigning task.,"Prosimo, shranite, preden dodelite nalogo."
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +74,Balance Value,Balance Vrednost
-DocType: Lab Test,Lab Technician,Laboratorijski tehnik
-apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Prodaja Cenik
-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, mapirana na Patient. Pacientovi računi bodo ustvarjeni proti tej Stranki. Med ustvarjanjem bolnika lahko izberete tudi obstoječo stranko."
-DocType: Bank Reconciliation,Account Currency,Valuta računa
-DocType: Lab Test,Sample ID,Vzorec ID
-apps/erpnext/erpnext/accounts/general_ledger.py +165,Please mention Round Off Account in Company,Navedite zaokrožijo račun v družbi
-DocType: Purchase Receipt,Range,Razpon
-DocType: Supplier,Default Payable Accounts,Privzete plačuje računov
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49,Employee {0} is not active or does not exist,Employee {0} ni aktiven ali pa ne obstaja
-DocType: Fee Structure,Components,komponente
-DocType: Item Barcode,Item Barcode,Postavka Barcode
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +329,Please enter Asset Category in Item {0},Vnesite Asset Kategorija točke {0}
-apps/erpnext/erpnext/stock/doctype/item/item.py +660,Item Variants {0} updated,Postavka Variante {0} posodobljen
-DocType: Quality Inspection Reading,Reading 6,Branje 6
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9,"to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field
-of this","ki se generirajo. Če je odloženo, boste morali ročno spremeniti polje »Ponovi na dan v mesecu« tega"
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +945,Cannot {0} {1} {2} without any negative outstanding invoice,"Ne more {0} {1} {2}, brez kakršne koli negativne izjemno račun"
-DocType: Share Transfer,From Folio No,Iz Folio No
-DocType: Purchase Invoice Advance,Purchase Invoice Advance,Nakup računa Advance
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199,Row {0}: Credit entry can not be linked with a {1},Vrstica {0}: Credit vnos ni mogoče povezati z {1}
-apps/erpnext/erpnext/config/accounts.py +246,Define budget for a financial year.,Določite proračuna za proračunsko leto.
-DocType: Lead,LEAD-,PONUDBA-
-DocType: Employee,Permanent Address Is,Stalni naslov je
-DocType: Production Order Operation,Operation completed for how many finished goods?,"Operacija zaključena, za koliko končnih izdelkov?"
-DocType: Payment Terms Template,Payment Terms Template,Predloga za plačilni pogoji
-apps/erpnext/erpnext/public/js/setup_wizard.js +51,The Brand,Brand
-DocType: Employee,Exit Interview Details,Exit Intervju Podrobnosti
-DocType: Item,Is Purchase Item,Je Nakup Postavka
-DocType: Journal Entry Account,Purchase Invoice,Nakup Račun
-DocType: Stock Ledger Entry,Voucher Detail No,Bon Detail Ne
-apps/erpnext/erpnext/accounts/page/pos/pos.js +789,New Sales Invoice,Nov račun
-DocType: Stock Entry,Total Outgoing Value,Skupaj Odhodni Vrednost
-DocType: Physician,Appointments,Imenovanja
-apps/erpnext/erpnext/public/js/account_tree_grid.js +224,Opening Date and Closing Date should be within same Fiscal Year,Pričetek in rok bi moral biti v istem proračunskem letu
-DocType: Lead,Request for Information,Zahteva za informacije
-,LeaderBoard,leaderboard
-DocType: Sales Invoice Item,Rate With Margin (Company Currency),Stopnja z maržo (valuta podjetja)
-apps/erpnext/erpnext/accounts/page/pos/pos.js +802,Sync Offline Invoices,Sinhronizacija Offline Računi
-DocType: Payment Request,Paid,Plačan
-DocType: Program Fee,Program Fee,Cena programa
-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, posodobiti stroške in obnovil tabelo &quot;BOM eksplozijsko blago&quot; v skladu z novim BOM. Prav tako posodablja najnovejšo ceno v vseh BOM."
-DocType: Salary Slip,Total in words,Skupaj z besedami
-DocType: Material Request Item,Lead Time Date,Lead Time Datum
-DocType: Asset,Available-for-use Date,"Datum, ki je na voljo za uporabo"
-DocType: Guardian,Guardian Name,Ime Guardian
-DocType: Cheque Print Template,Has Print Format,Ima format tiskanja
-DocType: Employee Loan,Sanctioned,sankcionirano
-apps/erpnext/erpnext/accounts/page/pos/pos.js +75, is mandatory. Maybe Currency Exchange record is not created for ,je obvezna. Mogoče Menjalni zapis ni ustvarjen za
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +126,Row #{0}: Please specify Serial No for Item {1},Vrstica # {0}: Navedite Zaporedna številka za postavko {1}
-DocType: Crop Cycle,Crop Cycle,Crop Crop
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +633,"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 &quot;izdelek Bundle &#39;predmetov, skladišče, serijska številka in serijska se ne šteje od&quot; seznam vsebine &quot;mizo. Če so skladišča in serija ni enaka za vso embalažo postavke za kakršno koli &quot;izdelek Bundle &#39;postavko, lahko te vrednosti je treba vnesti v glavnem Element tabele, bodo vrednosti, ki se kopira na&quot; seznam vsebine &quot;mizo."
-DocType: Student Admission,Publish on website,Objavi na spletni strani
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651,Supplier Invoice Date cannot be greater than Posting Date,Datum dobavitelj na računu ne sme biti večja od Napotitev Datum
-DocType: Purchase Invoice Item,Purchase Order Item,Naročilnica item
-DocType: Agriculture Task,Agriculture Task,Kmetijska naloga
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Indirect Income,Posredna Prihodki
-DocType: Student Attendance Tool,Student Attendance Tool,Študent Udeležba orodje
-DocType: Restaurant Menu,Price List (Auto created),Cenik (samodejno ustvarjen)
-DocType: Cheque Print Template,Date Settings,Datum Nastavitve
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,Variance
-,Company Name,ime podjetja
-DocType: SMS Center,Total Message(s),Skupaj sporočil (-i)
-DocType: Share Balance,Purchased,Nakup
-DocType: Purchase Invoice,Additional Discount Percentage,Dodatni popust Odstotek
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Oglejte si seznam vseh videoposnetkov pomočjo
-DocType: Agriculture Analysis Criteria,Soil Texture,Tekstura za tla
-DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,"Izberite račun vodja banke, kjer je bila deponirana pregled."
-DocType: Selling Settings,Allow user to edit Price List Rate in transactions,"Dovoli uporabniku, da uredite Cenik Ocenite v transakcijah"
-DocType: Pricing Rule,Max Qty,Max Kol
-apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30,"Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \
-						Please enter a valid Invoice","Vrstica {0}: Račun {1} ni veljavna, se lahko prekliče / ne obstaja. \ Vnesite veljaven račun"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +132,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Vrstica {0}: morala Plačilo proti prodaja / narocilo vedno označen kot vnaprej
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16,Chemical,Chemical
-DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,"Privzeti Bank / Cash račun bo samodejno posodobljen plač Journal Entry, ko je izbrana ta način."
-DocType: BOM,Raw Material Cost(Company Currency),Stroškov surovin (družba Valuta)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +783,All items have already been transferred for this Production Order.,Vsi artikli so se že prenesli na to Proizvodno naročilo.
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +87,Row # {0}: Rate cannot be greater than the rate used in {1} {2},"Vrstica # {0}: stopnja ne more biti večji od stopnje, ki se uporablja pri {1} {2}"
-apps/erpnext/erpnext/utilities/user_progress.py +144,Meter,meter
-DocType: Workstation,Electricity Cost,Stroški električne energije
-apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +22,Lab testing datetime cannot be before collection datetime,Testiranje datotečnega laboratorija ne more biti pred zbiranjem datetime
-DocType: HR Settings,Don't send Employee Birthday Reminders,Ne pošiljajte zaposlenih rojstnodnevnih opomnikov
-DocType: Expense Claim,Total Advance Amount,Skupni znesek vnaprej
-DocType: Delivery Stop,Estimated Arrival,Ocenjeni prihod
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34,Save Settings,Shrani nastavitve
-DocType: Delivery Stop,Notified by Email,Obvestilo po e-pošti
-DocType: Item,Inspection Criteria,Merila Inšpekcijske
-apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,Prenese
-DocType: BOM Website Item,BOM Website Item,BOM Spletna stran Element
-apps/erpnext/erpnext/public/js/setup_wizard.js +52,Upload your letter head and logo. (you can edit them later).,Naložite svoje pismo glavo in logotip. (lahko jih uredite kasneje).
-DocType: Timesheet Detail,Bill,Bill
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +88,Next Depreciation Date is entered as past date,Naslednja Amortizacija Datum je vpisana kot preteklem dnevu
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208,White,Bela
-DocType: SMS Center,All Lead (Open),Vse ponudbe (Odprte)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +257,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Vrstica {0}: Kol ni na voljo za {4} v skladišču {1} na objavo čas začetka ({2} {3})
-apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18,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: Purchase Invoice,Get Advances Paid,Get plačanih predplačil
-DocType: Item,Automatically Create New Batch,Samodejno Ustvari novo serijo
-DocType: Item,Automatically Create New Batch,Samodejno Ustvari novo serijo
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +635,Assigning {0} to {1} (row {2}),Dodeljevanje {0} do {1} (vrstica {2})
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810,Make ,Poskrbite
-DocType: Student Admission,Admission Start Date,Vstop Datum začetka
-DocType: Journal Entry,Total Amount in Words,Skupni znesek z besedo
-apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29,New Employee,Novi zaposleni
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7,There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,"Prišlo je do napake. Eden verjeten razlog je lahko, da niste shranili obrazec. Obrnite support@erpnext.com če je težava odpravljena."
-apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Košarica
-apps/erpnext/erpnext/controllers/selling_controller.py +129,Order Type must be one of {0},Sklep Tip mora biti eden od {0}
-DocType: Lead,Next Contact Date,Naslednja Stik Datum
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Opening Qty,Odpiranje Količina
-DocType: Healthcare Settings,Appointment Reminder,Opomnik o imenovanju
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +478,Please enter Account for Change Amount,Prosim vnesite račun za znesek spremembe
-DocType: Program Enrollment Tool Student,Student Batch Name,Student Serija Ime
-DocType: Consultation,Doctor,Doktor
-DocType: Holiday List,Holiday List Name,Naziv seznama praznikov
-DocType: Repayment Schedule,Balance Loan Amount,Bilanca Znesek posojila
-apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,urnik predmeta
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +235,Stock Options,Delniških opcij
-DocType: Buying Settings,Disable Fetching Last Purchase Details in Purchase Order,Onemogoči pridobivanje zadnjih podrobnosti nakupa v naročilu
-DocType: Journal Entry Account,Expense Claim,Expense zahtevek
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +267,Do you really want to restore this scrapped asset?,Ali res želite obnoviti ta izločeni sredstva?
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +381,Qty for {0},Količina za {0}
-DocType: Leave Application,Leave Application,Zapusti Application
-DocType: Patient,Patient Relation,Pacientovo razmerje
-apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Pustite Orodje razdelitve emisijskih
-DocType: Item,Hub Category to Publish,Kategorija vozlišča za objavo
-DocType: Leave Block List,Leave Block List Dates,Pustite Block List termini
-DocType: Sales Invoice,Billing Address GSTIN,Naslov za izstavitev računa GSTIN
-DocType: Assessment Plan,Evaluate,Ocenite
-DocType: Workstation,Net Hour Rate,Neto urna postavka
-DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Pristali Stroški Potrdilo o nakupu
-DocType: Company,Default Terms,Privzeti pogoji
-DocType: Supplier Scorecard Period,Criteria,Merila
-DocType: Packing Slip Item,Packing Slip Item,Pakiranje Slip Postavka
-DocType: Purchase Invoice,Cash/Bank Account,Gotovina / bančni račun
-apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},Navedite {0}
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +73,Removed items with no change in quantity or value.,Odstranjeni deli brez spremembe količine ali vrednosti.
-DocType: Delivery Note,Delivery To,Dostava
-apps/erpnext/erpnext/stock/doctype/item/item.js +386,Variant creation has been queued.,Ustvarjanje variant je bilo v čakalni vrsti.
-apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +100,Work Summary for {0},Povzetek dela za {0}
-apps/erpnext/erpnext/stock/doctype/item/item.py +695,Attribute table is mandatory,Lastnost miza je obvezna
-DocType: Production Plan,Get Sales Orders,Pridobite prodajnih nalogov
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +68,{0} can not be negative,{0} ne more biti negativna
-DocType: Training Event,Self-Study,Samo-študija
-apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +26,Soil compositions do not add up to 100,Sestavine tal ne ustvarjajo do 100
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +554,Discount,Popust
-DocType: Membership,Membership,Članstvo
-DocType: Asset,Total Number of Depreciations,Skupno število amortizacije
-DocType: Sales Invoice Item,Rate With Margin,Oceni z mejo
-DocType: Sales Invoice Item,Rate With Margin,Oceni z mejo
-DocType: Workstation,Wages,Plače
-DocType: Asset Maintenance,Maintenance Manager Name,Ime upravitelja vzdrževanja
-DocType: Agriculture Task,Urgent,Nujna
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,Please specify a valid Row ID for row {0} in table {1},Navedite veljavno Row ID za vrstico {0} v tabeli {1}
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84,Unable to find variable: ,Ni mogoče najti spremenljivke:
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +790,Please select a field to edit from numpad,Izberite polje za urejanje iz numpad
-apps/erpnext/erpnext/stock/doctype/item/item.py +263,Cannot be a fixed asset item as Stock Ledger is created.,"Ne more biti postavka osnovnega sredstva, kot je ustvarjena knjiga zalog."
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Pojdite na namizje in začeti uporabljati ERPNext
-DocType: Item,Manufacturer,Proizvajalec
-DocType: Landed Cost Item,Purchase Receipt Item,Potrdilo o nakupu Postavka
-DocType: Purchase Receipt,PREC-RET-,Prec-RET-
-DocType: POS Profile,Sales Invoice Payment,Plačilo prodaja Račun
-DocType: Quality Inspection Template,Quality Inspection Template Name,Kakovostna inšpekcijska preglednica Ime
-DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Rezervirano Warehouse v Sales Order / dokončanih proizvodov Warehouse
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Selling Amount,Prodajni Znesek
-DocType: Repayment Schedule,Interest Amount,Obresti Znesek
-DocType: Serial No,Creation Document No,Za ustvarjanje dokumentov ni
-DocType: Share Transfer,Issue,Težava
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11,Records,Zapisi
-DocType: Asset,Scrapped,izločeni
-DocType: Purchase Invoice,Returns,Vračila
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +42,WIP Warehouse,WIP Skladišče
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195,Serial No {0} is under maintenance contract upto {1},Serijska št {0} je pod vzdrževalne pogodbe stanuje {1}
-apps/erpnext/erpnext/config/hr.py +35,Recruitment,zaposlovanje
-DocType: Lead,Organization Name,Organization Name
-DocType: Tax Rule,Shipping State,Dostava država
-,Projected Quantity as Source,Predvidena količina kot vir
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item must be added using 'Get Items from Purchase Receipts' button,Postavka je treba dodati uporabo &quot;dobili predmetov iz nakupu prejemki&quot; gumb
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +858,Delivery Trip,Dostava potovanje
-DocType: Student,A-,A-
-DocType: Share Transfer,Transfer Type,Vrsta prenosa
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Sales Expenses,Prodajna Stroški
-DocType: Consultation,Diagnosis,Diagnoza
-apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18,Standard Buying,Standardna nabavna
-DocType: GL Entry,Against,Proti
-DocType: Item,Default Selling Cost Center,Privzet stroškovni center prodaje
-DocType: Sales Partner,Implementation Partner,Izvajanje Partner
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1623,ZIP Code,Poštna številka
-apps/erpnext/erpnext/controllers/selling_controller.py +251,Sales Order {0} is {1},Naročilo {0} je {1}
-DocType: Opportunity,Contact Info,Kontaktni podatki
-apps/erpnext/erpnext/config/stock.py +319,Making Stock Entries,Izdelava Zaloga Entries
-DocType: Packing Slip,Net Weight UOM,Neto teža UOM
-DocType: Item,Default Supplier,Privzeto Dobavitelj
-DocType: Manufacturing Settings,Over Production Allowance Percentage,Nad proizvodnjo dodatku Odstotek
-DocType: Employee Loan,Repayment Schedule,Povračilo Urnik
-DocType: Shipping Rule Condition,Shipping Rule Condition,Pogoj dostavnega pravila
-DocType: Holiday List,Get Weekly Off Dates,Get Tedenski datumov
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33,End Date can not be less than Start Date,Končni datum ne sme biti manjši kot začetni datum
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +337,Invoice can't be made for zero billing hour,Račun ni mogoče naročiti za ničelno uro zaračunavanja
-DocType: Sales Person,Select company name first.,Izberite ime podjetja prvič.
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +189,Email sent to {0},E-pošta je poslana na {0}
-apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Prejete ponudbe
-apps/erpnext/erpnext/config/manufacturing.py +74,Replace BOM and update latest price in all BOMs,Zamenjajte BOM in posodobite najnovejšo ceno v vseh BOM
-apps/erpnext/erpnext/controllers/selling_controller.py +27,To {0} | {1} {2},Za {0} | {1} {2}
-DocType: Delivery Trip,Driver Name,Ime voznika
-apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Povprečna starost
-DocType: Education Settings,Attendance Freeze Date,Udeležba Freeze Datum
-DocType: Education Settings,Attendance Freeze Date,Udeležba Freeze Datum
-apps/erpnext/erpnext/utilities/user_progress.py +107,List a few of your suppliers. They could be organizations or individuals.,Naštejte nekaj vaših dobaviteljev. Ti bi se lahko organizacije ali posamezniki.
-apps/erpnext/erpnext/templates/pages/home.html +31,View All Products,Oglejte si vse izdelke
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Minimalna Svinec Starost (dnevi)
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +59,All BOMs,Vse BOMs
-apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35,Hotel Rooms of type {0} are unavailable on {1},Sobe Hotela tipa {0} niso na voljo na {1}
-DocType: Patient,Default Currency,Privzeta valuta
-DocType: Expense Claim,From Employee,Od zaposlenega
-DocType: Driver,Cellphone Number,številka mobilnega telefona
-apps/erpnext/erpnext/controllers/accounts_controller.py +471,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Opozorilo: Sistem ne bo preveril previsokih saj znesek za postavko {0} v {1} je nič
-DocType: Journal Entry,Make Difference Entry,Naredite Razlika Entry
-DocType: Upload Attendance,Attendance From Date,Udeležba Od datuma
-DocType: Appraisal Template Goal,Key Performance Area,Key Uspešnost Area
-DocType: Program Enrollment,Transportation,Prevoz
-apps/erpnext/erpnext/controllers/item_variant.py +94,Invalid Attribute,Neveljavna Lastnost
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +235,{0} {1} must be submitted,{0} {1} je potrebno vložiti
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159,Quantity must be less than or equal to {0},Količina mora biti manjša ali enaka {0}
-DocType: SMS Center,Total Characters,Skupaj Znaki
-DocType: Employee Advance,Claimed,Zahtevana
-DocType: Crop,Row Spacing,Razmik vrstic
-apps/erpnext/erpnext/controllers/buying_controller.py +164,Please select BOM in BOM field for Item {0},"Prosimo, izberite BOM BOM v polju za postavko {0}"
-DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Form Račun Detail
-DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Plačilo Sprava Račun
-apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +38,Contribution %,Prispevek%
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215,"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}","Kot je na Nastavitve Nakup če narocilo Obvezno == &quot;DA&quot;, nato pa za ustvarjanje računu o nakupu, uporabniki potrebujejo za ustvarjanje naročilnice najprej za postavko {0}"
-DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Registracijska št. podjetja za lastno evidenco. Davčna številka itn.
-DocType: Sales Partner,Distributor,Distributer
-DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Pravilo za dostavo za košaro
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252,Production Order {0} must be cancelled before cancelling this Sales Order,Proizvodnja naročite {0} je treba preklicati pred preklicem te Sales Order
-apps/erpnext/erpnext/public/js/controllers/transaction.js +71,Please set 'Apply Additional Discount On',Prosim nastavite &quot;Uporabi dodatni popust na &#39;
-,Ordered Items To Be Billed,Naročeno Postavke placevali
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,From Range has to be less than To Range,Od mora biti manj Razpon kot gibala
-DocType: Global Defaults,Global Defaults,Globalni Privzeto
-apps/erpnext/erpnext/projects/doctype/project/project.py +228,Project Collaboration Invitation,Projekt Sodelovanje Vabilo
-DocType: Salary Slip,Deductions,Odbitki
-DocType: Leave Allocation,LAL/,LAL /
-DocType: Setup Progress Action,Action Name,Ime dejanja
-apps/erpnext/erpnext/public/js/financial_statements.js +75,Start Year,Začetek Leto
-apps/erpnext/erpnext/regional/india/utils.py +25,First 2 digits of GSTIN should match with State number {0},Prvi 2 številki GSTIN se mora ujemati z državno številko {0}
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +63,PDC/LC,PDC / LC
-DocType: Purchase Invoice,Start date of current invoice's period,Datum začetka obdobja sedanje faktura je
-DocType: Salary Slip,Leave Without Pay,Leave brez plačila
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +385,Capacity Planning Error,Kapaciteta Napaka Načrtovanje
-,Trial Balance for Party,Trial Balance za stranke
-DocType: Lead,Consultant,Svetovalec
-DocType: Salary Slip,Earnings,Zaslužek
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +428,Finished Item {0} must be entered for Manufacture type entry,Končano Postavka {0} je treba vpisati za vpis tipa Proizvodnja
-apps/erpnext/erpnext/config/learn.py +87,Opening Accounting Balance,Začetna bilanca
-,GST Sales Register,DDV prodaje Registracija
-DocType: Sales Invoice Advance,Sales Invoice Advance,Predplačila
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +552,Nothing to request,Nič zahtevati
-apps/erpnext/erpnext/public/js/setup_wizard.js +18,Select your Domains,Izberite svoje domene
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34,Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3},Druga proračunska zapis &#39;{0}&#39; že obstaja proti {1} &quot;{2}&quot; za poslovno leto {3}
-DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Polja bodo kopirana samo v času ustvarjanja.
-DocType: Setup Progress Action,Domains,Domene
-apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Actual Start Date' can not be greater than 'Actual End Date',"""Dejanski datum začetka"" ne more biti novejši od ""dejanskega končnega datuma"""
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117,Management,Vodstvo
-DocType: Cheque Print Template,Payer Settings,Nastavitve plačnik
-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 dodan Točka Kodeksa variante. Na primer, če je vaša kratica je &quot;SM&quot;, in oznaka postavka je &quot;T-shirt&quot;, postavka koda varianto bo &quot;T-SHIRT-SM&quot;"
-DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,"Neto Pay (z besedami), bo viden, ko boste shranite plačilnega lista."
-DocType: Purchase Invoice,Is Return,Je Return
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92,Caution,Previdno
-apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +16,Start day is greater than end day in task '{0}',Začetni dan je večji od končnega dne pri nalogi &#39;{0}&#39;
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +815,Return / Debit Note,Nazaj / opominu
-DocType: Price List Country,Price List Country,Cenik Država
-DocType: Item,UOMs,UOMs
-apps/erpnext/erpnext/stock/utils.py +212,{0} valid serial nos for Item {1},{0} veljavna serijska številka za postavko {1}
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,Oznaka se ne more spremeniti za Serial No.
-DocType: Purchase Invoice Item,UOM Conversion Factor,UOM Conversion Factor
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40,Please enter Item Code to get Batch Number,Vnesite Koda priti Serija Število
-DocType: Stock Settings,Default Item Group,Privzeto Element Group
-DocType: Employee Loan,Partially Disbursed,delno črpanju
-apps/erpnext/erpnext/config/non_profit.py +73,Grant information.,Informacije o donaciji.
-apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Dobavitelj baze podatkov.
-DocType: Account,Balance Sheet,Bilanca stanja
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +750,Cost Center For Item with Item Code ',Stalo Center za postavko s točko zakonika &quot;
-DocType: Fee Validity,Valid Till,Veljavno do
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2500,"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 nastavljen. Prosimo, preverite, ali je bil račun nastavljen na načinu plačila ali na POS profil."
-apps/erpnext/erpnext/buying/utils.py +74,Same item cannot be entered multiple times.,Isti element ni mogoče vnesti večkrat.
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30,"Further accounts can be made under Groups, but entries can be made against non-Groups","Nadaljnje računi se lahko izvede v skupinah, vendar vnosi lahko zoper niso skupin"
-DocType: Lead,Lead,Ponudba
-DocType: Email Digest,Payables,Obveznosti
-DocType: Course,Course Intro,Seveda Intro
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +105,Stock Entry {0} created,Stock Začetek {0} ustvaril
-apps/erpnext/erpnext/controllers/buying_controller.py +316,Row #{0}: Rejected Qty can not be entered in Purchase Return,Vrstica # {0}: Zavrnjena Kol ne more biti vpisana v Nabava Nazaj
-,Purchase Order Items To Be Billed,Naročilnica Postavke placevali
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +63,Updating estimated arrival times.,Posodabljanje predvidenih časov prihoda.
-DocType: Program Enrollment Tool,Enrollment Details,Podrobnosti o vpisu
-DocType: Purchase Invoice Item,Net Rate,Net Rate
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +152,Please select a customer,Izberite kupca
-DocType: Purchase Invoice Item,Purchase Invoice Item,Nakup računa item
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Zaloga Glavna knjiga Prijave in GL Vnosi se oglaša za izbrane Nakup Prejemki
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Postavka 1
-DocType: Holiday,Holiday,Prazniki
-DocType: Support Settings,Close Issue After Days,Zapri Težava Po dnevih
-DocType: Leave Control Panel,Leave blank if considered for all branches,"Pustite prazno, če velja za vse veje"
-DocType: Bank Guarantee,Validity in Days,Veljavnost v dnevih
-DocType: Bank Guarantee,Validity in Days,Veljavnost v dnevih
-apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21,C-form is not applicable for Invoice: {0},C-oblika ne velja za računa: {0}
-DocType: Payment Reconciliation,Unreconciled Payment Details,Unreconciled Plačilni Podrobnosti
-apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6,Member Activity,Članska dejavnost
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Da bi Štetje
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Da bi Štetje
-DocType: Global Defaults,Current Fiscal Year,Tekočem proračunskem letu
-DocType: Purchase Order,Group same items,Skupina Iste vsebine
-DocType: Purchase Invoice,Disable Rounded Total,Onemogoči zaokroževanje
-DocType: Employee Loan Application,Repayment Info,Povračilo Info
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448,'Entries' cannot be empty,"""Vnos"" ne more biti prazen"
-DocType: Maintenance Team Member,Maintenance Role,Vzdrževalna vloga
-apps/erpnext/erpnext/utilities/transaction_base.py +88,Duplicate row {0} with same {1},Dvojnik vrstica {0} z enako {1}
-,Trial Balance,Trial Balance
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +438,Fiscal Year {0} not found,Poslovno leto {0} ni bilo mogoče najti
-apps/erpnext/erpnext/config/hr.py +305,Setting up Employees,Postavitev Zaposleni
-DocType: Sales Order,SO-,SO-
-DocType: Hotel Room Reservation,Hotel Reservation User,Uporabnik rezervacije hotela
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +153,Please select prefix first,"Prosimo, izberite predpono najprej"
-DocType: Student,O-,O-
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189,Research,Raziskave
-DocType: Maintenance Visit Purpose,Work Done,Delo končano
-apps/erpnext/erpnext/controllers/item_variant.py +35,Please specify at least one attribute in the Attributes table,Prosimo navedite vsaj en atribut v tabeli Atributi
-DocType: Announcement,All Students,Vse Študenti
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +45,Item {0} must be a non-stock item,"Točka {0} mora biti postavka, non-stock"
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +18,View Ledger,Ogled Ledger
-DocType: Grading Scale,Intervals,intervali
-apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Najzgodnejša
-apps/erpnext/erpnext/stock/doctype/item/item.py +525,"An Item Group exists with same name, please change the item name or rename the item group","Element, skupina obstaja z istim imenom, vas prosimo, spremenite ime elementa ali preimenovati skupino element"
-DocType: Crop Cycle,Less than a year,Manj kot eno leto
-apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Študent Mobile No.
-apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105,Rest Of The World,Ostali svet
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,Postavki {0} ne more imeti Batch
-DocType: Crop,Yield UOM,Donosnost UOM
-,Budget Variance Report,Proračun Varianca Poročilo
-DocType: Salary Slip,Gross Pay,Bruto Pay
-DocType: Item,Is Item from Hub,Je predmet iz vozlišča
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118,Row {0}: Activity Type is mandatory.,Vrstica {0}: Vrsta dejavnosti je obvezna.
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166,Dividends Paid,Plačane dividende
-apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36,Accounting Ledger,Računovodstvo Ledger
-DocType: Stock Reconciliation,Difference Amount,Razlika Znesek
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +112,Dr {0} on Leave on {1},Dr {0} na pusti {1}
-DocType: Purchase Invoice,Reverse Charge,Povratna obremenitev
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172,Retained Earnings,Preneseni čisti poslovni izid
-DocType: Purchase Invoice,05-Change in POS,05-Sprememba v POS
-DocType: Vehicle Log,Service Detail,Service Podrobnosti
-DocType: BOM,Item Description,Postavka Opis
-DocType: Student Sibling,Student Sibling,študent Sorodstvena
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +18,Payment Mode,Način Plačilo
-DocType: Purchase Invoice,Supplied Items,Priložena Items
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85,Please set an active menu for Restaurant {0},"Prosimo, nastavite aktivni meni za restavracijo {0}"
-DocType: Student,STUD.,STUD.
-DocType: Production Order,Qty To Manufacture,Količina za izdelavo
-DocType: Email Digest,New Income,Novi prihodki
-DocType: Buying Settings,Maintain same rate throughout purchase cycle,Ohraniti enako stopnjo celotni nabavni cikel
-DocType: Opportunity Item,Opportunity Item,Priložnost Postavka
-,Student and Guardian Contact Details,Študent in Guardian Kontaktni podatki
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +53,Row {0}: For supplier {0} Email Address is required to send email,Vrstica {0}: Za dobavitelja je potrebno {0} e-poštni naslov za pošiljanje e-pošte
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72,Temporary Opening,Začasna Otvoritev
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +10,View Hub,Oglejte si vozlišče
-,Employee Leave Balance,Zaposleni Leave Balance
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147,Balance for Account {0} must always be {1},"Saldo račun {0}, morajo biti vedno {1}"
-DocType: Patient Appointment,More Info,Več informacij
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +180,Valuation Rate required for Item in row {0},Oceni Vrednotenje potreben za postavko v vrstici {0}
-DocType: Supplier Scorecard,Scorecard Actions,Akcije kazalnikov
-apps/erpnext/erpnext/utilities/user_progress.py +166,Example: Masters in Computer Science,Primer: Masters v računalništvu
-DocType: Purchase Invoice,Rejected Warehouse,Zavrnjeno Skladišče
-DocType: GL Entry,Against Voucher,Proti Voucher
-DocType: Item,Default Buying Cost Center,Privzet stroškovni center za nabavo
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6,"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Da bi dobili najboljše iz ERPNext, vam priporočamo, da si vzamete nekaj časa in gledam te posnetke pomoč."
-apps/erpnext/erpnext/accounts/page/pos/pos.js +76, to ,do
-DocType: Supplier Quotation Item,Lead Time in days,Lead time v dnevih
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +58,Accounts Payable Summary,Računi plačljivo Povzetek
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +321,Payment of salary from {0} to {1},Izplačilo plače iz {0} na {1}
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213,Not authorized to edit frozen Account {0},Ne smejo urejati zamrznjeni račun {0}
-DocType: Journal Entry,Get Outstanding Invoices,Pridobite neplačanih računov
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +84,Sales Order {0} is not valid,Naročilo {0} ni veljavno
-DocType: Supplier Scorecard,Warn for new Request for Quotations,Opozori na novo zahtevo za citate
-apps/erpnext/erpnext/utilities/activation.py +91,Purchase orders help you plan and follow up on your purchases,Naročilnice vam pomaga načrtovati in spremljati svoje nakupe
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151,Lab Test Prescriptions,Testi laboratorijskih testov
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +166,"The total Issue / Transfer quantity {0} in Material Request {1}  \
-							cannot be greater than requested quantity {2} for Item {3}",Skupna količina Vprašanje / Transfer {0} v dogovoru Material {1} \ ne sme biti večja od zahtevane količine {2} za postavko {3}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197,Small,Majhno
-DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Element orodja za ustvarjanje odprtega računa
-DocType: Education Settings,Employee Number,Število zaposlenih
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67,Case No(s) already in use. Try from Case No {0},Zadeva št (y) že v uporabi. Poskusite z zadevo št {0}
-DocType: Project,% Completed,% končano
-,Invoiced Amount (Exculsive Tax),Obračunani znesek (Exculsive Tax)
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14,Item 2,Postavka 2
-DocType: Supplier,SUPP-,SUPP-
-DocType: Training Event,Training Event,Dogodek usposabljanje
-DocType: Item,Auto re-order,Auto re-order
-apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,Skupaj Doseženi
-DocType: Employee,Place of Issue,Kraj izdaje
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101,Contract,Pogodba
-DocType: Plant Analysis,Laboratory Testing Datetime,Laboratorijsko testiranje Datetime
-DocType: Email Digest,Add Quote,Dodaj Citiraj
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +973,UOM coversion factor required for UOM: {0} in Item: {1},"UOM coversion dejavnik, potreben za UOM: {0} v postavki: {1}"
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92,Indirect Expenses,Posredni stroški
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +97,Row {0}: Qty is mandatory,Vrstica {0}: Kol je obvezna
-DocType: Agriculture Analysis Criteria,Agriculture,Kmetijstvo
-apps/erpnext/erpnext/accounts/page/pos/pos.js +794,Sync Master Data,Sync Master Data
-DocType: Asset Repair,Repair Cost,Stroški popravila
-apps/erpnext/erpnext/utilities/user_progress.py +135,Your Products or Services,Svoje izdelke ali storitve
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15,Failed to login,Prijava ni uspel
-DocType: Special Test Items,Special Test Items,Posebni testni elementi
-DocType: Mode of Payment,Mode of Payment,Način plačila
-apps/erpnext/erpnext/stock/doctype/item/item.py +201,Website Image should be a public file or website URL,Spletna stran Slika bi morala biti javna datoteka ali spletna stran URL
-DocType: Student Applicant,AP,AP
-DocType: Purchase Invoice Item,BOM,BOM
-apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37,This is a root item group and cannot be edited.,"To je skupina, root element in ga ni mogoče urejati."
-DocType: Journal Entry Account,Purchase Order,Naročilnica
-DocType: Vehicle,Fuel UOM,gorivo UOM
-DocType: Warehouse,Warehouse Contact Info,Skladišče Kontakt Info
-DocType: Payment Entry,Write Off Difference Amount,Napišite Off Razlika Znesek
-DocType: Volunteer,Volunteer Name,Ime prostovoljca
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +433,"{0}: Employee email not found, hence email not sent","{0}: email zaposlenega ni mogoče najti, zato e-poštno sporočilo ni bilo poslano"
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85,Shipping rule not applicable for country {0},Pravilo o pošiljanju ni veljavno za državo {0}
-DocType: Item,Foreign Trade Details,Zunanjo trgovino Podrobnosti
-,Assessment Plan Status,Status načrta ocenjevanja
-DocType: Email Digest,Annual Income,Letni dohodek
-DocType: Serial No,Serial No Details,Serijska št Podrobnosti
-DocType: Purchase Invoice Item,Item Tax Rate,Postavka Davčna stopnja
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +75,Please select Physician and Date,"Prosimo, izberite zdravnika in datum"
-DocType: Student Group Student,Group Roll Number,Skupina Roll Število
-DocType: Student Group Student,Group Roll Number,Skupina Roll Število
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145,"For {0}, only credit accounts can be linked against another debit entry","Za {0}, lahko le kreditne račune povezati proti drugemu vstop trajnika"
-apps/erpnext/erpnext/projects/doctype/project/project.py +82,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,"Vsota vseh uteži nalog bi moral biti 1. Prosimo, da ustrezno prilagodi uteži za vse naloge v projektu"
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +588,Delivery Note {0} is not submitted,Dobavnica {0} ni predložila
-apps/erpnext/erpnext/stock/get_item_details.py +148,Item {0} must be a Sub-contracted Item,Postavka {0} mora biti podizvajalcev item
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43,Capital Equipments,Kapitalski Oprema
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Cen Pravilo je najprej treba izbrati glede na &quot;Uporabi On &#39;polju, ki je lahko točka, točka Group ali Brand."
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +246,Please set the Item Code first,Najprej nastavite kodo izdelka
-DocType: Item,ITEM-,ITEM-
-apps/erpnext/erpnext/controllers/selling_controller.py +122,Total allocated percentage for sales team should be 100,Skupna dodeljena odstotek za prodajne ekipe mora biti 100
-DocType: Sales Invoice Item,Edit Description,Uredi Opis
-DocType: Antibiotic,Antibiotic,Antibiotik
-,Team Updates,ekipa Posodobitve
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +912,For Supplier,Za dobavitelja
-DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Nastavitev vrste računa pomaga pri izbiri računa v transakcijah.
-DocType: Purchase Invoice,Grand Total (Company Currency),Grand Total (družba Valuta)
-apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Create Print Format,Ustvari Print Format
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Ustvarjena provizija
-apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},Ni našla nobenega elementa z imenom {0}
-DocType: Supplier Scorecard Criteria,Criteria Formula,Kriterijska formula
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,Skupaj Odhodni
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""",Obstaja lahko samo en prevoz pravilo Pogoj z 0 ali prazno vrednost za &quot;ceniti&quot;
-DocType: Authorization Rule,Transaction,Posel
-DocType: Patient Appointment,Duration,Trajanje
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Opomba: Ta Stroški Center je skupina. Ne more vknjižbe proti skupinam.
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +54,Child warehouse exists for this warehouse. You can not delete this warehouse.,"Otrok skladišče obstaja za to skladišče. Ne, ne moreš izbrisati to skladišče."
-DocType: Item,Website Item Groups,Spletna stran Element Skupine
-DocType: Purchase Invoice,Total (Company Currency),Skupaj (družba Valuta)
-DocType: Daily Work Summary Group,Reminder,Opomnik
-apps/erpnext/erpnext/stock/utils.py +207,Serial number {0} entered more than once,Serijska številka {0} je začela več kot enkrat
-DocType: Journal Entry,Journal Entry,Vnos v dnevnik
-DocType: Expense Claim Advance,Unclaimed amount,Nezahteven znesek
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +148,{0} items in progress,{0} postavke v teku
-DocType: Workstation,Workstation Name,Workstation Name
-DocType: Grading Scale Interval,Grade Code,razred Code
-DocType: POS Item Group,POS Item Group,POS Element Group
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,Email Digest:
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +608,BOM {0} does not belong to Item {1},BOM {0} ne pripada postavki {1}
-DocType: Sales Partner,Target Distribution,Target Distribution
-DocType: Purchase Invoice,06-Finalization of Provisional assessment,06-Dokončanje začasne ocene
-DocType: Salary Slip,Bank Account No.,Št. bančnega računa
-DocType: Naming Series,This is the number of the last created transaction with this prefix,To je številka zadnjega ustvarjene transakcijo s tem predpono
-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)
-","Uporabljate lahko spremenljivke Scorecard, kot tudi: {total_score} (skupna ocena iz tega obdobja), {period_number} (število obdobij do današnjega dne)"
-DocType: Quality Inspection Reading,Reading 8,Branje 8
-DocType: Sales Partner,Agent,Agent
-DocType: Purchase Invoice,Taxes and Charges Calculation,Davki in dajatve Izračun
-DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Knjiga sredstev Amortizacija Začetek samodejno
-DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Knjiga sredstev Amortizacija Začetek samodejno
-DocType: BOM Operation,Workstation,Workstation
-DocType: Request for Quotation Supplier,Request for Quotation Supplier,Zahteva za ponudbo dobavitelja
-DocType: Healthcare Settings,Registration Message,Registracija sporočilo
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154,Hardware,Strojna oprema
-DocType: Prescription Dosage,Prescription Dosage,Odmerjanje na recept
-DocType: Attendance,HR Manager,Upravljanje človeških virov
-apps/erpnext/erpnext/accounts/party.py +176,Please select a Company,Prosimo izberite Company
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92,Privilege Leave,Privilege Zapusti
-DocType: Purchase Invoice,Supplier Invoice Date,Dobavitelj Datum računa
-DocType: Asset Settings,This value is used for pro-rata temporis calculation,Ta vrednost se uporablja za izracun pro rata temporis
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90,You need to enable Shopping Cart,Morate omogočiti Košarica
-DocType: Payment Entry,Writeoff,Odpisati
-DocType: Stock Settings,Naming Series Prefix,Namig serijske oznake
-DocType: Appraisal Template Goal,Appraisal Template Goal,Cenitev Predloga cilj
-DocType: Salary Component,Earning,Služenje
-DocType: Supplier Scorecard,Scoring Criteria,Kriteriji točkovanja
-DocType: Purchase Invoice,Party Account Currency,Party Valuta računa
-,BOM Browser,BOM Browser
-apps/erpnext/erpnext/templates/emails/training_event.html +13,Please update your status for this training event,"Prosimo, posodobite svoj status za ta trening dogodek"
-DocType: Item Barcode,EAN,EAN
-DocType: Purchase Taxes and Charges,Add or Deduct,Dodajte ali odštejemo
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148,Overlapping conditions found between:,Prekrivajoča pogoji najdemo med:
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187,Against Journal Entry {0} is already adjusted against some other voucher,Proti listu Začetek {0} je že prilagojena proti neki drugi kupon
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68,Total Order Value,Skupna vrednost naročila
-apps/erpnext/erpnext/demo/setup/setup_data.py +328,Food,Hrana
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +51,Ageing Range 3,Staranje Območje 3
-DocType: Maintenance Schedule Item,No of Visits,Število obiskov
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165,Maintenance Schedule {0} exists against {1},obstaja Vzdrževanje Razpored {0} proti {1}
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36,Enrolling student,Vpisovanje študentov
-apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,Currency of the Closing Account must be {0},Valuta zaključni račun mora biti {0}
-apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Seštevek točk za vseh ciljev bi morala biti 100. To je {0}
-DocType: Project,Start and End Dates,Začetni in končni datum
-,Delivered Items To Be Billed,Dobavljeni artikli placevali
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16,Open BOM {0},Odprti BOM {0}
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60,Warehouse cannot be changed for Serial No.,Skladišče ni mogoče spremeniti za Serial No.
-DocType: Authorization Rule,Average Discount,Povprečen Popust
-DocType: Purchase Invoice Item,UOM,UOM
-DocType: Rename Tool,Utilities,Utilities
-DocType: POS Profile,Accounting,Računovodstvo
-DocType: Employee,EMP/,EMP /
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133,Please select batches for batched item ,Izberite serij za združena postavko
-DocType: Asset,Depreciation Schedules,Amortizacija Urniki
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +192,Following accounts might be selected in GST Settings:,V nastavitvah GST se lahko izberejo naslednji računi:
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +71,Application period cannot be outside leave allocation period,Prijavni rok ne more biti obdobje dodelitve izven dopusta
-DocType: Activity Cost,Projects,Projekti
-DocType: Payment Request,Transaction Currency,transakcija Valuta
-apps/erpnext/erpnext/controllers/buying_controller.py +30,From {0} | {1} {2},Od {0} | {1} {2}
-DocType: Production Order Operation,Operation Description,Operacija Opis
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,"Ne more spremeniti poslovno leto začetni datum in fiskalnem letu End Datum, ko je poslovno leto shranjen."
-DocType: Quotation,Shopping Cart,Nakupovalni voziček
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Avg Daily Odhodni
-DocType: POS Profile,Campaign,Kampanja
-DocType: Supplier,Name and Type,Ime in Type
-DocType: Physician,Contacts and Address,Stiki in naslov
-DocType: Purchase Invoice,Contact Person,Kontaktna oseba
-apps/erpnext/erpnext/projects/doctype/task/task.py +38,'Expected Start Date' can not be greater than 'Expected End Date','Pričakovani datum začetka' ne more biti večji od 'Pričakovan datum zaključka'
-DocType: Course Scheduling Tool,Course End Date,Seveda Končni datum
-DocType: Holiday List,Holidays,Prazniki
-DocType: Sales Order Item,Planned Quantity,Načrtovana Količina
-DocType: Purchase Invoice Item,Item Tax Amount,Postavka Znesek davka
-DocType: Water Analysis,Water Analysis Criteria,Kriteriji za analizo vode
-DocType: Item,Maintain Stock,Ohraniti park
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +226,Stock Entries already created for Production Order ,Zaloga Vpisi že ustvarjene za proizvodnjo red
-DocType: Employee,Prefered Email,Prednostna pošta
-DocType: Student Admission,Eligibility and Details,Upravičenost in podrobnosti
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +38,Net Change in Fixed Asset,Neto sprememba v osnovno sredstvo
-DocType: Leave Control Panel,Leave blank if considered for all designations,"Pustite prazno, če velja za vse označb"
-apps/erpnext/erpnext/controllers/accounts_controller.py +799,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Naboj tip &quot;Dejanski&quot; v vrstici {0} ni mogoče vključiti v postavko Rate
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +382,Max: {0},Max: {0}
-apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,Od datetime
-DocType: Email Digest,For Company,Za podjetje
-apps/erpnext/erpnext/config/support.py +17,Communication log.,Sporočilo dnevnik.
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +195,"Request for Quotation is disabled to access from portal, for more check portal settings.",Zahteva za ponudbo je onemogočen dostop iz portala za več nastavitev za preverjanje portala.
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +24,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Prosimo, nastavite sistem imenovanja zaposlenih v kadrovskem načrtu&gt; HR Settings"
-DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Dobavitelj Scorecard Scoring Spremenljivka
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Buying Amount,Znesek nabave
-DocType: Sales Invoice,Shipping Address Name,Naslov dostave
-DocType: Material Request,Terms and Conditions Content,Pogoji in vsebina
-apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18,There were errors creating Course Schedule,Prišlo je do napak pri urejanju tečaja tečaja
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +581,cannot be greater than 100,ne more biti večja kot 100
-apps/erpnext/erpnext/stock/doctype/item/item.py +751,Item {0} is not a stock Item,Postavka {0} ni zaloge Item
-DocType: Maintenance Visit,Unscheduled,Nenačrtovana
-DocType: Employee,Owned,Lasti
-DocType: Salary Detail,Depends on Leave Without Pay,Odvisno od dopusta brez plačila
-DocType: Pricing Rule,"Higher the number, higher the priority","Višja kot je številka, višja je prioriteta"
-,Purchase Invoice Trends,Račun za nakup Trendi
-DocType: Employee,Better Prospects,Boljši obeti
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +217,"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}: Serija {1} ima le {2} kol. Izberite drugo serijo, ki ima {3} kol na voljo ali razdeli vrstico v več vrstic, da poda / vprašanja iz različnih serij"
-DocType: Vehicle,License Plate,Registrska tablica
-DocType: Appraisal,Goals,Cilji
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +349,Select POS Profile,Izberite POS profil
-DocType: Warranty Claim,Warranty / AMC Status,Garancija / AMC Status
-,Accounts Browser,Računi Browser
-DocType: Payment Entry Reference,Payment Entry Reference,Plačilo Začetek Reference
-DocType: GL Entry,GL Entry,GL Začetek
-DocType: HR Settings,Employee Settings,Nastavitve zaposlenih
-,Batch-Wise Balance History,Serija-Wise Balance Zgodovina
-apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73,Print settings updated in respective print format,nastavitve tiskanja posodabljajo v ustrezni obliki za tiskanje
-DocType: Package Code,Package Code,paket koda
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105,Apprentice,Vajenec
-DocType: Purchase Invoice,Company GSTIN,Podjetje GSTIN
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +105,Negative Quantity is not allowed,Negativno Količina ni dovoljeno
-DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
-Used for Taxes and Charges",Davčna podrobnosti tabela nerealne iz postavke mojstra kot vrvico in shranjena na tem področju. Uporablja se za davki in dajatve
-DocType: Supplier Scorecard Period,SSC-,SSC-
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +159,Employee cannot report to himself.,Delavec ne more poročati zase.
-DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Če računa je zamrznjeno, so vpisi dovoljeni omejenih uporabnikov."
-DocType: Email Digest,Bank Balance,Banka Balance
-apps/erpnext/erpnext/accounts/party.py +241,Accounting Entry for {0}: {1} can only be made in currency: {2},"Računovodstvo Vstop za {0}: lahko {1}, se izvede le v valuti: {2}"
-DocType: Job Opening,"Job profile, qualifications required etc.","Profil delovnega mesta, potrebna usposobljenost itd"
-DocType: Journal Entry Account,Account Balance,Stanje na računu
-apps/erpnext/erpnext/config/accounts.py +183,Tax Rule for transactions.,Davčna pravilo za transakcije.
-DocType: Rename Tool,Type of document to rename.,Vrsta dokumenta preimenovati.
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},{0} {1}: zahtevan je Naročnik za račun prejemkov {2}
-DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Skupaj davki in dajatve (Company valuti)
-DocType: Weather,Weather Parameter,Vremenski parameter
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60,Show unclosed fiscal year's P&L balances,Prikaži nezaprt poslovno leto je P &amp; L bilanc
-DocType: Lab Test Template,Collection Details,Podrobnosti o zbirki
-DocType: POS Profile,Allow Print Before Pay,Dovoli tiskanje pred plačilom
-DocType: Land Unit,Linked Soil Texture,Povezana tla teksture
-DocType: Shipping Rule,Shipping Account,Dostava račun
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92,{0} {1}: Account {2} is inactive,{0} {1}: račun {2} je neaktiven
-apps/erpnext/erpnext/utilities/activation.py +82,Make Sales Orders to help you plan your work and deliver on-time,"Naredite Prodajni nalogi, ki vam pomaga načrtovati svoje delo in poda na čas"
-DocType: Quality Inspection,Readings,Readings
-DocType: Stock Entry,Total Additional Costs,Skupaj Dodatni stroški
-DocType: Course Schedule,SH,SH
-DocType: BOM,Scrap Material Cost(Company Currency),Odpadni material Stroški (družba Valuta)
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66,Sub Assemblies,Sklope
-DocType: Asset,Asset Name,Ime sredstvo
-DocType: Project,Task Weight,naloga Teža
-DocType: Shipping Rule Condition,To Value,Do vrednosti
-DocType: Asset Movement,Stock Manager,Stock Manager
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +158,Source warehouse is mandatory for row {0},Vir skladišče je obvezna za vrstico {0}
-apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38,The Payment Term at row {0} is possibly a duplicate.,Izraz plačila v vrstici {0} je morda dvojnik.
-apps/erpnext/erpnext/public/js/setup_wizard.js +30,Agriculture (beta),Kmetijstvo (beta)
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +863,Packing Slip,Pakiranje listek
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Office Rent,Urad za najem
-apps/erpnext/erpnext/config/setup.py +111,Setup SMS gateway settings,Nastavitve Setup SMS gateway
-DocType: Disease,Common Name,Pogosto ime
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61,Import Failed!,Uvoz uspelo!
-apps/erpnext/erpnext/public/js/templates/address_list.html +20,No address added yet.,Še ni naslov dodal.
-DocType: Workstation Working Hour,Workstation Working Hour,Workstation delovno uro
-DocType: Vital Signs,Blood Pressure,Krvni pritisk
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125,Analyst,Analitik
-DocType: Item,Inventory,Popis
-DocType: Item,Sales Details,Prodajna Podrobnosti
-DocType: Quality Inspection,QI-,QI-
-DocType: Opportunity,With Items,Z Items
-DocType: Asset Maintenance,Maintenance Team,Vzdrževalna ekipa
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,V Kol
-DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Potrdite vpisanih tečaj za študente v študentskih skupine
-DocType: Notification Control,Expense Claim Rejected,Expense zahtevek zavrnjen
-DocType: Item,Item Attribute,Postavka Lastnost
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147,Government,Vlada
-apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40,Expense Claim {0} already exists for the Vehicle Log,Expense Zahtevek {0} že obstaja za Prijavi vozil
-apps/erpnext/erpnext/public/js/setup_wizard.js +64,Institute Name,Ime Institute
-apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117,Please enter repayment Amount,Vnesite odplačevanja Znesek
-apps/erpnext/erpnext/config/stock.py +309,Item Variants,Artikel Variante
-apps/erpnext/erpnext/public/js/setup_wizard.js +29,Services,Storitve
-DocType: HR Settings,Email Salary Slip to Employee,Email Plača Slip na zaposlenega
-DocType: Cost Center,Parent Cost Center,Parent Center Stroški
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1041,Select Possible Supplier,Izberite Možni Dobavitelj
-DocType: Sales Invoice,Source,Vir
-DocType: Customer,"Select, to make the customer searchable with these fields","Izberite, da bo stranka s temi področji omogočila iskanje"
-apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Prikaži zaprto
-DocType: Leave Type,Is Leave Without Pay,Se Leave brez plačila
-apps/erpnext/erpnext/stock/doctype/item/item.py +260,Asset Category is mandatory for Fixed Asset item,Sredstvo kategorije je obvezna za fiksno postavko sredstev
-DocType: Fee Validity,Fee Validity,Veljavnost pristojbine
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +146,No records found in the Payment table,Ni najdenih v tabeli plačil zapisov
-apps/erpnext/erpnext/education/utils.py +19,This {0} conflicts with {1} for {2} {3},Ta {0} ni v nasprotju s {1} za {2} {3}
-DocType: Student Attendance Tool,Students HTML,študenti HTML
-DocType: POS Profile,Apply Discount,Uporabi popust
-DocType: GST HSN Code,GST HSN Code,DDV HSN koda
-DocType: Employee External Work History,Total Experience,Skupaj Izkušnje
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,"Prosimo, nastavite številske serije za udeležbo preko Setup&gt; Series Numbering"
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70,Open Projects,Odprti projekti
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +295,Packing Slip(s) cancelled,Dobavnico (e) odpovedan
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +36,Cash Flow from Investing,Denarni tokovi iz naložbenja
-DocType: Program Course,Program Course,Tečaj programa
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,Freight and Forwarding Charges,Tovorni in Forwarding Stroški
-DocType: Homepage,Company Tagline for website homepage,Podjetje Slogan za domačo stran spletnega mesta
-DocType: Item Group,Item Group Name,Item Name Group
-apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Taken,Taken
-DocType: Student,Date of Leaving,Datum Leaving
-DocType: Pricing Rule,For Price List,Za cenik
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27,Executive Search,Executive Search
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55,Setting defaults,Nastavitev privzetih nastavitev
-apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,Ustvari Interesenti
-DocType: Maintenance Schedule,Schedules,Urniki
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +464,POS Profile is required to use Point-of-Sale,Profil POS je potreben za uporabo Point-of-Sale
-DocType: Purchase Invoice Item,Net Amount,Neto znesek
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +141,{0} {1} has not been submitted so the action cannot be completed,"{0} {1} ni bila vložena, dejanje ne more biti dokončano"
-DocType: Purchase Order Item Supplied,BOM Detail No,BOM Detail Ne
-DocType: Landed Cost Voucher,Additional Charges,dodatni stroški
-DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Dodatni popust Znesek (Valuta Company)
-DocType: Supplier Scorecard,Supplier Scorecard,Scorecard dobavitelja
-DocType: Plant Analysis,Result Datetime,Result Datetime
-apps/erpnext/erpnext/accounts/doctype/account/account.js +21,Please create new account from Chart of Accounts.,"Prosimo, ustvarite nov račun iz kontnega načrta."
-,Support Hour Distribution,Podpora Distribution Hour
-DocType: Maintenance Visit,Maintenance Visit,Vzdrževanje obisk
-DocType: Student,Leaving Certificate Number,Leaving Certificate Število
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +63,"Appointment cancelled, Please review and cancel the invoice {0}","Imenovanje je preklicano, preglejte in prekličite račun {0}"
-DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Dostopno Serija Količina na Warehouse
-apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Update Print Format,Update Print Format
-DocType: Landed Cost Voucher,Landed Cost Help,Pristali Stroški Pomoč
-DocType: Purchase Invoice,Select Shipping Address,Izbira naslova za dostavo
-apps/erpnext/erpnext/config/non_profit.py +28,Memebership Details,Podrobnosti o memorandumu
-DocType: Leave Block List,Block Holidays on important days.,Blokiranje Počitnice na pomembnih dni.
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +220,Please input all required Result Value(s),Vnesite vso zahtevano vrednost (-e)
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +94,Accounts Receivable Summary,Terjatve Povzetek
-DocType: Employee Loan,Monthly Repayment Amount,Mesečni Povračilo Znesek
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9,Opening Invoices,Odpiranje računov
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +195,Please set User ID field in an Employee record to set Employee Role,"Prosim, nastavite ID uporabnika polje v zapisu zaposlenih za določen Vloga zaposlenih"
-DocType: UOM,UOM Name,UOM Name
-DocType: GST HSN Code,HSN Code,Tarifna številka
-apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +39,Contribution Amount,Prispevek Znesek
-DocType: Purchase Invoice,Shipping Address,naslov za pošiljanje
-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 popravite količino in vrednotenje zalog v sistemu. To se ponavadi uporablja za sinhronizacijo sistemske vrednosti in kaj dejansko obstaja v vaših skladiščih.
-DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,"V besedi bo viden, ko boste shranite dobavnici."
-DocType: Expense Claim,EXP,EXP
-DocType: Water Analysis,Container,Zabojnik
-apps/erpnext/erpnext/education/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Študent {0} - {1} pojavi večkrat v vrsti {2} {3}
-DocType: Healthcare Settings,Manage Sample Collection,Upravljanje vzorčenja
-DocType: Production Plan,Ignore Existing Ordered Quantity,Prezri obstoječa naročena količina
-DocType: Patient,Tobacco Past Use,Pretekla uporaba tobaka
-DocType: Sales Invoice Item,Brand Name,Blagovna znamka
-DocType: Purchase Receipt,Transporter Details,Transporter Podrobnosti
-apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +65,User {0} is already assigned to Physician {1},Uporabnik {0} je že dodeljen zdravniku {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2684,Default warehouse is required for selected item,Privzeto skladišče je potrebna za izbrano postavko
-apps/erpnext/erpnext/utilities/user_progress.py +143,Box,Škatla
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1038,Possible Supplier,Možni Dobavitelj
-DocType: Budget,Monthly Distribution,Mesečni Distribution
-apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68,Receiver List is empty. Please create Receiver List,"Sprejemnik Seznam je prazen. Prosimo, da ustvarite sprejemnik seznam"
-apps/erpnext/erpnext/public/js/setup_wizard.js +31,Healthcare (beta),Zdravstvo (beta)
-DocType: Production Plan Sales Order,Production Plan Sales Order,Proizvodni načrt Sales Order
-DocType: Sales Partner,Sales Partner Target,Prodaja Partner Target
-DocType: Loan Type,Maximum Loan Amount,Največja Znesek posojila
-DocType: Pricing Rule,Pricing Rule,Cen Pravilo
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Podvojena številka rola študent {0}
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Podvojena številka rola študent {0}
-DocType: Budget,Action if Annual Budget Exceeded,"Ukrep, če letni proračun Prekoračitev"
-apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,Material Zahteva za narocilo
-DocType: Shopping Cart Settings,Payment Success URL,Plačilo Uspeh URL
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +80,Row # {0}: Returned Item {1} does not exists in {2} {3},Vrstica # {0}: Vrnjeno Postavka {1} ne obstaja v {2} {3}
-DocType: Purchase Receipt,PREC-,PREC-
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16,Bank Accounts,Bančni računi
-,Bank Reconciliation Statement,Izjava Bank Sprava
-DocType: Consultation,Medical Coding,Zdravniško kodiranje
-DocType: Healthcare Settings,Reminder Message,Opomnik
-,Lead Name,Ime ponudbe
-,POS,POS
-DocType: C-Form,III,III
-apps/erpnext/erpnext/config/stock.py +314,Opening Stock Balance,Odpiranje Stock Balance
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58,{0} must appear only once,{0} se morajo pojaviti le enkrat
-apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,Leaves Allocated Successfully for {0},Listi Dodeljena Uspešno za {0}
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42,No Items to pack,Ni prispevkov za pakiranje
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,"Prosimo, nastavite sistem imenovanja inštruktorja v izobraževanju&gt; Nastavitve izobraževanja"
-DocType: Shipping Rule Condition,From Value,Od vrednosti
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +593,Manufacturing Quantity is mandatory,Proizvodnja Količina je obvezna
-DocType: Employee Loan,Repayment Method,Povračilo Metoda
-DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Če je omogočeno, bo Naslovna stran je skupina privzeta točka za spletno stran"
-DocType: Quality Inspection Reading,Reading 4,Branje 4
-apps/erpnext/erpnext/config/hr.py +132,Claims for company expense.,Terjatve za račun družbe.
-apps/erpnext/erpnext/utilities/activation.py +118,"Students are at the heart of the system, add all your students","Študenti so v središču sistema, dodamo vse svoje učence"
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +81,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Row # {0}: Datum Potrditev {1} ne more biti pred Ček Datum {2}
-DocType: Asset Maintenance Task,Certificate Required,Zahtevano potrdilo
-DocType: Company,Default Holiday List,Privzeti seznam praznikov
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +196,Row {0}: From Time and To Time of {1} is overlapping with {2},Vrstica {0}: V času in času {1} se prekrivajo z {2}
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145,Stock Liabilities,Zaloga Obveznosti
-DocType: Purchase Invoice,Supplier Warehouse,Dobavitelj Skladišče
-DocType: Opportunity,Contact Mobile No,Kontaktna mobilna številka
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +395,Select Company,Izberite podjetje
-,Material Requests for which Supplier Quotations are not created,Material Prošnje za katere so Dobavitelj Citati ni ustvaril
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34,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 na vrstici {1} za tega uporabnika.
-DocType: Student Group,Set 0 for no limit,Nastavite 0 za brez omejitev
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +123,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,"Dan (s), na kateri se prijavljate za dopust, so prazniki. Vam ni treba zaprositi za dopust."
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64,Row {idx}: {field} is required to create the Opening {invoice_type} Invoices,Vrstica {idx}: {field} je potrebna za ustvarjanje računov za odpiranje {invoice_type}
-DocType: Customer,Primary Address and Contact Detail,Osnovni naslov in kontaktni podatki
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,Ponovno pošlji plačila Email
-apps/erpnext/erpnext/templates/pages/projects.html +27,New task,Nova naloga
-DocType: Consultation,Appointment,Imenovanje
-apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Naredite predračun
-apps/erpnext/erpnext/config/education.py +226,Other Reports,Druga poročila
-apps/erpnext/erpnext/public/js/setup_wizard.js +39,Please select at least one domain.,Izberite vsaj eno domeno.
-DocType: Dependent Task,Dependent Task,Odvisna Task
-apps/erpnext/erpnext/stock/doctype/item/item.py +443,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}"
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +189,Leave of type {0} cannot be longer than {1},Dopust tipa {0} ne more biti daljši od {1}
-DocType: Manufacturing Settings,Try planning operations for X days in advance.,Poskusite načrtovanju operacij za X dni vnaprej.
-DocType: HR Settings,Stop Birthday Reminders,Stop Birthday opomniki
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235,Please set Default Payroll Payable Account in Company {0},"Prosimo, nastavite privzetega izplačane plače je treba plačati račun v družbi {0}"
-DocType: SMS Center,Receiver List,Sprejemnik Seznam
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1093,Search Item,Iskanje Item
-DocType: Payment Schedule,Payment Amount,Znesek Plačila
-DocType: Patient Appointment,Referring Physician,Referenčni zdravnik
-apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Porabljeni znesek
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +100,Net Change in Cash,Neto sprememba v gotovini
-DocType: Assessment Plan,Grading Scale,Ocenjevalna lestvica
-apps/erpnext/erpnext/stock/doctype/item/item.py +437,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Merska enota {0} je v pretvorbeni faktor tabeli vpisana več kot enkrat
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +639,Already completed,že končana
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock In Hand,Zaloga v roki
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64,Import Successful!,Uvoz uspešno!
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29,Payment Request already exists {0},Plačilni Nalog že obstaja {0}
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Strošek izdanih postavk
-DocType: Physician,Hospital,Bolnišnica
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +385,Quantity must not be more than {0},Količina ne sme biti več kot {0}
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117,Previous Financial Year is not closed,Prejšnja Proračunsko leto ni zaprt
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46,Age (Days),Starost (dnevi)
-DocType: Quotation Item,Quotation Item,Postavka ponudbe
-DocType: Customer,Customer POS Id,ID POS stranka
-DocType: Account,Account Name,Ime računa
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40,From Date cannot be greater than To Date,Od datum ne more biti večja kot doslej
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198,Serial No {0} quantity {1} cannot be a fraction,Serijska št {0} količina {1} ne more biti del
-apps/erpnext/erpnext/config/buying.py +43,Supplier Type master.,Dobavitelj Type gospodar.
-DocType: Purchase Order Item,Supplier Part Number,Dobavitelj Številka dela
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108,Conversion rate cannot be 0 or 1,Menjalno razmerje ne more biti 0 ali 1
-DocType: Share Balance,To No,Na št
-DocType: Subscription,Reference Document,referenčni dokument
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +229,{0} {1} is cancelled or stopped,{0} {1} je preklican ali ustavljen
-DocType: Accounts Settings,Credit Controller,Credit Controller
-DocType: Grant Application,Applicant Type,Vrsta vlagatelja
-DocType: Purchase Invoice,03-Deficiency in services,03-Pomanjkanje storitev
-DocType: Delivery Note,Vehicle Dispatch Date,Vozilo Dispatch Datum
-DocType: Healthcare Settings,Default Medical Code Standard,Privzeti standard za medicinsko kodo
-DocType: Purchase Invoice Item,HSN/SAC,TARIC
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237,Purchase Receipt {0} is not submitted,Potrdilo o nakupu {0} ni predložila
-DocType: Company,Default Payable Account,Privzeto plačljivo račun
-apps/erpnext/erpnext/config/website.py +17,"Settings for online shopping cart such as shipping rules, price list etc.","Nastavitve za spletni košarici, kot so predpisi v pomorskem prometu, cenik itd"
-apps/erpnext/erpnext/controllers/website_list_for_contact.py +113,{0}% Billed,{0}% zaračunano
-apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18,Reserved Qty,Rezervirano Kol
-DocType: Party Account,Party Account,Račun Party
-apps/erpnext/erpnext/config/setup.py +122,Human Resources,Človeški viri
-DocType: Lead,Upper Income,Zgornja Prihodki
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17,Reject,Zavrni
-DocType: Journal Entry Account,Debit in Company Currency,Debetno v podjetju valuti
-DocType: BOM Item,BOM Item,BOM Postavka
-DocType: Appraisal,For Employee,Za zaposlenega
-apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49,Make Disbursement Entry,Naredite izplačilu vnos
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138,Row {0}: Advance against Supplier must be debit,Vrstica {0}: Advance zoper dobavitelja mora biti v breme
-DocType: Company,Default Values,Privzete vrednosti
-DocType: Membership,INR,INR
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60,{frequency} Digest,{frekvenca} izvleček
-DocType: Expense Claim,Total Amount Reimbursed,"Skupnega zneska, povrnjenega"
-apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5,This is based on logs against this Vehicle. See timeline below for details,Ta temelji na dnevnikih glede na ta vozila. Oglejte si časovnico spodaj za podrobnosti
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90,Against Supplier Invoice {0} dated {1},Zoper dobavitelja Račun {0} dne {1}
-DocType: Customer,Default Price List,Privzeto Cenik
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +322,Asset Movement record {0} created,zapis Gibanje sredstvo {0} ustvaril
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,"Ne, ne moreš brisati poslovnega leta {0}. Poslovno leto {0} je privzet v globalnih nastavitvah"
-apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,A customer with the same name already exists,Kupec z istim imenom že obstaja
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +185,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,To bo poslalo plačne liste in ustvarilo časovni razpored poročanja. Želite nadaljevati?
-DocType: Purchase Invoice,Total Net Weight,Skupna neto teža
-DocType: Purchase Invoice,Eligibility For ITC,Upravičenost do ITC
-DocType: Journal Entry,Entry Type,Začetek Type
-,Customer Credit Balance,Stranka Credit Balance
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +28,Net Change in Accounts Payable,Neto sprememba obveznosti do dobaviteljev
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48,EcritureLet,EcritureLet
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +216,Credit limit has been crossed for customer {0} ({1}/{2}),Kreditna meja je prešla za stranko {0} ({1} / {2})
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',Stranka zahteva za &quot;Customerwise popust&quot;
-apps/erpnext/erpnext/config/accounts.py +140,Update bank payment dates with journals.,Posodobite rok plačila banka s revijah.
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21,Pricing,Cenitev
-DocType: Quotation,Term Details,Izraz Podrobnosti
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,ne more vpisati več kot {0} študentov za to študentsko skupino.
-apps/erpnext/erpnext/templates/print_formats/includes/total.html +4,Total (Without Tax),Skupaj (brez davka)
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,svinec Štetje
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,svinec Štetje
-apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} mora biti večje od 0
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +30,Stock Available,Stock Na voljo
-DocType: Manufacturing Settings,Capacity Planning For (Days),Kapaciteta Načrtovanje Za (dnevi)
-apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10,Procurement,Javna naročila
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +66,None of the items have any change in quantity or value.,Nobena od postavk imate kakršne koli spremembe v količini ali vrednosti.
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17,Mandatory field - Program,Obvezno polje - program
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17,Mandatory field - Program,Obvezno polje - program
-DocType: Special Test Template,Result Component,Komponenta rezultata
-apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46,Warranty Claim,Garancija zahtevek
-,Lead Details,Podrobnosti ponudbe
-DocType: Volunteer,Availability and Skills,Razpoložljivost in spretnosti
-DocType: Salary Slip,Loan repayment,vračila posojila
-DocType: Purchase Invoice,End date of current invoice's period,Končni datum obdobja tekočega faktura je
-DocType: Pricing Rule,Applicable For,Velja za
-DocType: Lab Test,Technician Name,Ime tehnika
-DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Prekinitev povezave med Plačilo na Izbris računa
-apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Trenutni Stanje kilometrov vpisana mora biti večja od začetne števca prevožene poti vozila {0}
-DocType: Restaurant Reservation,No Show,Ni predstave
-DocType: Shipping Rule Country,Shipping Rule Country,Država dostavnega pravila
-apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10,Leave and Attendance,Pusti in postrežbo
-DocType: Maintenance Visit,Partially Completed,Delno Dopolnil
-apps/erpnext/erpnext/healthcare/setup.py +257,Moderate Sensitivity,Zmerna občutljivost
-DocType: Leave Type,Include holidays within leaves as leaves,Vključite počitnice v listih kot listja
-DocType: Sales Invoice,Packed Items,Pakirane Items
-apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Garancija zahtevek zoper Serial No.
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +192,'Total',&quot;Skupaj&quot;
-DocType: Shopping Cart Settings,Enable Shopping Cart,Omogoči Košarica
-DocType: Employee,Permanent Address,stalni naslov
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260,"Advance paid against {0} {1} cannot be greater \
-						than Grand Total {2}",Izplačano predplačilo proti {0} {1} ne more biti večja \ kot Grand Total {2}
-DocType: Patient,Medication,Zdravila
-DocType: Production Plan,Include Non Stock Items,Vključite elemente brez zaloge
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147,Please select item code,"Prosimo, izberite postavko kodo"
-DocType: Student Sibling,Studying in Same Institute,Študij v istem inštitutu
-DocType: Territory,Territory Manager,Ozemlje Manager
-DocType: Packed Item,To Warehouse (Optional),Da Warehouse (po želji)
-DocType: GST Settings,GST Accounts,GST računi
-DocType: Payment Entry,Paid Amount (Company Currency),Plačan znesek (družba Valuta)
-DocType: Purchase Invoice,Additional Discount,Dodatni popust
-DocType: Selling Settings,Selling Settings,Prodaja Nastavitve
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83,Confirm Action,Potrdi dejanje
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39,Online Auctions,Online Dražbe
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +100,Please specify either Quantity or Valuation Rate or both,"Prosimo, navedite bodisi količina ali Ocenite vrednotenja ali oboje"
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18,Fulfillment,izpolnitev
-apps/erpnext/erpnext/templates/generators/item.html +82,View in Cart,Poglej v košarico
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103,Marketing Expenses,Marketing Stroški
-,Item Shortage Report,Postavka Pomanjkanje Poročilo
-apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py +15,Can't create standard criteria. Please rename the criteria,Ne morem ustvariti standardnih meril. Preimenujte merila
-apps/erpnext/erpnext/stock/doctype/item/item.js +282,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Teža je omenjeno, \ nProsim omenja &quot;Teža UOM&quot; preveč"
-DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Material Zahteva se uporablja za izdelavo tega staleža Entry
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Naslednja Amortizacija Datum je obvezna za nove investicije
-DocType: Student Group Creation Tool,Separate course based Group for every Batch,Ločeno Group s sedežem tečaj za vsako serijo
-DocType: Student Group Creation Tool,Separate course based Group for every Batch,Ločeno Group s sedežem tečaj za vsako serijo
-apps/erpnext/erpnext/config/support.py +32,Single unit of an Item.,Enotni enota točke.
-DocType: Fee Category,Fee Category,Fee Kategorija
-DocType: Agriculture Task,Next Business Day,Naslednji delovni dan
-DocType: Drug Prescription,Dosage by time interval,Odmerjanje po časovnem intervalu
-DocType: Cash Flow Mapper,Section Header,Naslov glave
-,Student Fee Collection,Študent Fee Collection
-apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +23,Appointment Duration (mins),Trajanje imenovanja (min)
-DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Naredite vknjižba Za vsako borzno gibanje
-DocType: Leave Allocation,Total Leaves Allocated,Skupaj Listi Dodeljena
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163,Warehouse required at Row No {0},Skladišče zahteva pri Row št {0}
-apps/erpnext/erpnext/public/js/setup_wizard.js +145,Please enter valid Financial Year Start and End Dates,"Prosimo, vnesite veljaven proračunsko leto, datum začetka in konca"
-DocType: Employee,Date Of Retirement,Datum upokojitve
-DocType: Upload Attendance,Get Template,Get predlogo
-DocType: Material Request,Transferred,Preneseni
-DocType: Vehicle,Doors,vrata
-apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117,ERPNext Setup Complete!,ERPNext Setup Complete!
-DocType: Healthcare Settings,Collect Fee for Patient Registration,Zberi pristojbino za registracijo pacientov
-apps/erpnext/erpnext/stock/doctype/item/item.py +677,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Ne morem spremeniti atributov po transakciji z delnicami. Na novo postavko naredite nov element in prenesite zalogo
-DocType: Course Assessment Criteria,Weightage,Weightage
-DocType: Purchase Invoice,Tax Breakup,davčna Breakup
-DocType: Packing Slip,PS-,PS-
-DocType: Member,Non Profit Member,Neprofitni član
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67,{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 zahtevano za ""Izkaz poslovnega izida"" računa {2}. Nastavite privzeto stroškovno mesto za družbo."
-DocType: Payment Schedule,Payment Term,Pogoji plačila
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +167,A Customer Group exists with same name please change the Customer name or rename the Customer Group,"A Skupina kupcev obstaja z istim imenom, prosimo spremenite ime stranke ali preimenovati skupino odjemalcev"
-DocType: Land Unit,Area,Območje
-apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Nov kontakt
-DocType: Territory,Parent Territory,Parent Territory
-DocType: Purchase Invoice,Place of Supply,Kraj dobave
-DocType: Quality Inspection Reading,Reading 2,Branje 2
-DocType: Stock Entry,Material Receipt,Material Prejem
-DocType: Homepage,Products,Izdelki
-DocType: Announcement,Instructor,inštruktor
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61,Select Item (optional),Izberite postavko (neobvezno)
-DocType: Fee Schedule Student Group,Fee Schedule Student Group,Skupina študijskih ur
-DocType: Student,AB+,AB +
-DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Če ima ta postavka variante, potem ne more biti izbran v prodajnih naročil itd"
-DocType: Lead,Next Contact By,Naslednja Kontakt Z
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +324,Quantity required for Item {0} in row {1},"Količina, potrebna za postavko {0} v vrstici {1}"
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +46,Warehouse {0} can not be deleted as quantity exists for Item {1},"Skladišče {0} ni mogoče izbrisati, kot obstaja količina za postavko {1}"
-DocType: Quotation,Order Type,Sklep Type
-,Item-wise Sales Register,Element-pametno Sales Registriraj se
-DocType: Asset,Gross Purchase Amount,Bruto znesek nakupa
-apps/erpnext/erpnext/utilities/user_progress.py +36,Opening Balances,Začetne stave
-DocType: Asset,Depreciation Method,Metoda amortiziranja
-DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Je to DDV vključen v osnovni stopnji?
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,Skupaj Target
-DocType: Soil Texture,Sand Composition (%),Sestava peska (%)
-DocType: Job Applicant,Applicant for a Job,Kandidat za službo
-DocType: Production Plan Material Request,Production Plan Material Request,Proizvodnja Zahteva načrt Material
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231,No Production Orders created,Ni Proizvodne Naročila ustvarjena
-DocType: Stock Reconciliation,Reconciliation JSON,Uskladitev JSON
-apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,Preveč stolpcev. Izvoziti poročilo in ga natisnete s pomočjo aplikacije za preglednice.
-DocType: Purchase Invoice Item,Batch No,Serija Ne
-DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Dovoli več prodajnih nalogov zoper naročnikovo narocilo
-DocType: Student Group Instructor,Student Group Instructor,Inštruktor Študent Skupina
-DocType: Student Group Instructor,Student Group Instructor,Inštruktor Študent Skupina
-DocType: Grant Application,Assessment  Mark (Out of 10),Ocenjevalna oznaka (od 10)
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Skrbnika2 Mobile No
-apps/erpnext/erpnext/setup/doctype/company/company.py +218,Main,Main
-apps/erpnext/erpnext/stock/doctype/item/item.js +72,Variant,Variant
-DocType: Naming Series,Set prefix for numbering series on your transactions,Nastavite predpona za številčenje serij na vaše transakcije
-DocType: Employee Attendance Tool,Employees HTML,zaposleni HTML
-apps/erpnext/erpnext/stock/doctype/item/item.py +457,Default BOM ({0}) must be active for this item or its template,Privzeto BOM ({0}) mora biti aktiven za to postavko ali njeno predlogo
-DocType: Employee,Leave Encashed?,Dopusta unovčijo?
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Priložnost Iz polja je obvezno
-DocType: Email Digest,Annual Expenses,letni stroški
-DocType: Item,Variants,Variante
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1139,Make Purchase Order,Naredite narocilo
-DocType: SMS Center,Send To,Pošlji
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +134,There is not enough leave balance for Leave Type {0},Ni dovolj bilanca dopust za dopust tipa {0}
-DocType: Payment Reconciliation Payment,Allocated amount,Dodeljen znesek
-DocType: Sales Team,Contribution to Net Total,Prispevek k Net Total
-DocType: Sales Invoice Item,Customer's Item Code,Koda artikla stranke
-DocType: Stock Reconciliation,Stock Reconciliation,Uskladitev zalog
-DocType: Territory,Territory Name,Territory Name
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +204,Work-in-Progress Warehouse is required before Submit,Work-in-Progress Warehouse je pred potreben Submit
-apps/erpnext/erpnext/config/hr.py +40,Applicant for a Job.,Kandidat za službo.
-DocType: Purchase Order Item,Warehouse and Reference,Skladišče in Reference
-DocType: Supplier,Statutory info and other general information about your Supplier,Statutarna info in druge splošne informacije o vašem dobavitelju
-DocType: Item,Serial Nos and Batches,Serijska št in Serije
-DocType: Item,Serial Nos and Batches,Serijska št in Serije
-apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Študent Skupina moč
-apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Študent Skupina moč
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +256,Against Journal Entry {0} does not have any unmatched {1} entry,Proti listu Začetek {0} nima neprimerljivo {1} vnos
-apps/erpnext/erpnext/config/hr.py +142,Appraisals,cenitve
-apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8,Training Events,Dogodki za usposabljanje
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205,Duplicate Serial No entered for Item {0},Podvajati Zaporedna številka vpisana v postavko {0}
-DocType: Shipping Rule Condition,A condition for a Shipping Rule,Pogoj za Shipping pravilu
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +167,Please enter ,vnesite
-apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43,Maintenance Log,Dnevnik vzdrževanja
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +236,Please set filter based on Item or Warehouse,"Prosim, nastavite filter, ki temelji na postavki ali skladišče"
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Koda postavke&gt; Skupina izdelkov&gt; Blagovna znamka
-DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Neto teža tega paketa. (samodejno izračuna kot vsota neto težo blaga)
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +798,Discount amount cannot be greater than 100%,Znesek popusta ne sme biti večji od 100%
-DocType: Sales Order,To Deliver and Bill,Dostaviti in Bill
-DocType: Student Group,Instructors,inštruktorji
-DocType: GL Entry,Credit Amount in Account Currency,Credit Znesek v Valuta računa
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +598,BOM {0} must be submitted,BOM {0} je treba predložiti
-apps/erpnext/erpnext/config/accounts.py +460,Share Management,Deljeno upravljanje
-DocType: Authorization Control,Authorization Control,Pooblastilo za nadzor
-apps/erpnext/erpnext/controllers/buying_controller.py +327,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Vrstica # {0}: zavrnitev Skladišče je obvezno proti zavrnil postavki {1}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810,Payment,Plačilo
-apps/erpnext/erpnext/controllers/stock_controller.py +92,"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, navedite račun v evidenco skladišče ali nastavite privzeto inventarja račun v družbi {1}."
-apps/erpnext/erpnext/utilities/activation.py +81,Manage your orders,Upravljajte naročila
-DocType: Production Order Operation,Actual Time and Cost,Dejanski čas in stroški
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +56,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Material Zahteva za največ {0} se lahko izvede za postavko {1} proti Sales Order {2}
-DocType: Crop,Crop Spacing,Razmik rastlin
-DocType: Course,Course Abbreviation,Kratica za tečaj
-DocType: Student Leave Application,Student Leave Application,Študent Zapusti Uporaba
-DocType: Item,Will also apply for variants,Bo veljalo tudi za variante
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +217,"Asset cannot be cancelled, as it is already {0}","Sredstvo ni mogoče preklicati, saj je že {0}"
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} on Half day on {1},Zaposlenih {0} v pol dneva na {1}
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42,Total working hours should not be greater than max working hours {0},Skupaj delovni čas ne sme biti večja od max delovnih ur {0}
-apps/erpnext/erpnext/templates/pages/task_info.html +90,On,na
-apps/erpnext/erpnext/config/selling.py +62,Bundle items at time of sale.,Bundle predmeti v času prodaje.
-DocType: Material Request Plan Item,Actual Qty,Dejanska Količina
-DocType: Sales Invoice Item,References,Reference
-DocType: Quality Inspection Reading,Reading 10,Branje 10
-DocType: Item,Barcodes,Črtne kode
-DocType: Hub Category,Hub Node,Vozliščna točka
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,"Vnesli ste podvojene elemente. Prosimo, popravite in poskusite znova."
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129,Associate,Sodelavec
-DocType: Asset Movement,Asset Movement,Gibanje sredstvo
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2199,New Cart,Nova košarico
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,Postavka {0} ni serialized postavka
-DocType: SMS Center,Create Receiver List,Ustvarite sprejemnik seznam
-DocType: Vehicle,Wheels,kolesa
-DocType: Packing Slip,To Package No.,Če želite Paket No.
-DocType: Patient Relation,Family,Družina
-DocType: Production Plan,Material Requests,Material Zahteve
-DocType: Warranty Claim,Issue Date,Datum izdaje
-DocType: Activity Cost,Activity Cost,Stroški dejavnost
-DocType: Sales Invoice Timesheet,Timesheet Detail,timesheet Podrobnosti
-DocType: Purchase Receipt Item Supplied,Consumed Qty,Porabljeno Kol
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52,Telecommunications,Telekomunikacije
-apps/erpnext/erpnext/accounts/party.py +264,Billing currency must be equal to either default company's currency or party account currency,Valuta za obračun mora biti enaka valuti podjetja ali valuti stranke
-DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),"Kaže, da je paket del tega dostave (samo osnutka)"
-DocType: Soil Texture,Loam,Loam
-apps/erpnext/erpnext/controllers/accounts_controller.py +700,Row {0}: Due Date cannot be before posting date,Vrstica {0}: Datum roka ne more biti pred datumom objavljanja
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36,Make Payment Entry,Naredite Entry plačila
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129,Quantity for Item {0} must be less than {1},Količina za postavko {0} sme biti manjša od {1}
-,Sales Invoice Trends,Prodajni fakturi Trendi
-DocType: Leave Application,Apply / Approve Leaves,Uporabi / Odobri Leaves
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,For,Za
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +167,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Lahko sklicuje vrstico le, če je tip naboj &quot;Na prejšnje vrstice Znesek&quot; ali &quot;prejšnje vrstice Total&quot;"
-DocType: Sales Order Item,Delivery Warehouse,Dostava Skladišče
-apps/erpnext/erpnext/config/accounts.py +241,Tree of financial Cost Centers.,Drevo centrov finančnih stroškov.
-DocType: Serial No,Delivery Document No,Dostava dokument št
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Prosim nastavite &quot;dobiček / izguba račun pri odtujitvi sredstev&quot; v družbi {0}
-DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Dobili predmetov iz nakupa Prejemki
-DocType: Serial No,Creation Date,Datum nastanka
-apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33,Item {0} appears multiple times in Price List {1},Postavka {0} pojavi večkrat v Ceniku {1}
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41,"Selling must be checked, if Applicable For is selected as {0}","Prodajanje je treba preveriti, če se uporablja za izbrana kot {0}"
-DocType: Production Plan Material Request,Material Request Date,Material Zahteva Datum
-DocType: Purchase Order Item,Supplier Quotation Item,Dobavitelj Kotacija Postavka
-DocType: Manufacturing Settings,Disables creation of time logs against Production Orders. Operations shall not be tracked against Production Order,Onemogoči oblikovanje časovnih dnevnikov proti proizvodnji naročil. Operacije se ne gosenicami proti Production reda
-DocType: Student,Student Mobile Number,Študent mobilno številko
-DocType: Item,Has Variants,Ima različice
-apps/erpnext/erpnext/controllers/accounts_controller.py +487,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Za postavko {0} v vrstici {1} ne moremo preseči več kot {2}. Če želite omogočiti prekomerno zaračunavanje, nastavite nastavitve zalog"
-apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Posodobi odgovor
-apps/erpnext/erpnext/public/js/utils.js +232,You have already selected items from {0} {1},Ste že izbrane postavke iz {0} {1}
-DocType: Monthly Distribution,Name of the Monthly Distribution,Ime mesečnim izplačilom
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +95,Batch ID is mandatory,Serija ID je obvezen
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +95,Batch ID is mandatory,Serija ID je obvezen
-DocType: Sales Person,Parent Sales Person,Nadrejena Sales oseba
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +100,The seller and the buyer cannot be the same,Prodajalec in kupec ne moreta biti isti
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24,Select the program first,Najprej izberite program
-DocType: Patient Appointment,Patient Age,Pacientova doba
-apps/erpnext/erpnext/config/learn.py +253,Managing Projects,Upravljanje projektov
-DocType: Supplier,Supplier of Goods or Services.,Dobavitelj blaga ali storitev.
-DocType: Budget,Fiscal Year,Poslovno leto
-DocType: Asset Maintenance Log,Planned,Načrtovano
-DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Consultation charges.,"Neplačani računi za terjatve, ki jih je treba uporabiti, če niso določeni v Patientu za rezervacijo stroškov posvetovanja."
-DocType: Vehicle Log,Fuel Price,gorivo Cena
-DocType: Budget,Budget,Proračun
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +51,Set Open,Nastavi odprto
-apps/erpnext/erpnext/stock/doctype/item/item.py +257,Fixed Asset Item must be a non-stock item.,Osnovno sredstvo točka mora biti postavka ne-stock.
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Proračun ne more biti dodeljena pred {0}, ker to ni prihodek ali odhodek račun"
-apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,Doseženi
-DocType: Student Admission,Application Form Route,Prijavnica pot
-apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66,Territory / Customer,Territory / Stranka
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44,Leave Type {0} cannot be allocated since it is leave without pay,"Pusti tipa {0} ni mogoče dodeliti, ker je zapustil brez plačila"
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +167,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},"Vrstica {0}: Dodeljena količina {1}, mora biti manjša ali enaka zaračunati neodplačanega {2}"
-DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,"V besedi bo viden, ko boste prihranili prodajni fakturi."
-DocType: Lead,Follow Up,Nadaljuj
-DocType: Item,Is Sales Item,Je Sales Postavka
-apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21,Item Group Tree,Element Group Tree
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69,Item {0} is not setup for Serial Nos. Check Item master,Postavka {0} ni setup za Serijska št. Preverite item mojster
-DocType: Maintenance Visit,Maintenance Time,Vzdrževanje čas
-,Amount to Deliver,"Znesek, Deliver"
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +334,Same item has been entered multiple times. {0},Isti element je bil večkrat vnesen. {0}
-apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +30,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 izraz začetka ne more biti zgodnejši od datuma Leto začetku študijskega leta, v katerem je izraz povezan (študijsko leto {}). Popravite datum in poskusite znova."
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +190,There were errors.,Tam so bile napake.
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +167,Employee {0} has already applied for {1} between {2} and {3} : ,Zaposleni {0} je že zaprosil za {1} med {2} in {3}:
-DocType: Guardian,Guardian Interests,Guardian Zanima
-DocType: Naming Series,Current Value,Trenutna vrednost
-apps/erpnext/erpnext/controllers/accounts_controller.py +272,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,"obstaja več proračunskih let za datum {0}. Prosim, nastavite podjetje v poslovnem letu"
-DocType: Education Settings,Instructor Records to be created by,"Zapise za inštruktorje, ki jih bo ustvaril"
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229,{0} created,{0} ustvaril
-DocType: GST Account,GST Account,GST račun
-DocType: Delivery Note Item,Against Sales Order,Za Naročilo Kupca
-,Serial No Status,Serijska Status Ne
-DocType: Payment Entry Reference,Outstanding,Izjemna
-DocType: Supplier,Warn POs,Opozori PO
-,Daily Timesheet Summary,Dnevni Timesheet Povzetek
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137,"Row {0}: To set {1} periodicity, difference between from and to date \
-						must be greater than or equal to {2}","Vrstica {0}: nastavi {1} periodičnost, razlika med od do sedaj \ mora biti večja od ali enaka {2}"
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,Ta temelji na gibanju zalog. Glej {0} za podrobnosti
-DocType: Pricing Rule,Selling,Prodaja
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +385,Amount {0} {1} deducted against {2},Znesek {0} {1} odšteti pred {2}
-DocType: Employee,Salary Information,Plača Informacije
-DocType: Sales Person,Name and Employee ID,Ime in zaposlenih ID
-apps/erpnext/erpnext/accounts/party.py +309,Due Date cannot be before Posting Date,Rok ne more biti pred datumom knjiženja
-DocType: Website Item Group,Website Item Group,Spletna stran Element Group
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +458,No salary slip found to submit for the above selected criteria OR salary slip already submitted,"Za zgoraj navedena izbrana merila ILI plačilni list, ki je že bil predložen, ni bilo mogoče najti nobene plačilne liste"
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Duties and Taxes,Dajatve in davki
-DocType: Projects Settings,Projects Settings,Nastavitve projektov
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356,Please enter Reference date,Vnesite Referenčni datum
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44,{0} payment entries can not be filtered by {1},{0} vnosov plačil ni mogoče filtrirati s {1}
-DocType: Item Website Specification,Table for Item that will be shown in Web Site,"Tabela za postavko, ki bo prikazana na spletni strani"
-DocType: Purchase Order Item Supplied,Supplied Qty,Priložena Kol
-DocType: Purchase Order Item,Material Request Item,Material Zahteva Postavka
-apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Drevo skupin artiklov.
-DocType: Production Plan,Total Produced Qty,Skupno število proizvedenih količin
-DocType: Payroll Entry,Get Employee Details,Pridobite podrobnosti o zaposlenih
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177,Cannot refer row number greater than or equal to current row number for this Charge type,Ne more sklicevati številko vrstice večja ali enaka do trenutne številke vrstice za to vrsto Charge
-DocType: Asset,Sold,Prodano
-,Item-wise Purchase History,Element-pametno Zgodovina nakupov
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Prosimo, kliknite na &quot;ustvarjajo Seznamu&quot; puščati Serijska št dodal za postavko {0}"
-DocType: Account,Frozen,Frozen
-,Open Production Orders,Odprte Proizvodne Naročila
-DocType: Sales Invoice Payment,Base Amount (Company Currency),Osnovna Znesek (družba Valuta)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +919,Raw Materials,Surovine
-DocType: Payment Reconciliation Payment,Reference Row,referenčna Row
-DocType: Installation Note,Installation Time,Namestitev čas
-DocType: Sales Invoice,Accounting Details,Računovodstvo Podrobnosti
-apps/erpnext/erpnext/setup/doctype/company/company.js +113,Delete all the Transactions for this Company,Izbriši vse transakcije za to družbo
-DocType: Patient,O Positive,O Pozitivno
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +204,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,"Vrstica # {0}: Operacija {1} ni končana, za {2} Kol končnih izdelkov v proizvodnji naročite # {3}. Prosimo, posodobite statusa delovanja preko Čas Dnevniki"
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Investments,Naložbe
-DocType: Issue,Resolution Details,Resolucija Podrobnosti
-apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,dodelitve
-DocType: Item Quality Inspection Parameter,Acceptance Criteria,Merila sprejemljivosti
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159,Please enter Material Requests in the above table,Vnesite Material Prošnje v zgornji tabeli
-DocType: Item Attribute,Attribute Name,Ime atributa
-DocType: BOM,Show In Website,Pokaži V Website
-DocType: Shopping Cart Settings,Show Quantity in Website,Prikaži Količina na spletni strani
-DocType: Employee Loan Application,Total Payable Amount,Skupaj plačljivo Znesek
-DocType: Task,Expected Time (in hours),Pričakovani čas (v urah)
-DocType: Item Reorder,Check in (group),Preverite v (skupina)
-DocType: Soil Texture,Silt,Silt
-,Qty to Order,Količina naročiti
-DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Glava račun v odgovornosti ali kapitala, v katerem se bo dobiček / izguba rezervirana"
-apps/erpnext/erpnext/config/projects.py +31,Gantt chart of all tasks.,Ganttov diagram vseh nalog.
-DocType: Opportunity,Mins to First Response,Minut do prvega odziva
-DocType: Pricing Rule,Margin Type,Margin Type
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15,{0} hours,{0} ur
-DocType: Course,Default Grading Scale,Privzeti Ocenjevalna lestvica
-DocType: Appraisal,For Employee Name,Za imena zaposlenih
-DocType: Holiday List,Clear Table,Počisti tabelo
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +106,Available slots,Razpoložljive slote
-DocType: C-Form Invoice Detail,Invoice No,Račun št
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +350,Make Payment,Plačam
-DocType: Room,Room Name,soba Ime
-DocType: Prescription Duration,Prescription Duration,Trajanje recepta
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +82,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Pustite se ne more uporabiti / preklicana pred {0}, saj je bilanca dopust že-carry posredujejo v evidenco dodeljevanja dopust prihodnji {1}"
-DocType: Activity Cost,Costing Rate,Stanejo Rate
-apps/erpnext/erpnext/config/selling.py +229,Customer Addresses And Contacts,Naslovi strank in kontakti
-,Campaign Efficiency,kampanja Učinkovitost
-DocType: Discussion,Discussion,Diskusija
-DocType: Payment Entry,Transaction ID,Transaction ID
-DocType: Volunteer,Anytime,Kadarkoli
-DocType: Patient,Surgical History,Kirurška zgodovina
-DocType: Employee,Resignation Letter Date,Odstop pismo Datum
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,Pricing Rules are further filtered based on quantity.,Cenovne Pravila so dodatno filtriran temelji na količini.
-apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +131,Not Set,Ni nastavljeno
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +334,Please set the Date Of Joining for employee {0},"Prosimo, da določi datum Vstop za zaposlenega {0}"
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +334,Please set the Date Of Joining for employee {0},"Prosimo, da določi datum Vstop za zaposlenega {0}"
-DocType: Task,Total Billing Amount (via Time Sheet),Skupni znesek plačevanja (preko Čas lista)
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Ponovite Customer Prihodki
-DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
-DocType: Chapter,Chapter,Poglavje
-apps/erpnext/erpnext/utilities/user_progress.py +143,Pair,Par
-DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,"Privzet račun se samodejno posodablja v računu POS, ko je ta način izbran."
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +961,Select BOM and Qty for Production,Izberite BOM in Količina za proizvodnjo
-DocType: Asset,Depreciation Schedule,Amortizacija Razpored
-apps/erpnext/erpnext/config/selling.py +124,Sales Partner Addresses And Contacts,Prodaja Partner naslovi in kontakti
-DocType: Bank Reconciliation Detail,Against Account,Proti račun
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Dobavitelj&gt; Dobavitelj tip
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +53,Half Day Date should be between From Date and To Date,Poldnevni datum mora biti med Od datuma in Do datuma
-DocType: Maintenance Schedule Detail,Actual Date,Dejanski datum
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +139,Please set the Default Cost Center in {0} company.,Center za privzete stroške nastavite v {0} podjetju.
-DocType: Item,Has Batch No,Ima številko serije
-apps/erpnext/erpnext/public/js/utils.js +106,Annual Billing: {0},Letni obračun: {0}
-apps/erpnext/erpnext/config/accounts.py +200,Goods and Services Tax (GST India),Davčna blago in storitve (DDV Indija)
-DocType: Delivery Note,Excise Page Number,Trošarinska Številka strani
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +227,"Company, From Date and To Date is mandatory","Podjetje, od datuma do datuma je obvezen"
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33,Get from Consultation,Pojdite s posvetovanja
-DocType: Asset,Purchase Date,Datum nakupa
-DocType: Volunteer,Volunteer Type,Volunteer Type
-DocType: Student,Personal Details,Osebne podrobnosti
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193,Please set 'Asset Depreciation Cost Center' in Company {0},Prosim nastavite &quot;Asset Center Amortizacija stroškov&quot; v družbi {0}
-,Maintenance Schedules,Vzdrževanje Urniki
-DocType: Task,Actual End Date (via Time Sheet),Dejanski končni datum (preko Čas lista)
-DocType: Soil Texture,Soil Type,Vrsta tal
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +380,Amount {0} {1} against {2} {3},Znesek {0} {1} proti {2} {3}
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +277,New Message,Novo sporočilo
-,Quotation Trends,Trendi ponudb
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +160,Item Group not mentioned in item master for item {0},"Element Group, ki niso navedeni v točki mojster za postavko {0}"
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +368,Debit To account must be a Receivable account,Bremenitev računa mora biti Terjatve račun
-DocType: Shipping Rule,Shipping Amount,Znesek Dostave
-DocType: Supplier Scorecard Period,Period Score,Obdobje obdobja
-apps/erpnext/erpnext/utilities/user_progress.py +63,Add Customers,Dodaj stranke
-apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Pending Amount,Dokler Znesek
-DocType: Lab Test Template,Special,Poseben
-DocType: Purchase Order Item Supplied,Conversion Factor,Faktor pretvorbe
-DocType: Purchase Order,Delivered,Dostavljeno
-,Vehicle Expenses,Stroški vozil
-DocType: Serial No,Invoice Details,Podrobnosti na računu
-DocType: Grant Application,Show on Website,Prikaži na spletni strani
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +212,Expected value after useful life must be greater than or equal to {0},"Pričakovana vrednost po življenjski dobi, mora biti večja ali enaka {0}"
-apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29,Start on,Začni
-DocType: Hub Category,Hub Category,Kategorija vozlišča
-DocType: Purchase Invoice,SEZ,SEZ
-DocType: Purchase Receipt,Vehicle Number,Število vozil
-DocType: Employee Loan,Loan Amount,Znesek posojila
-apps/erpnext/erpnext/utilities/user_progress.py +88,Add Letterhead,Dodaj slovo
-DocType: Program Enrollment,Self-Driving Vehicle,Self-Vožnja vozil
-DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Stalni ocenjevalni list dobavitelja
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +442,Row {0}: Bill of Materials not found for the Item {1},Vrstica {0}: Kosovnica nismo našli v postavki {1}
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98,Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,Skupaj dodeljena listi {0} ne sme biti manjši od že odobrenih listov {1} za obdobje
-DocType: Journal Entry,Accounts Receivable,Terjatve
-,Supplier-Wise Sales Analytics,Dobavitelj-Wise Prodajna Analytics
-DocType: Purchase Invoice,Availed ITC Central Tax,Uporabil centralni davčni sistem za ITC
-DocType: Salary Structure,Select employees for current Salary Structure,Izberite zaposlenih za sedanje strukture plač
-DocType: Sales Invoice,Company Address Name,Naslov podjetja Ime
-DocType: Production Order,Use Multi-Level BOM,Uporabite Multi-Level BOM
-DocType: Bank Reconciliation,Include Reconciled Entries,Vključi usklajene vnose
-DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Matično igrišče (pustite prazno, če to ni del obvladujoče Course)"
-DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Matično igrišče (pustite prazno, če to ni del obvladujoče Course)"
-DocType: Leave Control Panel,Leave blank if considered for all employee types,"Pustite prazno, če velja za vse vrste zaposlenih"
-DocType: Landed Cost Voucher,Distribute Charges Based On,Distribuirajo pristojbin na podlagi
-DocType: Projects Settings,Timesheets,Evidence prisotnosti
-DocType: HR Settings,HR Settings,Nastavitve človeških virov
-DocType: Salary Slip,net pay info,net info plačilo
-DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Ta vrednost se posodablja na seznamu Privzeta prodajna cena.
-DocType: Email Digest,New Expenses,Novi stroški
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +79,PDC/LC Amount,PDC / LC Znesek
-DocType: Shareholder,Shareholder,Delničar
-DocType: Purchase Invoice,Additional Discount Amount,Dodatni popust Količina
-DocType: Cash Flow Mapper,Position,Položaj
-DocType: Patient,Patient Details,Podrobnosti bolnika
-DocType: Patient,B Positive,B Pozitivni
-apps/erpnext/erpnext/controllers/accounts_controller.py +595,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Row # {0}: Kol mora biti 1, kot točka je osnovno sredstvo. Prosimo, uporabite ločeno vrstico za večkratno Kol."
-DocType: Leave Block List Allow,Leave Block List Allow,Pustite Block List Dovoli
-apps/erpnext/erpnext/setup/doctype/company/company.py +317,Abbr can not be blank or space,Abbr ne more biti prazna ali presledek
-DocType: Patient Medical Record,Patient Medical Record,Zdravniški zapis bolnika
-apps/erpnext/erpnext/accounts/doctype/account/account.js +68,Group to Non-Group,Skupina Non-Group
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50,Sports,Šport
-DocType: Loan Type,Loan Name,posojilo Ime
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Actual,Skupaj Actual
-DocType: Lab Test UOM,Test UOM,Test UOM
-DocType: Student Siblings,Student Siblings,Študentski Bratje in sestre
-apps/erpnext/erpnext/utilities/user_progress.py +143,Unit,Enota
-apps/erpnext/erpnext/stock/get_item_details.py +138,Please specify Company,"Prosimo, navedite Company"
-,Customer Acquisition and Loyalty,Stranka Pridobivanje in zvestobe
-DocType: Asset Maintenance Task,Maintenance Task,Vzdrževalna naloga
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +118,Please set B2C Limit in GST Settings.,Nastavite omejitev B2C v nastavitvah GST.
-DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,"Skladišče, kjer ste vzdrževanje zalog zavrnjenih predmetov"
-DocType: Production Order,Skip Material Transfer,Preskoči Material Transfer
-DocType: Production Order,Skip Material Transfer,Preskoči Material Transfer
-apps/erpnext/erpnext/setup/utils.py +109,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Mogoče najti menjalni tečaj za {0} in {1} za ključ datumu {2}. Prosimo ustvariti zapis Valuta Exchange ročno
-DocType: POS Profile,Price List,Cenik
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +22,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,"{0} je zdaj privzeto poslovno leto. Prosimo, osvežite brskalnik, da se sprememba uveljavi."
-apps/erpnext/erpnext/projects/doctype/task/task.js +45,Expense Claims,Odhodkov Terjatve
-DocType: Issue,Support,Podpora
-,BOM Search,BOM Iskanje
-DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.","Objavite &quot;Na zalogi&quot; ali &quot;Ni na zalogi&quot; na vozlišču na podlagi zalog, ki so na voljo v tem skladišču."
-DocType: Vehicle,Fuel Type,Vrsta goriva
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27,Please specify currency in Company,"Prosimo, navedite valuto v družbi"
-DocType: Workstation,Wages per hour,Plače na uro
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Stock ravnotežje Serija {0} bo postal negativen {1} za postavko {2} v skladišču {3}
-apps/erpnext/erpnext/templates/emails/reorder_item.html +1,Following Material Requests have been raised automatically based on Item's re-order level,Po Material Zahteve so bile samodejno dvigne temelji na ravni re-naročilnico elementa
-DocType: Email Digest,Pending Sales Orders,Dokler prodajnih naročil
-apps/erpnext/erpnext/controllers/accounts_controller.py +311,Account {0} is invalid. Account Currency must be {1},Račun {0} ni veljaven. Valuta računa mora biti {1}
-DocType: Healthcare Settings,Remind Before,Opomni pred
-apps/erpnext/erpnext/buying/utils.py +34,UOM Conversion factor is required in row {0},Faktor UOM Pretvorba je potrebno v vrstici {0}
-DocType: Production Plan Item,material_request_item,material_request_item
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1060,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Row # {0}: Reference Vrsta dokumenta mora biti eden od prodajnega naloga, prodaje računa ali Journal Entry"
-DocType: Salary Component,Deduction,Odbitek
-DocType: Item,Retain Sample,Ohrani vzorec
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,Row {0}: From Time and To Time is mandatory.,Vrstica {0}: Od časa in do časa je obvezna.
-DocType: Stock Reconciliation Item,Amount Difference,znesek Razlika
-apps/erpnext/erpnext/stock/get_item_details.py +356,Item Price added for {0} in Price List {1},Postavka Cena dodana za {0} v Ceniku {1}
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,Vnesite ID Employee te prodaje oseba
-DocType: Territory,Classification of Customers by region,Razvrstitev stranke po regijah
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71,In Production,V izdelavi
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +60,Difference Amount must be zero,Razlika Znesek mora biti nič
-DocType: Project,Gross Margin,Gross Margin
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +61,Please enter Production Item first,"Prosimo, da najprej vnesete Production artikel"
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Calculated Bank Statement balance,Izračunan Izjava bilance banke
-DocType: Normal Test Template,Normal Test Template,Običajna preskusna predloga
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,onemogočena uporabnik
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +919,Quotation,Ponudba
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +984,Cannot set a received RFQ to No Quote,Prejeti RFQ ni mogoče nastaviti na nobeno ceno
-DocType: Quotation,QTN-,QTN-
-DocType: Salary Slip,Total Deduction,Skupaj Odbitek
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +18,Select an account to print in account currency,"Izberite račun, ki ga želite natisniti v valuti računa"
-,Production Analytics,proizvodne Analytics
-apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6,This is based on transactions against this Patient. See timeline below for details,To temelji na transakcijah proti temu bolniku. Podrobnosti si oglejte spodaj
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +203,Cost Updated,Stroškovno Posodobljeno
-DocType: Patient,Date of Birth,Datum rojstva
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +129,Item {0} has already been returned,Postavka {0} je bil že vrnjen
-DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,**Poslovno leto** predstavlja knjigovodsko leto. Vse vknjižbe in druge transakcije so povezane s **poslovnim letom**.
-DocType: Opportunity,Customer / Lead Address,Stranka / Naslov ponudbe
-DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Nastavitev kazalčevega kazalnika
-apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Ime načrta ocenjevanja
-apps/erpnext/erpnext/stock/doctype/item/item.py +232,Warning: Invalid SSL certificate on attachment {0},Opozorilo: Neveljavno potrdilo SSL za pritrditev {0}
-apps/erpnext/erpnext/utilities/activation.py +64,"Leads help you get business, add all your contacts and more as your leads","Interesenti vam pomaga dobiti posel, dodamo vse svoje stike in več kot vaše vodi"
-DocType: Production Order Operation,Actual Operation Time,Dejanska Operacija čas
-DocType: Authorization Rule,Applicable To (User),Ki se uporabljajo za (Uporabnik)
-DocType: Purchase Taxes and Charges,Deduct,Odbitka
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +237,Job Description,Opis dela
-DocType: Student Applicant,Applied,Applied
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +865,Re-open,Re-open
-DocType: Sales Invoice Item,Qty as per Stock UOM,Kol. kot na UOM
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Ime skrbnika2
-DocType: Purchase Invoice,02-Post Sale Discount,Popust za prodajo po pošti
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +127,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Posebni znaki razen ""-"" ""."", ""#"", in ""/"" niso dovoljeni v poimenovanju zaporedja"
-DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Spremljajte prodajnih akcij. Spremljajte Interesenti, citatov, Sales Order itd iz akcije, da bi ocenili donosnost naložbe."
-,SO Qty,SO Kol
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +91,The field To Shareholder cannot be blank,Polje Delničarju ne more biti prazno
-DocType: Guardian,Work Address,Delovni naslov
-DocType: Appraisal,Calculate Total Score,Izračunaj skupni rezultat
-DocType: Asset Repair,Manufacturing Manager,Proizvodnja Manager
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191,Serial No {0} is under warranty upto {1},Serijska št {0} je pod garancijo stanuje {1}
-DocType: Plant Analysis Criteria,Minimum Permissible Value,Najmanjša dovoljena vrednost
-apps/erpnext/erpnext/education/doctype/guardian/guardian.py +41,User {0} already exists,Uporabnik {0} že obstaja
-apps/erpnext/erpnext/hooks.py +109,Shipments,Pošiljke
-DocType: Payment Entry,Total Allocated Amount (Company Currency),Skupaj Dodeljena Znesek (družba Valuta)
-DocType: Purchase Order Item,To be delivered to customer,Ki jih je treba dostaviti kupcu
-DocType: BOM,Scrap Material Cost,Stroški odpadnega materiala
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227,Serial No {0} does not belong to any Warehouse,Serijska št {0} ne pripada nobeni Warehouse
-DocType: Grant Application,Email Notification Sent,Poslano obvestilo o e-pošti
-DocType: Purchase Invoice,In Words (Company Currency),V besedi (družba Valuta)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1009,"Item Code, warehouse, quantity are required on row","Koda postavke, skladišče, količina sta potrebna v vrstici"
-DocType: Pricing Rule,Supplier,Dobavitelj
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41,Show Payment Details,Prikaži podatke o plačilu
-DocType: Consultation,Consultation Time,Čas posvetovanja
-DocType: C-Form,Quarter,Quarter
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Miscellaneous Expenses,Razni stroški
-DocType: Global Defaults,Default Company,Privzeto Podjetje
-apps/erpnext/erpnext/controllers/stock_controller.py +227,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Odhodek ali Razlika račun je obvezna za postavko {0} saj to vpliva na skupna vrednost zalog
-DocType: Payment Request,PR,PR
-DocType: Cheque Print Template,Bank Name,Ime Banke
-apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +29,-Above,-Nad
-DocType: Employee Loan,Employee Loan Account,Zaposlenih Loan račun
-DocType: Leave Application,Total Leave Days,Skupaj dni dopusta
-DocType: Email Digest,Note: Email will not be sent to disabled users,Opomba: E-mail ne bo poslano uporabnike invalide
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Število interakcij
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Število interakcij
-apps/erpnext/erpnext/stock/doctype/item/item.js +105,Item Variant Settings,Nastavitve različice postavke
-apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +39,Select Company...,Izberite Company ...
-DocType: Leave Control Panel,Leave blank if considered for all departments,"Pustite prazno, če velja za vse oddelke"
-apps/erpnext/erpnext/config/hr.py +228,"Types of employment (permanent, contract, intern etc.).","Vrste zaposlitve (trajna, pogodbeni, intern itd)."
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434,{0} is mandatory for Item {1},{0} je obvezen za postavko {1}
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +136,"Item {0}: {1} qty produced, ","Postavka {0}: {1} proizvedena količina,"
-DocType: Payroll Entry,Fortnightly,vsakih štirinajst dni
-DocType: Currency Exchange,From Currency,Iz valute
-DocType: Vital Signs,Weight (In Kilogram),Teža (v kilogramih)
-DocType: Chapter,"chapters/chapter_name
-leave blank automatically set after saving chapter.",poglavja / poglavje_name pustite samodejno nastaviti prazno po shranjevanju poglavja.
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +202,Please set GST Accounts in GST Settings,Nastavite GST račune v nastavitvah GST
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +31,Type of Business,Vrsta podjetja
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +171,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Prosimo, izberite Dodeljeni znesek, fakture Vrsta in številka računa v atleast eno vrstico"
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128,Cost of New Purchase,Stroški New Nakup
-apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +35,All tasks for the detected diseases were imported,Uvažale so se vse naloge za odkrite bolezni
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97,Sales Order required for Item {0},Sales Order potreben za postavko {0}
-DocType: Grant Application,Grant Description,Grant Opis
-DocType: Purchase Invoice Item,Rate (Company Currency),Oceni (družba Valuta)
-DocType: Student Guardian,Others,Drugi
-DocType: Payment Entry,Unallocated Amount,nerazporejena Znesek
-apps/erpnext/erpnext/templates/includes/product_page.js +90,Cannot find a matching Item. Please select some other value for {0}.,"Ne morete najti ujemanja artikel. Prosimo, izberite kakšno drugo vrednost za {0}."
-DocType: POS Profile,Taxes and Charges,Davki in dajatve
-DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Izdelek ali storitev, ki je kupil, prodal ali jih hranijo na zalogi."
-apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44,No more updates,Nič več posodobitve
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Ne morete izbrati vrsto naboja kot &quot;On prejšnje vrstice Znesek&quot; ali &quot;Na prejšnje vrstice Total&quot; za prvi vrsti
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6,This covers all scorecards tied to this Setup,"To zajema vse kazalnike, povezane s tem Setup"
-apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Otrok točka ne bi smela biti izdelka Bundle. Odstranite element &#39;{0}&#39; in shranite
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12,Banking,Bančništvo
-apps/erpnext/erpnext/utilities/activation.py +108,Add Timesheets,Dodaj časovnice
-DocType: Vehicle Service,Service Item,Service Element
-DocType: Bank Guarantee,Bank Guarantee,Bančna garancija
-DocType: Bank Guarantee,Bank Guarantee,Bančna garancija
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,"Prosimo, kliknite na &quot;ustvarjajo Seznamu&quot;, da bi dobili razpored"
-DocType: Bin,Ordered Quantity,Naročeno Količina
-apps/erpnext/erpnext/public/js/setup_wizard.js +118,"e.g. ""Build tools for builders""",npr &quot;Build orodja za gradbenike&quot;
-DocType: Grading Scale,Grading Scale Intervals,Ocenjevalna lestvica intervali
-apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Profit for the year,Dobiček za leto
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: računovodski zapis za {2} se lahko zapiše le v valuti: {3}
-DocType: Fee Schedule,In Process,V postopku
-DocType: Authorization Rule,Itemwise Discount,Itemwise Popust
-apps/erpnext/erpnext/config/accounts.py +75,Tree of financial accounts.,Drevo finančnih računov.
-DocType: Cash Flow Mapping,Cash Flow Mapping,Kartiranje denarnih tokov
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364,{0} against Sales Order {1},{0} za Naročilnico {1}
-DocType: Account,Fixed Asset,Osnovno sredstvo
-apps/erpnext/erpnext/config/stock.py +324,Serialized Inventory,Zaporednimi Inventory
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74,Email not found in default contact,V privzetem stiku ni mogoče najti e-pošte
-DocType: Employee Loan,Account Info,Informacije o računu
-DocType: Activity Type,Default Billing Rate,Privzeto Oceni plačevanja
-DocType: Fees,Include Payment,Vključi plačilo
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} skupine študentov ustvarjene
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} skupine študentov ustvarjene
-DocType: Sales Invoice,Total Billing Amount,Skupni znesek plačevanja
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50,Program in the Fee Structure and Student Group {0} are different.,Program v strukturi pristojbin in študentski skupini {0} je drugačen.
-DocType: Fee Schedule,Receivable Account,Terjatev račun
-apps/erpnext/erpnext/controllers/accounts_controller.py +617,Row #{0}: Asset {1} is already {2},Row # {0}: Asset {1} je že {2}
-DocType: Quotation Item,Stock Balance,Stock Balance
-apps/erpnext/erpnext/config/selling.py +316,Sales Order to Payment,Sales Order do plačila
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123,CEO,direktor
-DocType: Purchase Invoice,With Payment of Tax,S plačilom davka
-DocType: Expense Claim Detail,Expense Claim Detail,Expense Zahtevek Detail
-DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,Trojnih dobavitelja
-DocType: Land Unit,Is Container,Je kontejner
-DocType: Crop Cycle,This will be day 1 of the crop cycle,To bo dan 1 ciklusa poljščin
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +871,Please select correct account,"Prosimo, izberite ustrezen račun"
-DocType: Purchase Invoice Item,Weight UOM,Teža UOM
-apps/erpnext/erpnext/config/accounts.py +466,List of available Shareholders with folio numbers,Seznam razpoložljivih delničarjev s številkami folije
-DocType: Salary Structure Employee,Salary Structure Employee,Struktura Plač zaposlenih
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45,Show Variant Attributes,Prikaži lastnosti različic
-DocType: Student,Blood Group,Blood Group
-DocType: Course,Course Name,Ime predmeta
-DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,"Uporabniki, ki lahko potrdijo zahtevke zapustiti določenega zaposlenega"
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52,Office Equipments,Pisarniška oprema
-DocType: Purchase Invoice Item,Qty,Kol.
-DocType: Fiscal Year,Companies,Podjetja
-DocType: Supplier Scorecard,Scoring Setup,Nastavitev točkovanja
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,Electronics
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +326,Debit ({0}),Debet ({0})
-DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Dvignite Material Zahtevaj ko stock doseže stopnjo ponovnega naročila
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98,Full-time,Polni delovni čas
-DocType: Payroll Entry,Employees,zaposleni
-DocType: Employee,Contact Details,Kontaktni podatki
-DocType: C-Form,Received Date,Prejela Datum
-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 prodaji davkov in dajatev predlogo, izberite eno in kliknite na gumb spodaj."
-DocType: BOM Scrap Item,Basic Amount (Company Currency),Osnovni znesek (družba Valuta)
-DocType: Student,Guardians,skrbniki
-DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,"Cene se ne bodo pokazale, če Cenik ni nastavljen"
-DocType: Stock Entry,Total Incoming Value,Skupaj Dohodni Vrednost
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362,Debit To is required,Bremenitev je potrebno
-apps/erpnext/erpnext/utilities/activation.py +109,"Timesheets help keep track of time, cost and billing for activites done by your team","Timesheets pomaga slediti časa, stroškov in zaračunavanje za aktivnostmi s svojo ekipo, podpisan"
-apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Nakup Cenik
-apps/erpnext/erpnext/config/buying.py +155,Templates of supplier scorecard variables.,Predloge spremenljivk rezultatov dobaviteljev.
-DocType: Job Offer Term,Offer Term,Ponudba Term
-DocType: Asset,Quality Manager,Quality Manager
-DocType: Job Applicant,Job Opening,Job Otvoritev
-DocType: Payment Reconciliation,Payment Reconciliation,Uskladitev plačil
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153,Please select Incharge Person's name,"Prosimo, izberite ime zadolžen osebe"
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51,Technology,Tehnologija
-DocType: Hub Settings,Unregister from Hub,Odjavite se iz Hub
-apps/erpnext/erpnext/public/js/utils.js +108,Total Unpaid: {0},Skupaj neplačano: {0}
-DocType: BOM Website Operation,BOM Website Operation,BOM Spletna stran Operacija
-apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Production Orders.,Ustvarjajo Materialne zahteve (MRP) in naročila za proizvodnjo.
-DocType: Supplier Scorecard,Supplier Score,Ocen dobavitelja
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +208,Total Invoiced Amt,Skupaj Fakturna Amt
-DocType: Supplier,Warn RFQs,Opozori RFQs
-DocType: BOM,Conversion Rate,Stopnja konverzije
-apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Iskanje
-DocType: Assessment Plan,To Time,Time
-DocType: Authorization Rule,Approving Role (above authorized value),Odobritvi vloge (nad pooblaščeni vrednosti)
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118,Credit To account must be a Payable account,Credit Za računu mora biti plačljivo račun
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,"Prosimo, izberite Študentski Pristop, ki je obvezen za študenta, ki plača študent"
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +348,BOM recursion: {0} cannot be parent or child of {2},BOM rekurzija: {0} ne more biti starš ali otrok {2}
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +21,Please select a Price List to publish pricing,Izberite cenik za objavo cen
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38,Budget List,Proračunski seznam
-DocType: Production Order Operation,Completed Qty,Končano število
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148,"For {0}, only debit accounts can be linked against another credit entry","Za {0}, lahko le debetne račune povezati proti drugemu knjiženje"
-apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27,Price List {0} is disabled,Seznam Cena {0} je onemogočena
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127,Row {0}: Completed Qty cannot be more than {1} for operation {2},Vrstica {0}: Zaključen Količina ne sme biti večja od {1} za delovanje {2}
-DocType: Manufacturing Settings,Allow Overtime,Dovoli Nadurno delo
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Zaporednimi Postavka {0} ni mogoče posodobiti s pomočjo zaloge sprave, uporabite zaloge Entry"
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Zaporednimi Postavka {0} ni mogoče posodobiti s pomočjo zaloge sprave, uporabite zaloge Entry"
-DocType: Training Event Employee,Training Event Employee,Dogodek usposabljanje zaposlenih
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1017,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Največje vzorce - {0} lahko hranite za paket {1} in element {2}.
-apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +6,Add Time Slots,Dodaj časovne reže
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} serijska(e) številka(e) zahtevana(e) za postavko {1}. Navedli ste {2}.
-DocType: Stock Reconciliation Item,Current Valuation Rate,Trenutni tečaj Vrednotenje
-DocType: Item,Customer Item Codes,Stranka Postavka Kode
-DocType: Training Event,Advance,Napredovanje
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,for making recurring again.,za ponovni ponovitev.
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122,Exchange Gain/Loss,Exchange dobiček / izguba
-DocType: Opportunity,Lost Reason,Lost Razlog
-apps/erpnext/erpnext/controllers/accounts_controller.py +264,Row #{0}: Account {1} does not belong to company {2},Vrstica # {0}: Račun {1} ne pripada podjetju {2}
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +30,Unable to find DocType {0},Datoteke DocType {0} ni mogoče najti
-apps/erpnext/erpnext/public/js/templates/address_list.html +22,New Address,New Naslov
-DocType: Quality Inspection,Sample Size,Velikost vzorca
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47,Please enter Receipt Document,Vnesite Prejem dokumenta
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +369,All items have already been invoiced,Vsi predmeti so bili že obračunano
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49,Please specify a valid 'From Case No.',"Prosimo, navedite veljaven &quot;Od zadevi št &#39;"
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24,Further cost centers can be made under Groups but entries can be made against non-Groups,"Nadaljnje stroškovna mesta se lahko izvede v skupinah, vendar vnosi lahko zoper niso skupin"
-apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Uporabniki in dovoljenja
-DocType: Vehicle Log,VLOG.,Vlog.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +996,Production Orders Created: {0},Naročila za proizvodnjo Ustvarjen: {0}
-DocType: Branch,Branch,Branch
-DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
-DocType: Delivery Trip,Fulfillment User,Uporabnik izpolnjevanja
-apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Tiskanje in Branding
-DocType: Company,Total Monthly Sales,Skupna mesečna prodaja
-DocType: Agriculture Analysis Criteria,Weather,Vreme
-DocType: Bin,Actual Quantity,Dejanska količina
-DocType: Shipping Rule,example: Next Day Shipping,Primer: Next Day Shipping
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187,Serial No {0} not found,Serijska št {0} ni bilo mogoče najti
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +291,Subscription has been {0},Naročnina je bila {0}
-DocType: Fee Schedule Program,Fee Schedule Program,Program urnika
-DocType: Fee Schedule Program,Student Batch,študent serije
-apps/erpnext/erpnext/utilities/activation.py +119,Make Student,Naredite Študent
-DocType: Supplier Scorecard Scoring Standing,Min Grade,Min razred
-apps/erpnext/erpnext/projects/doctype/project/project.py +216,You have been invited to collaborate on the project: {0},Ti so bili povabljeni k sodelovanju na projektu: {0}
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +135,Physician not available on {0},Zdravnik ni na voljo na {0}
-DocType: Leave Block List Date,Block Date,Block Datum
-DocType: Crop,Crop,Pridelek
-DocType: Purchase Receipt,Supplier Delivery Note,Opomba: dobavitelj dostava
-apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70,Apply Now,Prijavi se zdaj
-apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Dejanska Kol {0} / čakajoči Kol {1}
-apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Dejanska Kol {0} / čakajoči Kol {1}
-DocType: Purchase Invoice,E-commerce GSTIN,E-trgovina GSTIN
-DocType: Sales Order,Not Delivered,Ne Delivered
-,Bank Clearance Summary,Banka Potrditev Povzetek
-apps/erpnext/erpnext/config/setup.py +106,"Create and manage daily, weekly and monthly email digests.","Ustvarjanje in upravljanje dnevne, tedenske in mesečne email prebavlja."
-DocType: Appraisal Goal,Appraisal Goal,Cenitev cilj
-DocType: Stock Reconciliation Item,Current Amount,Trenutni znesek
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58,Buildings,zgradbe
-DocType: Fee Schedule,Fee Structure,Fee Struktura
-DocType: Timesheet Detail,Costing Amount,Stanejo Znesek
-DocType: Student Admission Program,Application Fee,Fee uporaba
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +52,Submit Salary Slip,Predloži plačilni list
-apps/erpnext/erpnext/controllers/selling_controller.py +136,Maxiumm discount for Item {0} is {1}%,Maxiumm popust za Element {0} je {1}%
-apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Uvoz v razsutem stanju
-DocType: Sales Partner,Address & Contacts,Naslov &amp; Kontakti
-DocType: SMS Log,Sender Name,Sender Name
-DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Kriteriji za analizo kmetijstva
-DocType: POS Profile,[Select],[Izberite]
-DocType: Vital Signs,Blood Pressure (diastolic),Krvni tlak (diastolični)
-DocType: SMS Log,Sent To,Poslano
-DocType: Agriculture Task,Holiday Management,Upravljanje praznikov
-DocType: Payment Request,Make Sales Invoice,Naredi račun
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61,Softwares,Programska oprema
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +51,Next Contact Date cannot be in the past,Naslednja Stik datum ne more biti v preteklosti
-DocType: Company,For Reference Only.,Samo za referenco.
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +99,Physician {0} not available on {1},Zdravnik {0} ni na voljo {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2565,Select Batch No,Izberite Serija št
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +61,Invalid {0}: {1},Neveljavna {0}: {1}
-,GSTR-1,GSTR-1
-DocType: Purchase Invoice,PINV-RET-,PINV-RET-
-DocType: Fee Validity,Reference Inv,Reference Inv
-DocType: Sales Invoice Advance,Advance Amount,Advance Znesek
-DocType: Manufacturing Settings,Capacity Planning,Načrtovanje zmogljivosti
-DocType: Supplier Quotation,Rounding Adjustment (Company Currency,Prilagajanje zaokroževanja (Valuta podjetja
-apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43,'From Date' is required,"Zahtevano je ""Od datuma"""
-DocType: Journal Entry,Reference Number,Referenčna številka
-DocType: Employee,Employment Details,Podatki o zaposlitvi
-DocType: Employee,New Workplace,Novo delovno mesto
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Nastavi kot Zaprto
-apps/erpnext/erpnext/stock/get_item_details.py +127,No Item with Barcode {0},Ne Postavka s črtno kodo {0}
-DocType: Normal Test Items,Require Result Value,Zahtevajte vrednost rezultata
-DocType: Item,Show a slideshow at the top of the page,Prikaži diaprojekcijo na vrhu strani
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +527,Boms,Boms
-apps/erpnext/erpnext/stock/doctype/item/item.py +161,Stores,Trgovine
-DocType: Project Type,Projects Manager,Projekti Manager
-DocType: Serial No,Delivery Time,Čas dostave
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,"Staranje, ki temelji na"
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +66,Appointment cancelled,Imenovanje je preklicano
-DocType: Item,End of Life,End of Life
-apps/erpnext/erpnext/demo/setup/setup_data.py +331,Travel,Potovanja
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +182,No active or default Salary Structure found for employee {0} for the given dates,"Ni aktivnega ali privzeti plač struktura, ugotovljena za zaposlenega {0} za datumoma"
-DocType: Leave Block List,Allow Users,Dovoli uporabnike
-DocType: Purchase Order,Customer Mobile No,Stranka Mobile No
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1,Recurring,Ponavljajoči
-DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Podrobnosti o predlogi za kartiranje denarnega toka
-DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Sledi ločeno prihodki in odhodki za vertikal proizvodov ali delitve.
-DocType: Rename Tool,Rename Tool,Preimenovanje orodje
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72,Update Cost,Posodobitev Stroški
-DocType: Item Reorder,Item Reorder,Postavka Preureditev
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463,Show Salary Slip,Prikaži Plača listek
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +849,Transfer Material,Prenos Material
-DocType: Fees,Send Payment Request,Pošiljanje zahtevka za plačilo
-DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Določite operacij, obratovalne stroške in daje edinstveno Operacija ni na vaše poslovanje."
-DocType: Water Analysis,Origin,Izvor
-apps/erpnext/erpnext/controllers/status_updater.py +201,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,"Ta dokument je nad mejo, ki jo {0} {1} za postavko {4}. Delaš drugo {3} zoper isto {2}?"
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1154,Please set recurring after saving,"Prosim, nastavite ponavljajočih se po shranjevanju"
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +769,Select change amount account,znesek računa Izberite sprememba
-DocType: Purchase Invoice,Price List Currency,Cenik Valuta
-DocType: Naming Series,User must always select,Uporabnik mora vedno izbrati
-DocType: Stock Settings,Allow Negative Stock,Dovoli Negative Stock
-DocType: Installation Note,Installation Note,Namestitev Opomba
-DocType: Soil Texture,Clay,Glina
-DocType: Topic,Topic,tema
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +45,Cash Flow from Financing,Denarni tok iz financiranja
-DocType: Budget Account,Budget Account,proračun računa
-DocType: Quality Inspection,Verified By,Verified by
-apps/erpnext/erpnext/setup/doctype/company/company.py +78,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Ne more spremeniti privzeto valuto družbe, saj so obstoječi posli. Transakcije se treba odpovedati, da spremenite privzeto valuto."
-DocType: Cash Flow Mapping,Is Income Tax Liability,Je obveznost dohodnine
-DocType: Grading Scale Interval,Grade Description,razred Opis
-DocType: Stock Entry,Purchase Receipt No,Potrdilo o nakupu Ne
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,Kapara
-DocType: Sales Invoice, Shipping Bill Number,Številka naročila
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,sledljivost
-DocType: Asset Maintenance Log,Actions performed,Izvedeni ukrepi
-DocType: Cash Flow Mapper,Section Leader,Oddelek Leader
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137,Source of Funds (Liabilities),Vir sredstev (obveznosti)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +418,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Količina v vrstici {0} ({1}) mora biti enaka kot je bila proizvedena količina {2}
-DocType: Supplier Scorecard Scoring Standing,Employee,Zaposleni
-DocType: Asset Repair,Failure Date,Datum odpovedi
-DocType: Sample Collection,Collected Time,Zbrani čas
-DocType: Company,Sales Monthly History,Mesečna zgodovina prodaje
-DocType: Asset Maintenance Task,Next Due Date,Naslednji datum roka
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214,Select Batch,Izberite Serija
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244,{0} {1} is fully billed,{0} {1} je v celoti zaračunano
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +47,Vital Signs,Življenjski znaki
-DocType: Training Event,End Time,Končni čas
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,Active Salary Structure {0} found for employee {1} for the given dates,Aktivne Struktura Plača {0} ugotovljeno za delavca {1} za dane termin
-DocType: Payment Entry,Payment Deductions or Loss,Plačilni Odbitki ali izguba
-DocType: Soil Analysis,Soil Analysis Criterias,Kriteriji za analizo tal
-apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Standardni pogodbeni pogoji za prodajo ali nakup.
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +100,Group by Voucher,Skupina kupon
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +195,Are you sure you want to cancel this appointment?,"Ali ste prepričani, da želite preklicati ta sestanek?"
-DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Paket hotelskih cen
-apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,prodaja Pipeline
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201,Please set default account in Salary Component {0},"Prosim, nastavite privzetega računa v plač komponento {0}"
-apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Zahtevani Na
-DocType: Rename Tool,File to Rename,Datoteka za preimenovanje
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200,Please select BOM for Item in Row {0},Izberite BOM za postavko v vrstici {0}
-apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account {0} does not match with Company {1} in Mode of Account: {2},Račun {0} ne ujema z družbo {1} v načinu račun: {2}
-apps/erpnext/erpnext/controllers/buying_controller.py +289,Specified BOM {0} does not exist for Item {1},Določeno BOM {0} ne obstaja za postavko {1}
-DocType: Soil Texture,Sandy Loam,Sandy Loam
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Vzdrževanje Urnik {0} je treba odpovedati pred preklicem te Sales Order
-DocType: POS Profile,Applicable for Users,Uporabno za uporabnike
-DocType: Notification Control,Expense Claim Approved,Expense Zahtevek Odobreno
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +320,Salary Slip of employee {0} already created for this period,Plača Slip delavca {0} že ustvarili za to obdobje
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155,Pharmaceutical,Pharmaceutical
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Vrednost kupljenih artiklov
-DocType: Selling Settings,Sales Order Required,Zahtevano je naročilo
-DocType: Purchase Invoice,Credit To,Kredit
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46,PieceDate,PieceDate
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31,Active Leads / Customers,Aktivne ponudbe / Stranke
-DocType: Employee Education,Post Graduate,Post Graduate
-DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Vzdrževanje Urnik Detail
-DocType: Supplier Scorecard,Warn for new Purchase Orders,Opozori na nova naročila
-DocType: Quality Inspection Reading,Reading 9,Branje 9
-DocType: Supplier,Is Frozen,Je zamrznjena
-apps/erpnext/erpnext/stock/utils.py +224,Group node warehouse is not allowed to select for transactions,Skupina vozlišče skladišče ni dovoljeno izbrati za transakcije
-DocType: Buying Settings,Buying Settings,Nastavitve nabave
-DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM No. za Končni Good postavki
-DocType: Upload Attendance,Attendance To Date,Udeležba na tekočem
-DocType: Request for Quotation Supplier,No Quote,Brez cenika
-DocType: Warranty Claim,Raised By,Raised By
-DocType: Payment Gateway Account,Payment Account,Plačilo računa
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +909,Please specify Company to proceed,"Prosimo, navedite Company nadaljevati"
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +27,Net Change in Accounts Receivable,Neto sprememba terjatev do kupcev
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88,Compensatory Off,Kompenzacijske Off
-DocType: Job Offer,Accepted,Sprejeto
-DocType: Grant Application,Organization,organizacija
-DocType: Grant Application,Organization,organizacija
-DocType: BOM Update Tool,BOM Update Tool,Orodje za posodobitev BOM
-DocType: SG Creation Tool Course,Student Group Name,Ime študent Group
-apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js +17,Show exploded view,Pokaži eksplodiran pogled
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Ustvarjanje pristojbin
-apps/erpnext/erpnext/setup/doctype/company/company.js +91,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.,"Prosimo, preverite, ali ste prepričani, da želite izbrisati vse posle, za te družbe. Vaši matični podatki bodo ostali kot je. Ta ukrep ni mogoče razveljaviti."
-apps/erpnext/erpnext/templates/pages/product_search.html +21,Search Results,Rezultati iskanja
-DocType: Room,Room Number,Številka sobe
-apps/erpnext/erpnext/utilities/transaction_base.py +103,Invalid reference {0} {1},Neveljavna referenčna {0} {1}
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +187,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) ne more biti večji od načrtovanih količin ({2}) v Naročilu proizvodnje {3}
-DocType: Shipping Rule,Shipping Rule Label,Oznaka dostavnega pravila
-DocType: Journal Entry Account,Payroll Entry,Vnos plače
-apps/erpnext/erpnext/setup/doctype/company/company.js +35,Make Tax Template,Naredi davčno predlogo
-apps/erpnext/erpnext/public/js/conf.js +28,User Forum,Uporabniški forum
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +318,Raw Materials cannot be blank.,Surovine ne more biti prazno.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +498,"Could not update stock, invoice contains drop shipping item.","Ni mogel posodobiti vozni park, faktura vsebuje padec element ladijskega prometa."
-DocType: Lab Test Sample,Lab Test Sample,Vzorec laboratorijskega testa
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +491,Quick Journal Entry,Hitro Journal Entry
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200,You can not change rate if BOM mentioned agianst any item,"Vi stopnje ni mogoče spremeniti, če BOM omenjeno agianst vsako postavko"
-DocType: Restaurant,Invoice Series Prefix,Predpisi serije računov
-DocType: Employee,Previous Work Experience,Prejšnja Delovne izkušnje
-DocType: Stock Entry,For Quantity,Za Količino
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205,Please enter Planned Qty for Item {0} at row {1},Vnesite načrtovanih Količina za postavko {0} v vrstici {1}
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +93,Google Maps integration is not enabled,Integracija Google Zemljevidov ni omogočena
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241,{0} {1} is not submitted,{0} {1} ni vložen
-DocType: Member,Membership Expiry Date,Datum prenehanja članstva
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +127,{0} must be negative in return document,{0} mora biti negativno na povratnem dokumentu
-,Minutes to First Response for Issues,Minut do prvega odziva na vprašanja
-DocType: Purchase Invoice,Terms and Conditions1,Pogoji in razmer1
-apps/erpnext/erpnext/public/js/setup_wizard.js +109,The name of the institute for which you are setting up this system.,"Ime zavoda, za katerega vzpostavitev tega sistema."
-DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Vknjižba zamrzniti do tega datuma, nihče ne more narediti / spremeniti vnos razen vlogi določeno spodaj."
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116,Please save the document before generating maintenance schedule,"Prosimo, shranite dokument pred ustvarjanjem razpored vzdrževanja"
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30,Latest price updated in all BOMs,Najnovejša cena posodobljena v vseh BOM
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Stanje projekta
-DocType: UOM,Check this to disallow fractions. (for Nos),"Preverite, da je to prepoveste frakcij. (za številkami)"
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +446,The following Production Orders were created:,so bile oblikovane naslednje naročila za proizvodnjo:
-DocType: Student Admission Program,Naming Series (for Student Applicant),Poimenovanje Series (za Student prijavitelja)
-DocType: Delivery Note,Transporter Name,Transporter Name
-DocType: Authorization Rule,Authorized Value,Dovoljena vrednost
-DocType: BOM,Show Operations,prikaži Operations
-,Minutes to First Response for Opportunity,Minut do prvega odziva za priložnost
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Absent,Skupaj Odsoten
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +848,Item or Warehouse for row {0} does not match Material Request,Postavka ali skladišča za vrstico {0} ne ujema Material dogovoru
-apps/erpnext/erpnext/config/stock.py +191,Unit of Measure,Merska enota
-DocType: Fiscal Year,Year End Date,Leto End Date
-DocType: Task Depends On,Task Depends On,Naloga je odvisna od
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1026,Opportunity,Priložnost
-,Completed Production Orders,Zaključeni Proizvodne Naročila
-DocType: Operation,Default Workstation,Privzeto Workstation
-DocType: Notification Control,Expense Claim Approved Message,Expense Zahtevek Odobreno Sporočilo
-DocType: Payment Entry,Deductions or Loss,Odbitki ali izguba
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247,{0} {1} is closed,{0} {1} je zaprt
-DocType: Email Digest,How frequently?,Kako pogosto?
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +58,Total Collected: {0},Skupno zbranih: {0}
-DocType: Purchase Receipt,Get Current Stock,Pridobite trenutne zaloge
-DocType: Purchase Invoice,ineligible,neupravičeno
-apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Drevo Bill of Materials
-DocType: Student,Joining Date,Vstop Datum
-,Employees working on a holiday,Zaposleni na počitnice
-DocType: Share Balance,Current State,Trenutno stanje
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Mark Present
-DocType: Share Transfer,From Shareholder,Od delničarja
-DocType: Project,% Complete Method,% končano
-apps/erpnext/erpnext/healthcare/setup.py +181,Drug,Zdravilo
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200,Maintenance start date can not be before delivery date for Serial No {0},Datum začetka vzdrževanje ne more biti pred datumom dostave za serijsko št {0}
-DocType: Production Order,Actual End Date,Dejanski končni datum
-DocType: Cash Flow Mapping,Is Finance Cost Adjustment,Je prilagoditev stroškov financiranja
-DocType: BOM,Operating Cost (Company Currency),Obratovalni stroški (družba Valuta)
-DocType: Purchase Invoice,PINV-,PINV-
-DocType: Authorization Rule,Applicable To (Role),Ki se uporabljajo za (vloga)
-DocType: BOM Update Tool,Replace BOM,Zamenjajte BOM
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110,Code {0} already exist,Koda {0} že obstaja
-DocType: Employee Advance,Purpose,Namen
-DocType: Company,Fixed Asset Depreciation Settings,Osnovno sredstvo Nastavitve amortizacije
-DocType: Item,Will also apply for variants unless overrridden,Bo veljalo tudi za variante razen overrridden
-DocType: Purchase Invoice,Advances,Predplačila
-DocType: Production Order,Manufacture against Material Request,Izdelava proti Material zahtevo
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +14,Assessment Group: ,Ocenjevalna skupina:
-DocType: Item Reorder,Request for,Prošnja za
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,"Odobritvi Uporabnik ne more biti isto kot uporabnika je pravilo, ki veljajo za"
-DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Osnovni tečaj (kot na borzi UOM)
-DocType: SMS Log,No of Requested SMS,Št zaprošene SMS
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +245,Leave Without Pay does not match with approved Leave Application records,Pusti brez plačila ne ujema z odobrenimi evidence Leave aplikacij
-DocType: Campaign,Campaign-.####,Akcija -. ####
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Naslednji koraki
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +796,Please supply the specified items at the best possible rates,"Prosimo, da določene elemente na najboljših možnih cenah"
-DocType: Membership,USD,ameriški dolar
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Make Invoice,Izračunajte
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +80,Remaining Balance,Ostati v ravnotežju
-DocType: Selling Settings,Auto close Opportunity after 15 days,Auto blizu Priložnost po 15 dneh
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +86,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Nakupna naročila niso dovoljena za {0} zaradi postavke ocene rezultatov {1}.
-apps/erpnext/erpnext/stock/doctype/item/item.py +497,Barcode {0} is not a valid {1} code,Črtna koda {0} ni veljavna {1} koda
-apps/erpnext/erpnext/public/js/financial_statements.js +83,End Year,Leto zaključka
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Quot / svinec%
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Quot / svinec%
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +124,Contract End Date must be greater than Date of Joining,Naročilo Končni datum mora biti večja od Datum pridružitve
-DocType: Driver,Driver,Voznik
-DocType: Vital Signs,Nutrition Values,Prehranske vrednosti
-DocType: Lab Test Template,Is billable,Je zaračunljiv
-DocType: Delivery Note,DN-,DN-
-apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +44,"Both ""Physician Schedule"" and Time Per Appointment"" must be set for Dr {0}",Za zdravnik {0} je treba določiti oba &quot;Urnik zdravnikov&quot; in čas na imenovanju &quot;
-DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,"Distributer tretja oseba / trgovec / provizije agent / podružnica / prodajalec, ki prodaja podjetja, izdelke za provizijo."
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376,{0} against Purchase Order {1},{0} za Naročilo {1}
-DocType: Patient,Patient Demographics,Demografija pacienta
-DocType: Task,Actual Start Date (via Time Sheet),Dejanski začetni datum (preko Čas lista)
-apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15,This is an example website auto-generated from ERPNext,To je primer spletne strani samodejno ustvari iz ERPNext
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +37,Ageing Range 1,Staranje Razpon 1
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +210,Total advance amount cannot be greater than total claimed amount,Skupni znesek vnaprej ne more biti večji od skupnega zahtevanega zneska
-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 predlogo, ki se lahko uporablja za vse nakupnih poslov. To predlogo lahko vsebuje seznam davčnih glavami in tudi drugih odhodkov glavah, kot so &quot;Shipping&quot;, &quot;zavarovanje&quot;, &quot;Ravnanje&quot; itd #### Opomba davčno stopnjo, ki jo določite tu bo standard davčna stopnja za vse ** Točke * *. Če obstajajo ** Items **, ki imajo različne stopnje, ki jih je treba dodati v ** Element davku ** miza v ** Element ** mojstra. #### Opis Stolpci 1. Vrsta Izračun: - To je lahko na ** Net Total ** (to je vsota osnovnega zneska). - ** Na prejšnje vrstice Total / Znesek ** (za kumulativnih davkov ali dajatev). Če izberete to možnost, bo davek treba uporabiti kot odstotek prejšnje vrstice (davčne tabele) znesek ali skupaj. - ** Dejanska ** (kot je omenjeno). 2. Račun Head: The knjiga račun, pod katerimi se bodo rezervirana ta davek 3. stroškovni center: Če davek / pristojbina je prihodek (kot ladijski promet) ali odhodek je treba rezervirana proti centru stroškov. 4. Opis: Opis davka (bo, da se natisne v faktur / narekovajev). 5. stopnja: Davčna stopnja. 6. Znesek: Davčna znesek. 7. Skupaj: Kumulativno do te točke. 8. Vnesite Row: Če je na osnovi &quot;Prejšnji Row Total&quot; lahko izberete številko vrstice, ki bo sprejet kot osnova za ta izračun (privzeta je prejšnja vrstica). 9. Razmislite davek ali dajatev za: V tem razdelku lahko določite, če je davek / pristojbina le za vrednotenje (ni del skupaj) ali samo za skupno (ne dodajajo vrednost za postavko), ali pa oboje. 10. Dodajte ali odštejemo: Ali želite dodati ali odbiti davek."
-DocType: Homepage,Homepage,Domača stran
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +71,Select Physician...,Izberite zdravnika ...
-DocType: Grant Application,Grant Application Details ,Podrobnosti o aplikaciji za dodelitev sredstev
-DocType: Purchase Receipt Item,Recd Quantity,Recd Količina
-apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +65,Fee Records Created - {0},Fee Records Created - {0}
-DocType: Asset Category Account,Asset Category Account,Sredstvo Kategorija račun
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +913,Row #{0} (Payment Table): Amount must be positive,Vrstica # {0} (Tabela plačil): znesek mora biti pozitiven
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44,CompteNum,CompteNum
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +137,Cannot produce more Item {0} than Sales Order quantity {1},Ne more proizvajati več item {0} od prodaje kol {1}
-apps/erpnext/erpnext/stock/doctype/item/item.js +362,Select Attribute Values,Izberite vrednosti atributa
-DocType: Purchase Invoice,Reason For Issuing document,Razlog za izdajo dokumenta
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539,Stock Entry {0} is not submitted,Stock Začetek {0} ni predložila
-DocType: Payment Reconciliation,Bank / Cash Account,Banka / Gotovinski račun
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +45,Next Contact By cannot be same as the Lead Email Address,Naslednja Kontakt Po ne more biti enaka kot vodilni e-poštni naslov
-DocType: Tax Rule,Billing City,Zaračunavanje Mesto
-DocType: Asset,Manual,Ročno
-DocType: Salary Component Account,Salary Component Account,Plača Komponenta račun
-DocType: Global Defaults,Hide Currency Symbol,Skrij valutni simbol
-apps/erpnext/erpnext/config/non_profit.py +58,Donor information.,Podatki o donatorju.
-apps/erpnext/erpnext/config/accounts.py +330,"e.g. Bank, Cash, Credit Card","npr Bank, gotovini, Kreditna kartica"
-DocType: Lead Source,Source Name,Source Name
-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 pri odraslih je približno 120 mmHg sistoličnega in 80 mmHg diastoličnega, okrajšanega &quot;120/80 mmHg&quot;"
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +119,"Set items shelf life in days, to set expiry based on manufacturing_date plus self life","Določite rok trajanja v dnevih, nastavite potek veljavnosti glede na production_date plus življenjsko dobo"
-DocType: Journal Entry,Credit Note,Dobropis
-DocType: Projects Settings,Ignore Employee Time Overlap,Prezreti čas prekrivanja zaposlenih
-DocType: Warranty Claim,Service Address,Storitev Naslov
-DocType: Asset Maintenance Task,Calibration,Praznovanje
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +102,{0} is a company holiday,{0} je praznik podjetja
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49,Furnitures and Fixtures,Pohištvo in Fixtures
-DocType: Item,Manufacture,Izdelava
-apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Company,Setup Company
-,Lab Test Report,Poročilo o laboratorijskem testu
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,Prosimo Delivery Note prvi
-DocType: Student Applicant,Application Date,uporaba Datum
-DocType: Salary Detail,Amount based on formula,"Znesek, ki temelji na formuli"
-DocType: Purchase Invoice,Currency and Price List,Gotovina in Cenik
-DocType: Opportunity,Customer / Lead Name,Stranka / Ime ponudbe
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +99,Clearance Date not mentioned,Potrditev Datum ni omenjena
-apps/erpnext/erpnext/config/manufacturing.py +7,Production,Proizvodnja
-DocType: Guardian,Occupation,poklic
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74,Row {0}:Start Date must be before End Date,Vrstica {0}: Začetni datum mora biti pred končnim datumom
-DocType: Crop,Planting Area,Območje sajenja
-apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Skupaj (Kol)
-DocType: Installation Note Item,Installed Qty,Nameščen Kol
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4,This could be because of some invalid Email Addresses in the,To je lahko zaradi nekaterih neveljavnih e - poštnih naslovov v
-apps/erpnext/erpnext/utilities/user_progress.py +28,You added ,Dodali ste
-DocType: Purchase Taxes and Charges,Parenttype,Parenttype
-apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10,Training Result,Rezultat usposabljanja
-DocType: Purchase Invoice,Is Paid,je plačano
-DocType: Salary Structure,Total Earning,Skupaj zaslužka
-DocType: Purchase Receipt,Time at which materials were received,"Čas, v katerem so bile prejete materiale"
-DocType: Products Settings,Products per Page,Izdelki na stran
-DocType: Stock Ledger Entry,Outgoing Rate,Odhodni Rate
-apps/erpnext/erpnext/config/hr.py +233,Organization branch master.,Organizacija podružnica gospodar.
-apps/erpnext/erpnext/controllers/accounts_controller.py +312, or ,ali
-DocType: Sales Order,Billing Status,Status zaračunavanje
-apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Prijavi težavo
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,Utility Expenses,Pomožni Stroški
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,90-Nad
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +247,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Row # {0}: Journal Entry {1} nima računa {2} ali pa so že primerjali z drugo kupona
-DocType: Supplier Scorecard Criteria,Criteria Weight,Teža meril
-DocType: Buying Settings,Default Buying Price List,Privzet nabavni cenik
-DocType: Payroll Entry,Salary Slip Based on Timesheet,Plača Slip Na Timesheet
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +43,Buying Rate,Nakupna cena
-DocType: Notification Control,Sales Order Message,Sales Order Sporočilo
-apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Privzeta nastavitev Vrednote, kot so podjetja, valuta, tekočem proračunskem letu, itd"
-DocType: Payment Entry,Payment Type,Način plačila
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +240,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,"Izberite Serija za postavko {0}. Ni mogoče, da bi našli eno serijo, ki izpolnjuje te zahteve"
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +240,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,"Izberite Serija za postavko {0}. Ni mogoče, da bi našli eno serijo, ki izpolnjuje te zahteve"
-DocType: Hub Category,Parent Category,Kategorija staršev
-DocType: Payroll Entry,Select Employees,Izberite Zaposleni
-DocType: Opportunity,Potential Sales Deal,Potencialni Sales Deal
-DocType: Complaint,Complaints,Pritožbe
-DocType: Payment Entry,Cheque/Reference Date,Ček / Referenčni datum
-DocType: Purchase Invoice,Total Taxes and Charges,Skupaj davki in dajatve
-DocType: Employee,Emergency Contact,Zasilna Kontakt
-DocType: Bank Reconciliation Detail,Payment Entry,Začetek plačilo
-,sales-browser,prodaja brskalnik
-apps/erpnext/erpnext/accounts/doctype/account/account.js +79,Ledger,Ledger
-DocType: Patient Medical Record,PMR-,PMR-
-DocType: Drug Prescription,Drug Code,Koda zdravil
-DocType: Target Detail,Target  Amount,Ciljni znesek
-DocType: POS Profile,Print Format for Online,Format tiskanja za spletno
-DocType: Shopping Cart Settings,Shopping Cart Settings,Nastavitve Košarica
-DocType: Journal Entry,Accounting Entries,Vknjižbe
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"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 cenovno pravilo za &quot;Oceni&quot;, bo prepisalo cenik. Cena pravilnika je končna obrestna mera, zato ni treba uporabljati dodatnega popusta. Zato se pri transakcijah, kot je prodajna naročilo, naročilnica itd., Dobijo v polju »Oceni«, ne pa na »cenik tečaja«."
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},"Podvojenega vnosa. Prosimo, preverite Dovoljenje Pravilo {0}"
-DocType: Journal Entry Account,Reference Due Date,Referenčni datum roka
-DocType: Purchase Order,Ref SQ,Ref SQ
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Receipt document must be submitted,Potrdilo dokument je treba predložiti
-DocType: Purchase Invoice Item,Received Qty,Prejela Kol
-DocType: Stock Entry Detail,Serial No / Batch,Zaporedna številka / Batch
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340,Not Paid and Not Delivered,Ne plača in ne Delivered
-DocType: Product Bundle,Parent Item,Parent Item
-DocType: Account,Account Type,Vrsta računa
-DocType: Delivery Note,DN-RET-,DN-RET-
-apps/erpnext/erpnext/templates/pages/projects.html +58,No time sheets,Ni listami
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123,Leave Type {0} cannot be carry-forwarded,"Pustite Type {0} ni mogoče izvajati, posredovati"
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Vzdrževanje Urnik se ne ustvari za vse postavke. Prosimo, kliknite na &quot;ustvarjajo Seznamu&quot;"
-,To Produce,Za izdelavo
-apps/erpnext/erpnext/config/hr.py +93,Payroll,izplačane plače
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +196,"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 stopnji Element, {3}, mora biti vključena tudi vrstice"
-apps/erpnext/erpnext/utilities/activation.py +101,Make User,Naredite uporabnika
-DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikacija paketu za dostavo (za tisk)
-DocType: Bin,Reserved Quantity,Rezervirano Količina
-apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Vnesite veljaven e-poštni naslov
-apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Vnesite veljaven e-poštni naslov
-DocType: Volunteer Skill,Volunteer Skill,Sposobnost prostovoljcev
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +780,Please select an item in the cart,"Prosimo, izberite predmet v vozičku"
-DocType: Landed Cost Voucher,Purchase Receipt Items,Nakup Prejem Items
-apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Prilagajanje Obrazci
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74,Arrear,arrear
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158,Depreciation Amount during the period,Amortizacija Znesek v obdobju
-apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43,Disabled template must not be default template,Onemogočeno predloga ne sme biti kot privzeto
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +313,For row {0}: Enter planned qty,Za vrstico {0}: vnesite načrtovani qty
-DocType: Shareholder,SH-,SH-
-DocType: Account,Income Account,Prihodki račun
-DocType: Payment Request,Amount in customer's currency,Znesek v valuti stranke
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +825,Delivery,Dostava
-DocType: Volunteer,Weekdays,Delovni dnevi
-DocType: Stock Reconciliation Item,Current Qty,Trenutni Kol
-DocType: Restaurant Menu,Restaurant Menu,Restavracija Meni
-apps/erpnext/erpnext/templates/generators/item_group.html +36,Prev,prejšnja
-DocType: Appraisal Goal,Key Responsibility Area,Key Odgovornost Area
-apps/erpnext/erpnext/utilities/activation.py +127,"Student Batches help you track attendance, assessments and fees for students","Študentski Paketi vam pomaga slediti sejnin, ocene in pristojbine za študente"
-DocType: Payment Entry,Total Allocated Amount,Skupaj Dodeljena Znesek
-apps/erpnext/erpnext/setup/doctype/company/company.py +151,Set default inventory account for perpetual inventory,Privzeta nastavitev popis račun za stalne inventarizacije
-DocType: Item Reorder,Material Request Type,Material Zahteva Type
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252,Accural Journal Entry for salaries from {0} to {1},Accural list Vstop za pla iz {0} in {1}
-apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17,Send Grant Review Email,Pošlji e-pošto za pregled e-pošte
-apps/erpnext/erpnext/accounts/page/pos/pos.js +848,"LocalStorage is full, did not save","Lokalno shrambo je polna, ni rešil"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +99,Row {0}: UOM Conversion Factor is mandatory,Vrstica {0}: UOM Conversion Factor je obvezna
-apps/erpnext/erpnext/utilities/user_progress.py +232,Room Capacity,Zmogljivost sob
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +90,Ref,Ref
-DocType: Lab Test,LP-,LP-
-DocType: Healthcare Settings,Registration Fee,Kotizacija
-DocType: Budget,Cost Center,Stroškovno Center
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45,Voucher #,Voucher #
-DocType: Notification Control,Purchase Order Message,Naročilnica sporočilo
-DocType: Tax Rule,Shipping Country,Dostava Država
-DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Skrij ID za DDV naročnika od prodajnih transakcij
-DocType: Upload Attendance,Upload HTML,Naloži HTML
-DocType: Employee,Relieving Date,Lajšanje Datum
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Cen Pravilo je narejen prepisati Cenik / določiti diskontno odstotek, na podlagi nekaterih kriterijev."
-DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Skladišče je mogoče spremeniti samo prek borze Vstop / Delivery Note / Potrdilo o nakupu
-DocType: Employee Education,Class / Percentage,Razred / Odstotek
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134,Head of Marketing and Sales,Vodja marketinga in prodaje
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72,Income Tax,Davek na prihodek
-apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,Track Interesenti ga Industry Type.
-apps/erpnext/erpnext/utilities/user_progress.py +98,Go to Letterheads,Pojdite v Letterheads
-DocType: Item Supplier,Item Supplier,Postavka Dobavitelj
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1255,Please enter Item Code to get batch no,Vnesite Koda dobiti serijo no
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +880,Please select a value for {0} quotation_to {1},"Prosimo, izberite vrednost za {0} quotation_to {1}"
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +414,No Items selected for transfer,Ni izbranih elementov za prenos
-apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Vsi naslovi.
-DocType: Company,Stock Settings,Nastavitve Stock
-apps/erpnext/erpnext/accounts/doctype/account/account.py +183,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spajanje je mogoče le, če so naslednje lastnosti enaka v obeh evidencah. Je skupina, Root Type, Company"
-DocType: Vehicle,Electric,električni
-DocType: Task,% Progress,% napredka
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123,Gain/Loss on Asset Disposal,Dobiček / izgube pri prodaji premoženja
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +117,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 svoj račun.
-DocType: Task,Depends on Tasks,Odvisno od Opravila
-apps/erpnext/erpnext/config/selling.py +36,Manage Customer Group Tree.,Upravljanje drevesa skupine kupcev.
-DocType: Shopping Cart Settings,Attachments can be shown without enabling the shopping cart,"Priključki se lahko dokaže, ne da bi omogočili nakupovalni voziček"
-DocType: Normal Test Items,Result Value,Vrednost rezultata
-DocType: Hotel Room,Hotels,Hoteli
-DocType: Supplier Quotation,SQTN-,SQTN-
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22,New Cost Center Name,New Stroški Center Ime
-DocType: Leave Control Panel,Leave Control Panel,Pustite Nadzorna plošča
-DocType: Project,Task Completion,naloga Zaključek
-apps/erpnext/erpnext/templates/includes/product_page.js +21,Not in Stock,Ni na zalogi
-DocType: Volunteer,Volunteer Skills,Prostovoljne spretnosti
-DocType: Appraisal,HR User,Uporabnik človeških virov
-DocType: Purchase Invoice,Taxes and Charges Deducted,Davki in dajatve Odbitek
-apps/erpnext/erpnext/hooks.py +142,Issues,Vprašanja
-apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Stanje mora biti eno od {0}
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64,Reminder to update GSTIN Sent,Opomnik za posodobitev GSTIN Poslano
-DocType: Sales Invoice,Debit To,Bremenitev
-DocType: Restaurant Menu Item,Restaurant Menu Item,Restavracija Menu Item
-DocType: Delivery Note,Required only for sample item.,Zahteva le za točko vzorca.
-DocType: Stock Ledger Entry,Actual Qty After Transaction,Dejanska Kol Po Transaction
-apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +79,No salary slip found between {0} and {1},Št plačilni list dalo med {0} in {1}
-,Pending SO Items For Purchase Request,Dokler SO Točke za nakup dogovoru
-apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35,Student Admissions,Študentski Sprejemi
-apps/erpnext/erpnext/accounts/party.py +389,{0} {1} is disabled,{0} {1} je onemogočeno
-DocType: Supplier,Billing Currency,Zaračunavanje Valuta
-DocType: Sales Invoice,SINV-RET-,SINV-RET-
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200,Extra Large,Extra Large
-DocType: Crop,Scientific Name,Znanstveno ime
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Leaves,Skupaj Listi
-DocType: Customer,"Reselect, if the chosen contact is edited after save","Ponovno izbere, če je izbrani stik po urejanju urejen"
-DocType: Consultation,In print,V tisku
-,Profit and Loss Statement,Izkaz poslovnega izida
-DocType: Bank Reconciliation Detail,Cheque Number,Ček Število
-,Sales Browser,Prodaja Browser
-DocType: Journal Entry,Total Credit,Skupaj Credit
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542,Warning: Another {0} # {1} exists against stock entry {2},Opozorilo: Drug {0} # {1} obstaja pred vstopom parka {2}
-apps/erpnext/erpnext/utilities/user_progress_utils.py +66,Local,Lokalno
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Posojila in predujmi (sredstva)
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Dolžniki
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199,Large,Velika
-DocType: Homepage Featured Product,Homepage Featured Product,Domača stran izbranega izdelka
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +247,All Assessment Groups,Vse skupine za ocenjevanje
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Novo skladišče Ime
-apps/erpnext/erpnext/accounts/report/financial_statements.py +257,Total {0} ({1}),Skupno {0} ({1})
-DocType: C-Form Invoice Detail,Territory,Ozemlje
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,Please mention no of visits required,Navedite ni obiskov zahtevanih
-DocType: Stock Settings,Default Valuation Method,Način Privzeto Vrednotenje
-apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26,Fee,Fee
-apps/erpnext/erpnext/setup/doctype/company/company.js +154,Update in progress. It might take a while.,Posodabljanje je v teku. Mogoče bo trajalo nekaj časa.
-DocType: Production Plan Item,Produced Qty,Proizvedeno količino
-DocType: Vehicle Log,Fuel Qty,gorivo Kol
-DocType: Production Order Operation,Planned Start Time,Načrtovano Start Time
-DocType: Course,Assessment,ocena
-DocType: Payment Entry Reference,Allocated,Razporejeni
-apps/erpnext/erpnext/config/accounts.py +267,Close Balance Sheet and book Profit or Loss.,Zapri Bilanca stanja in rezervirajte poslovnem izidu.
-DocType: Student Applicant,Application Status,Status uporaba
-DocType: Sensitivity Test Items,Sensitivity Test Items,Testi preizkusov občutljivosti
-DocType: Fees,Fees,pristojbine
-DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Določite Menjalni tečaj za pretvorbo ene valute v drugo
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159,Quotation {0} is cancelled,Ponudba {0} je odpovedana
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +114,Total Outstanding Amount,Skupni preostali znesek
-DocType: Sales Partner,Targets,Cilji
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js +54,Please register the SIREN number in the company information file,"Prosimo, registrirajte številko SIREN v podatkovni datoteki podjetja"
-DocType: Price List,Price List Master,Cenik Master
-DocType: GST Account,CESS Account,CESS račun
-DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Vse prodajne transakcije je lahko označena pred številnimi ** Prodajni Osebe **, tako da lahko nastavite in spremljanje ciljev."
-,S.O. No.,SO No.
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241,Please create Customer from Lead {0},"Prosimo, da ustvarite strank iz svinca {0}"
-apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,Select Patient,Izberite Patient
-DocType: Price List,Applicable for Countries,Velja za države
-DocType: Supplier Scorecard Scoring Variable,Parameter Name,Ime parametra
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52,Student Group Name is mandatory in row {0},Študent Group Ime je obvezno v vrsti {0}
-DocType: Homepage,Products to be shown on website homepage,"Proizvodi, ki se prikaže na spletni strani"
-apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,To je skupina koren stranke in jih ni mogoče urejati.
-DocType: Student,AB-,AB-
-DocType: POS Profile,Ignore Pricing Rule,Ignoriraj Pricing pravilo
-DocType: Employee Education,Graduate,Maturirati
-DocType: Leave Block List,Block Days,Block dnevi
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83,"Shipping Address does not have country, which is required for this Shipping Rule","Naslov za dostavo nima države, ki je potrebna za to pravilo o pošiljanju"
-DocType: Journal Entry,Excise Entry,Trošarina Začetek
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Opozorilo: Sales Order {0} že obstaja zoper naročnikovo narocilo {1}
-DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.
-
-Examples:
-
-1. Validity of the offer.
-1. Payment Terms (In Advance, On Credit, part advance etc).
-1. What is extra (or payable by the Customer).
-1. Safety / usage warning.
-1. Warranty if any.
-1. Returns Policy.
-1. Terms of shipping, if applicable.
-1. Ways of addressing disputes, indemnity, liability, etc.
-1. Address and Contact of your Company.","Standardni Pogoji, ki se lahko dodajajo prodaje in nakupe. Primeri: 1. Veljavnost ponudbe. 1. Plačilni pogoji (vnaprej, na kredit, del predujem itd). 1. Kaj je dodatno (ali ga je dolžan plačati davek). Opozorilo / uporaba 1. varnost. 1. Garancija če sploh. 1. Izjava zasebnosti. 1. Pogoji ladijskega prometa, če je to primerno. 1. načine reševanja sporov, jamstva, odgovornosti, itd 1. Naslov in kontaktne vašega podjetja."
-DocType: Issue,Issue Type,Vrsta izdaje
-DocType: Attendance,Leave Type,Zapusti Type
-DocType: Purchase Invoice,Supplier Invoice Details,Dobavitelj Podrobnosti računa
-DocType: Agriculture Task,Ignore holidays,Prezri odmor
-apps/erpnext/erpnext/controllers/stock_controller.py +233,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Expense / Razlika račun ({0}) mora biti račun &quot;poslovni izid&quot;
-DocType: Project,Copied From,Kopirano iz
-DocType: Project,Copied From,Kopirano iz
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +340,Invoice already created for all billing hours,"Račun, ki je že ustvarjen za vse obračunske ure"
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96,Name error: {0},Ime napaka: {0}
-DocType: Cash Flow Mapping,Is Finance Cost,Je strošek financiranja
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,Attendance for employee {0} is already marked,Udeležba na zaposlenega {0} je že označeno
-DocType: Packing Slip,If more than one package of the same type (for print),Če več paketov istega tipa (v tisku)
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27,Please set default customer in Restaurant Settings,Privzeto stran nastavite v nastavitvah restavracij
-,Salary Register,plača Registracija
-DocType: Warehouse,Parent Warehouse,Parent Skladišče
-DocType: C-Form Invoice Detail,Net Total,Neto Skupaj
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +546,Default BOM not found for Item {0} and Project {1},Privzeti BOM nismo našli v postavki {0} in projektno {1}
-apps/erpnext/erpnext/config/hr.py +168,Define various loan types,Opredeliti različne vrste posojil
-DocType: Bin,FCFS Rate,FCFS Rate
-DocType: Opening Invoice Creation Tool Item,Outstanding Amount,Neporavnani znesek
-apps/erpnext/erpnext/templates/generators/bom.html +71,Time(in mins),Čas (v minutah)
-DocType: Project Task,Working,Delovna
-DocType: Stock Ledger Entry,Stock Queue (FIFO),Stock Queue (FIFO)
-apps/erpnext/erpnext/public/js/setup_wizard.js +127,Financial Year,Finančno leto
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46,{0} does not belong to Company {1},{0} ne pripada družbi {1}
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66,Could not solve criteria score function for {0}. Make sure the formula is valid.,"Za {0} ni bilo mogoče rešiti funkcije ocene rezultatov. Prepričajte se, da formula velja."
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122,Cost as on,Stane na
-DocType: Healthcare Settings,Out Patient Settings,Out Patient Settings
-DocType: Account,Round Off,Zaokrožite
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +259,Quantity must be positive,Količina mora biti pozitivna
-DocType: Material Request Plan Item,Requested Qty,Zahteval Kol
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +96,The fields From Shareholder and To Shareholder cannot be blank,Polja Od delničarja in delničarja ne morejo biti prazna
-DocType: Tax Rule,Use for Shopping Cart,Uporabite za Košarica
-apps/erpnext/erpnext/controllers/item_variant.py +98,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},Vrednost {0} za Attribute {1} ne obstaja na seznamu veljavnega točke Lastnost Vrednosti za postavko {2}
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79,Select Serial Numbers,Izberite serijsko številko
-DocType: BOM Item,Scrap %,Ostanki%
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Dajatve bodo razdeljeni sorazmerno na podlagi postavka Kol ali znesek, glede na vašo izbiro"
-DocType: Maintenance Visit,Purposes,Nameni
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +111,Atleast one item should be entered with negative quantity in return document,"Atleast en element, se vpiše z negativnim količino v povratni dokument"
-apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Operacija {0} dlje od vseh razpoložljivih delovnih ur v delovni postaji {1}, razčleniti operacijo na več operacij"
-DocType: Membership,Membership Status,Status članstva
-,Requested,Zahteval
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93,No Remarks,Ni Opombe
-DocType: Asset,In Maintenance,V vzdrževanju
-DocType: Purchase Invoice,Overdue,Zapadle
-DocType: Account,Stock Received But Not Billed,Prejete Stock Ampak ne zaračuna
-apps/erpnext/erpnext/accounts/doctype/account/account.py +84,Root Account must be a group,Root račun mora biti skupina
-DocType: Consultation,Drug Prescription,Predpis o drogah
-DocType: Fees,FEE.,FEE.
-DocType: Employee Loan,Repaid/Closed,Povrne / Zaprto
-DocType: Item,Total Projected Qty,Skupne projekcije Kol
-DocType: Monthly Distribution,Distribution Name,Porazdelitev Name
-apps/erpnext/erpnext/stock/stock_ledger.py +477,"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 mogoče najti za postavko {0}, ki je potrebna za izvršitev računovodskih vnosov za {1} {2}. Če je predmet predmet transakcije kot element ničelne vrednosti za vrednost v {1}, navedite to v tabeli {1} Item. V nasprotnem primeru ustvarite transakcijo dohodne delnice za postavko ali navedite stopnjo vrednotenja v zapisu postavke in poskusite poslati / preklicati ta vnos"
-DocType: Course,Course Code,Koda predmeta
-apps/erpnext/erpnext/controllers/stock_controller.py +337,Quality Inspection required for Item {0},Inšpekcija kakovosti potrebna za postavko {0}
-DocType: POS Settings,Use POS in Offline Mode,Uporabite POS v načinu brez povezave
-DocType: Supplier Scorecard,Supplier Variables,Spremenljivke dobavitelja
-DocType: Quotation,Rate at which customer's currency is converted to company's base currency,"Obrestna mera, po kateri kupec je valuti, se pretvori v osnovni valuti družbe"
-DocType: Purchase Invoice Item,Net Rate (Company Currency),Net Rate (družba Valuta)
-DocType: Salary Detail,Condition and Formula Help,Stanje in Formula Pomoč
-apps/erpnext/erpnext/config/selling.py +105,Manage Territory Tree.,Upravljanje Territory drevo.
-DocType: Journal Entry Account,Sales Invoice,Račun
-DocType: Journal Entry Account,Party Balance,Balance Party
-DocType: Cash Flow Mapper,Section Subtotal,Vmesni del vsote
-apps/erpnext/erpnext/accounts/page/pos/pos.js +498,Please select Apply Discount On,"Prosimo, izberite Uporabi popust na"
-DocType: Stock Settings,Sample Retention Warehouse,Skladišče za shranjevanje vzorcev
-DocType: Company,Default Receivable Account,Privzeto Terjatve račun
-DocType: Physician,Physician Schedule,Urnik zdravnika
-DocType: Purchase Invoice,Deemed Export,Izbrisani izvoz
-DocType: Stock Entry,Material Transfer for Manufacture,Prenos materialov za proizvodnjo
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20,Discount Percentage can be applied either against a Price List or for all Price List.,Popust Odstotek se lahko uporablja bodisi proti ceniku ali za vse cenik.
-DocType: Subscription,Half-yearly,Polletni
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +407,Accounting Entry for Stock,Računovodstvo Vstop za zalogi
-DocType: Lab Test,LabTest Approver,Odobritev LabTest
-apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +61,You have already assessed for the assessment criteria {}.,Ste že ocenili za ocenjevalnih meril {}.
-DocType: Vehicle Service,Engine Oil,Motorno olje
-DocType: Sales Invoice,Sales Team1,Prodaja TEAM1
-apps/erpnext/erpnext/stock/doctype/item/item.py +546,Item {0} does not exist,Element {0} ne obstaja
-DocType: Sales Invoice,Customer Address,Naslov stranke
-DocType: Employee Loan,Loan Details,posojilo Podrobnosti
-DocType: Company,Default Inventory Account,Privzeti Popis račun
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +192,The folio numbers are not matching,Folio številke se ne ujemajo
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124,Row {0}: Completed Qty must be greater than zero.,Vrstica {0}: Zaključen Kol mora biti večji od nič.
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +249,Payment Request for {0},Zahteva za plačilo za {0}
-DocType: Item Barcode,Barcode Type,Tip črtne kode
-DocType: Antibiotic,Antibiotic Name,Ime antibiotika
-DocType: Purchase Invoice,Apply Additional Discount On,Uporabi dodatni popust na
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +69,Select Type...,Izberite Vrsta ...
-DocType: Crop Cycle,A link to all the Land Units in which the Crop is growing,"Povezava na vse enote kopenskih površin, v katerih rastlina raste"
-DocType: Account,Root Type,Root Type
-DocType: Item,FIFO,FIFO
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +132,Row # {0}: Cannot return more than {1} for Item {2},Vrstica # {0}: ne more vrniti več kot {1} za postavko {2}
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +45,Plot,Plot
-DocType: Item Group,Show this slideshow at the top of the page,Pokažite ta diaprojekcije na vrhu strani
-DocType: BOM,Item UOM,Postavka UOM
-DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Davčna Znesek Po Popust Znesek (družba Valuta)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +164,Target warehouse is mandatory for row {0},Ciljna skladišče je obvezna za vrstico {0}
-DocType: Cheque Print Template,Primary Settings,primarni Nastavitve
-DocType: Purchase Invoice,Select Supplier Address,Izberite Dobavitelj naslov
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Add Employees,Dodaj Zaposleni
-DocType: Purchase Invoice Item,Quality Inspection,Quality Inspection
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196,Extra Small,Extra Small
-DocType: Company,Standard Template,standard Template
-DocType: Training Event,Theory,teorija
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +806,Warning: Material Requested Qty is less than Minimum Order Qty,"Opozorilo: Material Zahtevana Količina je manj kot minimalna, da Kol"
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211,Account {0} is frozen,Račun {0} je zamrznjen
-DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Pravna oseba / Hčerinska družba z ločenim računom ki pripada organizaciji.
-DocType: Payment Request,Mute Email,Mute Email
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29,"Food, Beverage & Tobacco","Hrana, pijača, tobak"
-DocType: Account,Account Number,Številka računa
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +720,Can only make payment against unbilled {0},Lahko le plačilo proti neobračunano {0}
-apps/erpnext/erpnext/controllers/selling_controller.py +101,Commission rate cannot be greater than 100,Stopnja Komisija ne more biti večja od 100
-DocType: Volunteer,Volunteer,Prostovoljka
-DocType: Stock Entry,Subcontract,Podizvajalska pogodba
-apps/erpnext/erpnext/public/js/utils/party.js +166,Please enter {0} first,Vnesite {0} najprej
-apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +104,No replies from,Ni odgovorov
-DocType: Production Order Operation,Actual End Time,Dejanski Končni čas
-DocType: Item,Manufacturer Part Number,Številka dela proizvajalca
-DocType: Production Order Operation,Estimated Time and Cost,Predvideni čas in stroški
-DocType: Bin,Bin,Bin
-DocType: Crop,Crop Name,Ime pridelka
-DocType: SMS Log,No of Sent SMS,Število poslanih SMS
-DocType: Antibiotic,Healthcare Administrator,Skrbnik zdravstva
-apps/erpnext/erpnext/utilities/user_progress.py +44,Set a Target,Nastavite cilj
-DocType: Dosage Strength,Dosage Strength,Odmerek
-DocType: Account,Expense Account,Expense račun
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,Programska oprema
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203,Colour,Barva
-DocType: Assessment Plan Criteria,Assessment Plan Criteria,Merila načrt ocenjevanja
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +118,Expiry date is mandatory for selected item,Datum izteka roka je obvezen za izbrani predmet
-DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Preprečevanje nakupnih naročil
-apps/erpnext/erpnext/healthcare/setup.py +258,Susceptible,Občutljivo
-DocType: Patient Appointment,Scheduled,Načrtovano
-apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Zahteva za ponudbo.
-apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Prosimo, izberite postavko, kjer &quot;Stock postavka je&quot; &quot;Ne&quot; in &quot;Je Sales Postavka&quot; je &quot;Yes&quot; in ni druge Bundle izdelka"
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148,Select Customer,Izberite stranko
-DocType: Student Log,Academic,akademski
-DocType: Patient,Personal and Social History,Osebna in socialna zgodovina
-apps/erpnext/erpnext/education/doctype/guardian/guardian.py +51,User {0} created,Uporabnik {0} je ustvaril
-DocType: Fee Schedule,Fee Breakup for each student,Povračilo stroškov za vsakega študenta
-apps/erpnext/erpnext/controllers/accounts_controller.py +540,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Skupaj predplačilo ({0}) proti odredbi {1} ne more biti večja od Grand Total ({2})
-DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Izberite mesečnim izplačilom neenakomerno distribucijo ciljev po mesecih.
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78,Change Code,Spremeni kodo
-DocType: Purchase Invoice Item,Valuation Rate,Oceni Vrednotenje
-DocType: Stock Reconciliation,SR/,SR /
-DocType: Vehicle,Diesel,Diesel
-apps/erpnext/erpnext/stock/get_item_details.py +388,Price List Currency not selected,Cenik Valuta ni izbran
-DocType: Purchase Invoice,Availed ITC Cess,Uporabil ITC Cess
-,Student Monthly Attendance Sheet,Študent Mesečni Udeležba Sheet
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96,Shipping rule only applicable for Selling,Pravilo o dostavi velja samo za prodajo
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Projekt Start Date
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +18,Until,Do
-DocType: Rename Tool,Rename Log,Preimenovanje Prijava
-apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Študent skupine ali tečaj Urnik je obvezna
-apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Študent skupine ali tečaj Urnik je obvezna
-DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,Ohranite plačevanja Ure in delovni čas Same na Timesheet
-DocType: Maintenance Visit Purpose,Against Document No,Proti dokument št
-DocType: BOM,Scrap,Odpadno
-apps/erpnext/erpnext/utilities/user_progress.py +214,Go to Instructors,Pojdi na Inštruktorje
-apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Upravljanje prodajne partnerje.
-DocType: Quality Inspection,Inspection Type,Inšpekcijski Type
-DocType: Fee Validity,Visited yet,Obiskal še
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +135,Warehouses with existing transaction can not be converted to group.,Skladišča z obstoječim poslom ni mogoče pretvoriti v skupino.
-DocType: Assessment Result Tool,Result HTML,rezultat HTML
-apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35,Expires On,Poteče
-apps/erpnext/erpnext/utilities/activation.py +117,Add Students,Dodaj Študenti
-apps/erpnext/erpnext/public/js/utils.js +270,Please select {0},"Prosimo, izberite {0}"
-DocType: C-Form,C-Form No,C-forma
-DocType: BOM,Exploded_items,Exploded_items
-apps/erpnext/erpnext/utilities/user_progress.py +136,List your products or services that you buy or sell.,"Navedite svoje izdelke ali storitve, ki jih kupite ali prodajate."
-DocType: Water Analysis,Storage Temperature,Temperatura shranjevanja
-DocType: Employee Attendance Tool,Unmarked Attendance,neoznačena in postrežbo
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137,Researcher,Raziskovalec
-DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Program Vpis Orodje Student
-apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16,Start date should be less than end date for task {0},Začetni datum mora biti krajši od končnega datuma za opravilo {0}
-apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Ime ali E-pošta je obvezna
-DocType: Member,MEM-,MEM-
-DocType: Instructor,Instructor Log,Dnevnik inštruktorja
-DocType: Purchase Order Item,Returned Qty,Vrnjeno Kol
-DocType: Student,Exit,Izhod
-apps/erpnext/erpnext/accounts/doctype/account/account.py +156,Root Type is mandatory,Root Tip je obvezna
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29,Failed to install presets,Namestitev prednastavitev ni uspela
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +44,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.",{0} ima trenutno {1} oceno dobavitelja in naročila temu dobavitelju je treba izdajati s previdnostjo
-DocType: Chapter,Non Profit Manager,Neprofitni menedžer
-DocType: BOM,Total Cost(Company Currency),Skupni stroški (družba Valuta)
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315,Serial No {0} created,Serijska št {0} ustvaril
-DocType: Homepage,Company Description for website homepage,Podjetje Opis za domačo stran spletnega mesta
-DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Za udobje kupcev lahko te kode se uporabljajo v tiskanih oblikah, kot so na računih in dobavnicah"
-apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18,Suplier Name,Ime suplier
-apps/erpnext/erpnext/accounts/report/financial_statements.py +172,Could not retrieve information for {0}.,Podatkov za {0} ni bilo mogoče pridobiti.
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +134,Opening Entry Journal,Otvoritveni dnevnik
-DocType: Sales Invoice,Time Sheet List,Časovnica
-DocType: Employee,You can enter any date manually,Lahko jih vnesete nobenega datuma
-DocType: Healthcare Settings,Result Printed,Rezultat natisnjen
-DocType: Asset Category Account,Depreciation Expense Account,Amortizacija račun
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232,Probationary Period,Poskusna doba
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32,View {0},Ogled {0}
-DocType: Customer Group,Only leaf nodes are allowed in transaction,Samo leaf vozlišča so dovoljene v transakciji
-DocType: Project,Total Costing Amount (via Timesheets),Skupni znesek stroškov (prek časopisov)
-DocType: Employee Advance,Expense Approver,Expense odobritelj
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Customer must be credit,Vrstica {0}: Advance proti naročniku mora biti kredit
-apps/erpnext/erpnext/accounts/doctype/account/account.js +89,Non-Group to Group,Non-Group skupini
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Serija je obvezna v vrstici {0}
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Serija je obvezna v vrstici {0}
-DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Potrdilo o nakupu Postavka Priložena
-apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,Da datetime
-apps/erpnext/erpnext/config/selling.py +297,Logs for maintaining sms delivery status,Dnevniki za ohranjanje statusa dostave sms
-DocType: Accounts Settings,Make Payment via Journal Entry,Naredite plačilo preko Journal Entry
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +218,Printed On,Tiskano na
-DocType: Item,Inspection Required before Delivery,Inšpekcijski Zahtevana pred dostavo
-DocType: Item,Inspection Required before Purchase,Inšpekcijski Zahtevana pred nakupom
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,Čakanju Dejavnosti
-DocType: Patient Appointment,Reminded,Opomniti
-DocType: Patient,PID-,PID-
-DocType: Chapter Member,Chapter Member,Član poslanke
-DocType: Material Request Plan Item,Minimum Order Quantity,Najmanjša količina naročila
-apps/erpnext/erpnext/public/js/setup_wizard.js +106,Your Organization,Vaša organizacija
-DocType: Fee Component,Fees Category,pristojbine Kategorija
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +134,Please enter relieving date.,Vnesite lajšanje datum.
-apps/erpnext/erpnext/controllers/trends.py +149,Amt,Amt
-DocType: Supplier Scorecard,Notify Employee,Obvesti delavca
-DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,"Vnesite ime oglaševalske akcije, če je vir preiskovalne akcije"
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38,Newspaper Publishers,Newspaper Publishers
-apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30,Select Fiscal Year,Izberite Fiscal Year
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115,Expected Delivery Date should be after Sales Order Date,Pričakovani rok dobave je po datumu prodajnega naročila
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Preureditev Raven
-DocType: Company,Chart Of Accounts Template,Graf Of predlogo računov
-DocType: Attendance,Attendance Date,Udeležba Datum
-apps/erpnext/erpnext/stock/get_item_details.py +352,Item Price updated for {0} in Price List {1},Kos Cena posodabljati za {0} v ceniku {1}
-DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Plača razpadu temelji na zaslužek in odbitka.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +128,Account with child nodes cannot be converted to ledger,Račun z zapirali vozlišč ni mogoče pretvoriti v knjigo terjatev
-DocType: Purchase Invoice Item,Accepted Warehouse,Accepted Skladišče
-DocType: Bank Reconciliation Detail,Posting Date,Napotitev Datum
-DocType: Item,Valuation Method,Metoda vrednotenja
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203,Mark Half Day,Mark Day Half
-DocType: Sales Invoice,Sales Team,Sales Team
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +87,Duplicate entry,Dvojnik vnos
-DocType: Program Enrollment Tool,Get Students,Get Študenti
-DocType: Serial No,Under Warranty,Pod garancijo
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +516,[Error],[Error]
-DocType: Sales Order,In Words will be visible once you save the Sales Order.,"V besedi bo viden, ko boste shranite Sales Order."
-,Employee Birthday,Zaposleni Rojstni dan
-apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14,Please select Completion Date for Completed Repair,Izberite datum zaključka za dokončano popravilo
-DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Študent Serija Udeležba orodje
-apps/erpnext/erpnext/controllers/status_updater.py +210,Limit Crossed,Limit navzkrižnim
-apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Načrtovani Upto
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55,Venture Capital,Tveganega kapitala
-apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40,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;študijskem letu &#39;{0} in&quot; Trajanje Ime&#39; {1} že obstaja. Prosimo, spremenite te vnose in poskusite znova."
-DocType: UOM,Must be Whole Number,Mora biti celo število
-DocType: Leave Control Panel,New Leaves Allocated (In Days),Nove Listi Dodeljena (v dnevih)
-DocType: Purchase Invoice,Invoice Copy,račun Kopiraj
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,Serijska št {0} ne obstaja
-DocType: Sales Invoice Item,Customer Warehouse (Optional),Skladišče stranka (po želji)
-DocType: Pricing Rule,Discount Percentage,Popust Odstotek
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Reserved for sub contracting,Rezervirano za podizvajalce
-DocType: Payment Reconciliation Invoice,Invoice Number,Številka računa
-DocType: Shopping Cart Settings,Orders,Naročila
-DocType: Employee Leave Approver,Leave Approver,Pustite odobritelju
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285,Please select a batch,Izberite serijo
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42,JournalLib,JournalLib
-DocType: Assessment Group,Assessment Group Name,Ime skupine ocena
-DocType: Manufacturing Settings,Material Transferred for Manufacture,Material Preneseno za Izdelava
-DocType: Landed Cost Item,Receipt Document Type,Prejem Vrsta dokumenta
-DocType: Daily Work Summary Settings,Select Companies,izberite podjetja
-,Issued Items Against Production Order,Izdane Postavke proti proizvodnji reda
-DocType: Antibiotic,Healthcare,Zdravstvo
-DocType: Target Detail,Target Detail,Ciljna Detail
-apps/erpnext/erpnext/stock/doctype/item/item.js +65,Single Variant,Enotna varianta
-apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24,All Jobs,Vsa delovna mesta
-DocType: Sales Order,% of materials billed against this Sales Order,% materiala zaračunano po tej naročilnici
-DocType: Program Enrollment,Mode of Transportation,Način za promet
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49,Period Closing Entry,Obdobje Closing Začetek
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +75,Select Department...,Izberite oddelek ...
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38,Cost Center with existing transactions can not be converted to group,Stroškovno Center z obstoječimi transakcij ni mogoče pretvoriti v skupini
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +367,Amount {0} {1} {2} {3},Znesek {0} {1} {2} {3}
-DocType: Account,Depreciation,Amortizacija
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +102,The number of shares and the share numbers are inconsistent,Število delnic in številke delnic so neskladne
-apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),Dobavitelj (-i)
-DocType: Employee Attendance Tool,Employee Attendance Tool,Zaposleni Udeležba Tool
-DocType: Guardian Student,Guardian Student,Guardian Študent
-DocType: Supplier,Credit Limit,Kreditni limit
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Selling Price List Rate,Povpr. Prodajna cenik tečaja
-DocType: Salary Component,Salary Component,plača Component
-apps/erpnext/erpnext/accounts/utils.py +495,Payment Entries {0} are un-linked,Plačilni Navedbe {0} un povezane
-DocType: GL Entry,Voucher No,Voucher ni
-,Lead Owner Efficiency,Svinec Lastnik Učinkovitost
-,Lead Owner Efficiency,Svinec Lastnik Učinkovitost
-DocType: Leave Allocation,Leave Allocation,Pustite Dodelitev
-DocType: Payment Request,Recipient Message And Payment Details,Prejemnik sporočila in način plačila
-DocType: Training Event,Trainer Email,Trainer Email
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550,Material Requests {0} created,Material Zahteve {0} ustvarjene
-DocType: Restaurant Reservation,No of People,Število ljudi
-apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Predloga izrazov ali pogodbe.
-DocType: Purchase Invoice,Address and Contact,Naslov in Stik
-DocType: Cheque Print Template,Is Account Payable,Je računa plačljivo
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276,Stock cannot be updated against Purchase Receipt {0},Stock ni mogoče posodobiti proti Nakup prejemu {0}
-DocType: Support Settings,Auto close Issue after 7 days,Auto blizu Izdaja po 7 dneh
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +71,"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Dopusta ni mogoče dodeliti pred {0}, saj je bilanca dopust že-carry posredujejo v evidenco dodeljevanja dopust prihodnji {1}"
-apps/erpnext/erpnext/accounts/party.py +318,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Opomba: Zaradi / Referenčni datum presega dovoljene kreditnih stranka dni s {0} dan (s)
-apps/erpnext/erpnext/education/doctype/program/program.js +8,Student Applicant,študent Prijavitelj
-DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINAL ZA PREJEMNIKA
-DocType: Asset Category Account,Accumulated Depreciation Account,Bilančni Amortizacija račun
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11,This email is autogenerated,To e-poštno sporočilo je samodejno generirano
-DocType: Stock Settings,Freeze Stock Entries,Freeze Stock Vnosi
-DocType: Program Enrollment,Boarding Student,Boarding Študent
-DocType: Asset,Expected Value After Useful Life,Pričakovana vrednost Po Koristne življenja
-DocType: Item,Reorder level based on Warehouse,Raven Preureditev temelji na Warehouse
-DocType: Activity Cost,Billing Rate,Zaračunavanje Rate
-,Qty to Deliver,Količina na Deliver
-,Stock Analytics,Analiza zaloge
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +518,Operations cannot be left blank,Operacije se ne sme ostati prazno
-DocType: Maintenance Visit Purpose,Against Document Detail No,Proti Podrobnosti dokumenta št
-apps/erpnext/erpnext/regional/france/utils.py +30,Deletion is not permitted for country {0},Brisanje ni dovoljeno za državo {0}
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +105,Party Type is mandatory,Vrsta Party je obvezen
-DocType: Quality Inspection,Outgoing,Odhodni
-DocType: Material Request,Requested For,Zaprosila za
-DocType: Quotation Item,Against Doctype,Proti DOCTYPE
-apps/erpnext/erpnext/controllers/buying_controller.py +414,{0} {1} is cancelled or closed,{0} {1} je preklican ali končan
-DocType: Asset,Calculate Depreciation,Izračunajte amortizacijo
-DocType: Delivery Note,Track this Delivery Note against any Project,Sledi tej dobavnica proti kateri koli projekt
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +35,Net Cash from Investing,Čisti denarni tok iz naložbenja
-DocType: Production Order,Work-in-Progress Warehouse,Work-in-Progress Warehouse
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Sredstvo {0} je treba predložiti
-DocType: Fee Schedule Program,Total Students,Skupaj študenti
-apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56,Attendance Record {0} exists against Student {1},Šivih {0} obstaja proti Študent {1}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,Reference #{0} dated {1},Referenčna # {0} dne {1}
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164,Depreciation Eliminated due to disposal of assets,Amortizacija je izpadlo zaradi odprodaje premoženja
-DocType: Member,Member,Član
-apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Upravljanje naslovov
-DocType: Pricing Rule,Item Code,Oznaka
-DocType: Serial No,Warranty / AMC Details,Garancija / AMC Podrobnosti
-apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,"Izberite študentov ročno za skupine dejavnosti, ki temelji"
-DocType: Journal Entry,User Remark,Uporabnik Pripomba
-DocType: Lead,Market Segment,Tržni segment
-DocType: Agriculture Analysis Criteria,Agriculture Manager,Kmetijski vodja
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +950,Paid Amount cannot be greater than total negative outstanding amount {0},Plačani znesek ne sme biti večja od celotnega negativnega neplačanega zneska {0}
-DocType: Supplier Scorecard Period,Variables,Spremenljivke
-DocType: Employee Internal Work History,Employee Internal Work History,Zaposleni Notranji Delo Zgodovina
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +249,Closing (Dr),Zapiranje (Dr)
-DocType: Cheque Print Template,Cheque Size,Ček Velikost
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232,Serial No {0} not in stock,Serijska št {0} ni na zalogi
-apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,Davčna predlogo za prodajne transakcije.
-DocType: Sales Invoice,Write Off Outstanding Amount,Napišite Off neporavnanega zneska
-apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27,Account {0} does not match with Company {1},Račun {0} ne ujema z družbo {1}
-DocType: Education Settings,Current Academic Year,Trenutni študijsko leto
-DocType: Stock Settings,Default Stock UOM,Privzeto Stock UOM
-DocType: Asset,Number of Depreciations Booked,Število amortizacije Rezervirano
-apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32,Against Employee Loan: {0},Proti delavcev doba: {0}
-DocType: Landed Cost Item,Receipt Document,prejem dokumenta
-DocType: Employee Education,School/University,Šola / univerza
-DocType: Payment Request,Reference Details,Referenčna Podrobnosti
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +56,Expected Value After Useful Life must be less than Gross Purchase Amount,Pričakovana vrednost Po Življenjska doba sme biti manjša od bruto zneska nakupa
-DocType: Sales Invoice Item,Available Qty at Warehouse,Na voljo Količina na Warehouse
-apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,Zaračunavajo Znesek
-DocType: Share Transfer,(including),(vključno)
-DocType: Asset,Double Declining Balance,Double Upadanje Balance
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180,Closed order cannot be cancelled. Unclose to cancel.,Zaprta naročila ni mogoče preklicati. Unclose za preklic.
-DocType: Student Guardian,Father,oče
-apps/erpnext/erpnext/controllers/accounts_controller.py +626,'Update Stock' cannot be checked for fixed asset sale,"&quot;Update Stock&quot;, ni mogoče preveriti za prodajo osnovnih sredstev"
-DocType: Bank Reconciliation,Bank Reconciliation,Banka Sprava
-DocType: Attendance,On Leave,Na dopustu
-apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,Dobite posodobitve
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: račun {2} ne pripada družbi {3}
-apps/erpnext/erpnext/stock/doctype/item/item.js +368,Select at least one value from each of the attributes.,Izberite vsaj eno vrednost iz vsakega od atributov.
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +166,Material Request {0} is cancelled or stopped,Material Zahteva {0} je odpovedan ali ustavi
-apps/erpnext/erpnext/config/hr.py +310,Leave Management,Pustite upravljanje
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +106,Group by Account,"Skupina, ki jo račun"
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py +21,Please select Employee,Izberite zaposleni
-DocType: Sales Order,Fully Delivered,Popolnoma Delivered
-DocType: Lead,Lower Income,Nižji od dobička
-DocType: Restaurant Order Entry,Current Order,Trenutni naročilo
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +183,Source and target warehouse cannot be same for row {0},Vir in cilj skladišče ne more biti enaka za vrstico {0}
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +243,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Razlika računa mora biti tip Asset / Liability račun, saj je ta Stock Sprava je Entry Otvoritev"
-apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107,Disbursed Amount cannot be greater than Loan Amount {0},Plačanega zneska ne sme biti večja od zneska kredita {0}
-apps/erpnext/erpnext/utilities/user_progress.py +173,Go to Programs,Pojdite v programe
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +203,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},"Vrstica {0} # Razdeljena količina {1} ne sme biti večja od količine, za katero je vložena zahtevka {2}"
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89,Purchase Order number required for Item {0},Naročilnica zahtevanega števila za postavko {0}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +945,Production Order not created,Proizvodnja Sklep ni bil ustvarjen
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date','Od datuma' mora biti za 'Do datuma '
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39,Cannot change status as student {0} is linked with student application {1},"status študenta, ne more spremeniti {0} je povezana z uporabo študentskega {1}"
-DocType: Asset,Fully Depreciated,celoti amortizirana
-DocType: Item Barcode,UPC-A,UPC-A
-,Stock Projected Qty,Stock Predvidena Količina
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +444,Customer {0} does not belong to project {1},"Stranka {0} ne pripada, da projekt {1}"
-DocType: Employee Attendance Tool,Marked Attendance HTML,Markirana Udeležba HTML
-apps/erpnext/erpnext/utilities/activation.py +73,"Quotations are proposals, bids you have sent to your customers","Citati so predlogi, ponudbe, ki ste jih poslali svojim strankam"
-DocType: Sales Invoice,Customer's Purchase Order,Stranke Naročilo
-DocType: Consultation,Patient,Bolnik
-apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Bypass credit check at Sales Order ,Bypass preverjanje kredita na prodajnem naročilu
-DocType: Land Unit,Check if it is a hydroponic unit,"Preverite, ali gre za hidroponično enoto"
-apps/erpnext/erpnext/config/stock.py +109,Serial No and Batch,Serijska številka in serije
-DocType: Warranty Claim,From Company,Od družbe
-apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +52,Sum of Scores of Assessment Criteria needs to be {0}.,Vsota ocen ocenjevalnih meril mora biti {0}.
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,"Prosim, nastavite Število amortizacije Rezervirano"
-DocType: Supplier Scorecard Period,Calculations,Izračuni
-apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +89,Value or Qty,Vrednost ali Kol
-DocType: Payment Terms Template,Payment Terms,Plačilni pogoji
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +448,Productions Orders cannot be raised for:,Produkcije Naročila ni mogoče povečati za:
-apps/erpnext/erpnext/utilities/user_progress.py +144,Minute,Minute
-DocType: Purchase Invoice,Purchase Taxes and Charges,Nakup davki in dajatve
-DocType: Chapter,Meetup Embed HTML,Meetup Vstavi HTML
-apps/erpnext/erpnext/utilities/user_progress.py +118,Go to Suppliers,Pojdi na dobavitelje
-,Qty to Receive,Količina za prejemanje
-DocType: Leave Block List,Leave Block List Allowed,Pustite Block Seznam Dovoljeno
-DocType: Grading Scale Interval,Grading Scale Interval,Ocenjevalna lestvica Interval
-apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49,Expense Claim for Vehicle Log {0},Expense Zahtevek za vozila Prijavi {0}
-DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Popust (%) na Cena iz cenika Oceni z mejo
-DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Popust (%) na Cena iz cenika Oceni z mejo
-apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,Vse Skladišča
-DocType: Sales Partner,Retailer,Retailer
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115,Credit To account must be a Balance Sheet account,Credit Za računu mora biti bilanca računa
-apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +122,All Supplier Types,Vse vrste Dobavitelj
-DocType: Donor,Donor,Darovalec
-DocType: Global Defaults,Disable In Words,"Onemogoči ""z besedami"""
-apps/erpnext/erpnext/stock/doctype/item/item.py +59,Item Code is mandatory because Item is not automatically numbered,"Oznaka je obvezna, ker se postavka samodejno ni oštevilčen"
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98,Quotation {0} not of type {1},Ponudba {0} ni tipa {1}
-DocType: Maintenance Schedule Item,Maintenance Schedule Item,Vzdrževanje Urnik Postavka
-DocType: Sales Order,%  Delivered,% Dostavljeno
-apps/erpnext/erpnext/education/doctype/fees/fees.js +105,Please set the Email ID for the Student to send the Payment Request,"Prosimo, nastavite e-poštni ID za študenta, da pošljete zahtevek za plačilo"
-DocType: Production Order,PRO-,PRO-
-DocType: Patient,Medical History,Zdravstvena zgodovina
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157,Bank Overdraft Account,Bančnem računu računa
-DocType: Patient,Patient ID,ID bolnika
-DocType: Physician Schedule,Schedule Name,Ime seznama
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48,Make Salary Slip,Naredite plačilnega lista
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +840,Add All Suppliers,Dodaj vse dobavitelje
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +89,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Vrstica # {0}: Razporejeni vrednosti ne sme biti večja od neplačanega zneska.
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75,Browse BOM,Prebrskaj BOM
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,Secured Loans,Secured Posojila
-DocType: Purchase Invoice,Edit Posting Date and Time,Uredi datum in uro vnosa
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101,Please set Depreciation related Accounts in Asset Category {0} or Company {1},"Prosim, nastavite račune, povezane Amortizacija v sredstvih kategoriji {0} ali družbe {1}"
-DocType: Lab Test Groups,Normal Range,Normalni obseg
-DocType: Academic Term,Academic Year,Študijsko leto
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Available Selling,Razpoložljiva prodaja
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169,Opening Balance Equity,Otvoritev Balance Equity
-DocType: Lead,CRM,CRM
-DocType: Purchase Invoice,N,N
-apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,preostala
-DocType: Appraisal,Appraisal,Cenitev
-DocType: Purchase Invoice,GST Details,Podrobnosti o GST
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +156,Email sent to supplier {0},E-pošta poslana dobavitelju {0}
-DocType: Item,Default Sales Unit of Measure,Privzeta prodajna enota ukrepa
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Academic Year: ,Študijsko leto:
-DocType: Opportunity,OPTY-,OPTY-
-apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,Datum se ponovi
-apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,Pooblaščeni podpisnik
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +67,Create Fees,Ustvari pristojbine
-DocType: Project,Total Purchase Cost (via Purchase Invoice),Skupaj Nakup Cost (via računu o nakupu)
-DocType: Training Event,Start Time,Začetni čas
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +400,Select Quantity,Izberite Količina
-DocType: Customs Tariff Number,Customs Tariff Number,Carinska tarifa številka
-DocType: Patient Appointment,Patient Appointment,Imenovanje pacienta
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,"Odobritvi vloge ne more biti enaka kot vloga je pravilo, ki veljajo za"
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +64,Unsubscribe from this Email Digest,Odjaviti iz te Email Digest
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +830,Get Suppliers By,Pridobite dobavitelje po
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +172,{0} not found for Item {1},{0} ni najden za postavko {1}
-apps/erpnext/erpnext/utilities/user_progress.py +194,Go to Courses,Pojdi na predmete
-DocType: Accounts Settings,Show Inclusive Tax In Print,Prikaži inkluzivni davek v tisku
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +17,"Bank Account, From Date and To Date are Mandatory","Bančni račun, od datuma do datuma je obvezen"
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,Sporočilo je bilo poslano
-apps/erpnext/erpnext/accounts/doctype/account/account.py +98,Account with child nodes cannot be set as ledger,Račun z zapirali vozlišč ni mogoče nastaviti kot knjigo
-DocType: C-Form,II,II
-DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Obrestna mera, po kateri Cenik valuti se pretvorijo v osn stranke"
-DocType: Purchase Invoice Item,Net Amount (Company Currency),Neto znesek (družba Valuta)
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +213,Total advance amount cannot be greater than total sanctioned amount,Skupni znesek predplačila ne more biti večji od skupnega sankcioniranega zneska
-DocType: Salary Slip,Hour Rate,Urna postavka
-DocType: Stock Settings,Item Naming By,Postavka Poimenovanje S
-apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46,Another Period Closing Entry {0} has been made after {1},Drug zaključnem obdobju Začetek {0} je bil dosežen po {1}
-DocType: Production Order,Material Transferred for Manufacturing,Material Preneseno za Manufacturing
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +41,Account {0} does not exists,Račun {0} ne obstaja
-DocType: Project,Project Type,Projekt Type
-apps/erpnext/erpnext/projects/doctype/task/task.py +142,Child Task exists for this Task. You can not delete this Task.,Otroška naloga obstaja za to nalogo. Te naloge ne morete izbrisati.
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48,DateLet,DateLet
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16,Either target qty or target amount is mandatory.,Bodisi ciljna kol ali ciljna vrednost je obvezna.
-apps/erpnext/erpnext/config/projects.py +51,Cost of various activities,Stroške različnih dejavnosti
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60,"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Nastavitev dogodkov na {0}, saj je zaposlenih pritrjen na spodnji prodaje oseb nima uporabniško {1}"
-DocType: Timesheet,Billing Details,Podrobnosti o obračunavanju
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +163,Source and target warehouse must be different,Vir in cilj skladišče mora biti drugačen
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},"Ni dovoljeno, da posodobite transakcije zalog starejši od {0}"
-DocType: BOM,Inspection Required,Inšpekcijski Zahtevano
-DocType: Purchase Invoice Item,PR Detail,PR Detail
-DocType: Driving License Category,Class,Razred
-DocType: Sales Order,Fully Billed,Popolnoma zaračunavajo
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101,Shipping rule only applicable for Buying,Pravilo o dostavi velja samo za nakup
-DocType: Vital Signs,BMI,ITM
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Denarna sredstva v blagajni
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137,Delivery warehouse required for stock item {0},Dostava skladišče potreben za postavko parka {0}
-DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Bruto teža paketa. Ponavadi neto teža + embalaža teže. (za tisk)
-DocType: Assessment Plan,Program,Program
-DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Uporabniki s to vlogo dovoljeno postaviti na zamrznjene račune in ustvariti / spreminjanje vknjižbe zoper zamrznjenih računih
-DocType: Serial No,Is Cancelled,Je Preklicana
-DocType: Student Group,Group Based On,"Skupina, ki temelji na"
-DocType: Journal Entry,Bill Date,Bill Datum
-DocType: Healthcare Settings,Laboratory SMS Alerts,Laboratorijske opozorila SMS
-apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20,"Service Item,Type,frequency and expense amount are required","morajo Service Element, tip, pogostost in odhodki znesek"
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Tudi če obstaja več cenovnih Pravila z najvišjo prioriteto, se uporabljajo nato naslednji notranje prednostne naloge:"
-DocType: Plant Analysis Criteria,Plant Analysis Criteria,Kriteriji za analizo rastlin
-DocType: Cheque Print Template,Cheque Height,Ček Višina
-DocType: Supplier,Supplier Details,Dobavitelj Podrobnosti
-DocType: Setup Progress,Setup Progress,Napredek nastavitve
-DocType: Hub Settings,Publish Items to Hub,Objavite artikel v Hub
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35,From value must be less than to value in row {0},Iz mora biti vrednost manj kot na vrednosti v vrstici {0}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182,Wire Transfer,Wire Transfer
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92,Check all,Preveri vse
-DocType: Vehicle Log,Invoice Ref,Ref na računu
-DocType: Company,Default Income Account,Privzeto Prihodki račun
-apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32,Customer Group / Customer,Skupina kupec / stranka
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37,Unclosed Fiscal Years Profit / Loss (Credit),Nezaprt proračunskih let dobiček / izguba (Credit)
-DocType: Sales Invoice,Time Sheets,čas listi
-DocType: Lab Test Template,Change In Item,Spremeni v postavki
-DocType: Payment Gateway Account,Default Payment Request Message,Privzeto Sporočilo Plačilnega Naloga
-DocType: Item Group,Check this if you want to show in website,"Označite to, če želite, da kažejo na spletni strani"
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +338,Balance ({0}),Stanje ({0})
-apps/erpnext/erpnext/config/accounts.py +134,Banking and Payments,Bančništvo in plačila
-,Welcome to ERPNext,Dobrodošli na ERPNext
-apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Privede do Kotacija
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +34,Email Reminders will be sent to all parties with email contacts,E-pošta Opomniki bodo poslani vsem strankam z e-poštnimi stiki
-DocType: Patient,A Negative,Negativno
-apps/erpnext/erpnext/templates/includes/product_list.js +45,Nothing more to show.,Nič več pokazati.
-DocType: Lead,From Customer,Od kupca
-apps/erpnext/erpnext/demo/setup/setup_data.py +327,Calls,Poziva
-apps/erpnext/erpnext/utilities/user_progress.py +140,A Product,Izdelek
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207,Batches,Paketi
-apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Naročite časovni razpored
-DocType: Purchase Order Item Supplied,Stock UOM,Stock UOM
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233,Purchase Order {0} is not submitted,Naročilnica {0} ni predložila
-DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normalno referenčno območje za odraslo osebo je 16-20 vdihov / minut (RCP 2012)
-DocType: Customs Tariff Number,Tariff Number,tarifna številka
-DocType: Production Order Item,Available Qty at WIP Warehouse,Na voljo Količina na WIP Warehouse
-apps/erpnext/erpnext/stock/doctype/item/item.js +39,Projected,Predvidoma
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222,Serial No {0} does not belong to Warehouse {1},Serijska št {0} ne pripada Warehouse {1}
-apps/erpnext/erpnext/controllers/status_updater.py +174,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Opomba: Sistem ne bo preveril čez povzetju in over-rezervacije za postavko {0} kot količina ali znesek je 0
-DocType: Notification Control,Quotation Message,Kotacija Sporočilo
-DocType: Employee Loan,Employee Loan Application,Zaposlenih Loan Application
-DocType: Issue,Opening Date,Otvoritev Datum
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +86,Please save the patient first,Najprej shranite bolnika
-apps/erpnext/erpnext/education/api.py +80,Attendance has been marked successfully.,Udeležba je bila uspešno označena.
-DocType: Program Enrollment,Public Transport,Javni prevoz
-DocType: Soil Texture,Silt Composition (%),Siltova sestava (%)
-DocType: Journal Entry,Remark,Pripomba
-DocType: Healthcare Settings,Avoid Confirmation,Izogibajte se potrditvi
-DocType: Purchase Receipt Item,Rate and Amount,Stopnja in znesek
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +171,Account Type for {0} must be {1},Vrsta računa za {0} mora biti {1}
-DocType: Healthcare Settings,Default income accounts to be used if not set in Physician to book Consultation charges.,"Računov neplačil, ki jih je treba uporabiti, če jih zdravnik ni določil za knjiženje stroškov posvetovanja."
-apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Listi in Holiday
-DocType: Education Settings,Current Academic Term,Trenutni Academic Term
-DocType: Education Settings,Current Academic Term,Trenutni Academic Term
-DocType: Sales Order,Not Billed,Ne zaračunavajo
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +77,Both Warehouse must belong to same Company,Oba Skladišče mora pripadati isti družbi
-apps/erpnext/erpnext/public/js/templates/contact_list.html +34,No contacts added yet.,Ni stikov še dodal.
-DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Pristali Stroški bon Znesek
-,Item Balance (Simple),Postavka Balance (Enostavno)
-apps/erpnext/erpnext/config/accounts.py +17,Bills raised by Suppliers.,"Računi, ki jih dobavitelji postavljeno."
-DocType: POS Profile,Write Off Account,Odpišite račun
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +210,Debit Note Amt,Opomin Amt
-apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,Discount Amount,Popust Količina
-DocType: Purchase Invoice,Return Against Purchase Invoice,Vrni proti Račun za nakup
-DocType: Item,Warranty Period (in days),Garancijski rok (v dnevih)
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61,Failed to set defaults,Nastavitev privzetih nastavitev ni uspela
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Povezava z Guardian1
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +787,Please select BOM against item {0},"Prosimo, izberite BOM proti elementu {0}"
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18,Make Invoices,Izdelava računov
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23,Net Cash from Operations,Čisti denarni tok iz poslovanja
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,Postavka 4
-DocType: Student Admission,Admission End Date,Sprejem Končni datum
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30,Sub-contracting,Podizvajalcem
-DocType: Journal Entry Account,Journal Entry Account,Journal Entry račun
-apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3,Student Group,Študentska skupina
-DocType: Shopping Cart Settings,Quotation Series,Zaporedje ponudb
-apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +57,"An item exists with same name ({0}), please change the item group name or rename the item","Element obstaja z istim imenom ({0}), prosimo, spremenite ime postavka skupine ali preimenovanje postavke"
-DocType: Soil Analysis Criteria,Soil Analysis Criteria,Kriteriji za analizo tal
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2039,Please select customer,Izberite stranko
-DocType: C-Form,I,jaz
-DocType: Company,Asset Depreciation Cost Center,Asset Center Amortizacija Stroški
-DocType: Production Plan Sales Order,Sales Order Date,Datum Naročila Kupca
-DocType: Sales Invoice Item,Delivered Qty,Delivered Kol
-DocType: Assessment Plan,Assessment Plan,načrt ocenjevanja
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +93,Customer {0} is created.,Stranka {0} je ustvarjena.
-DocType: Stock Settings,Limit Percent,omejitev Odstotek
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,Trenutno ni na zalogi
-,Payment Period Based On Invoice Date,Plačilo obdobju na podlagi računa Datum
-DocType: Sample Collection,No. of print,Št. Tiskanja
-DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,Rezervacija za hotelsko sobo
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58,Missing Currency Exchange Rates for {0},Manjka Menjalni tečaji za {0}
-DocType: Assessment Plan,Examiner,Examiner
-DocType: Student,Siblings,Bratje in sestre
-DocType: Journal Entry,Stock Entry,Stock Začetek
-DocType: Payment Entry,Payment References,Plačilni Reference
-DocType: C-Form,C-FORM-,C-FORM-
-DocType: Vehicle,Insurance Details,zavarovanje Podrobnosti
-DocType: Account,Payable,Plačljivo
-DocType: Share Balance,Share Type,Vrsta delnice
-apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113,Please enter Repayment Periods,Vnesite roki odplačevanja
-apps/erpnext/erpnext/shopping_cart/cart.py +378,Debtors ({0}),Dolžniki ({0})
-DocType: Pricing Rule,Margin,Margin
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Nove stranke
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Gross Profit %,Bruto dobiček %
-DocType: Appraisal Goal,Weightage (%),Weightage (%)
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +499,Change POS Profile,Spremenite profil POS
-DocType: Bank Reconciliation Detail,Clearance Date,Potrditev Datum
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Ocenjevalno poročilo
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +59,Gross Purchase Amount is mandatory,Bruto znesek nakupa je obvezna
-apps/erpnext/erpnext/setup/doctype/company/company.js +95,Company name not same,Ime podjetja ni isto
-DocType: Lead,Address Desc,Naslov opis izdelka
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +108,Party is mandatory,Party je obvezen
-DocType: Journal Entry,JV-,JV-
-apps/erpnext/erpnext/controllers/accounts_controller.py +707,Rows with duplicate due dates in other rows were found: {list},Vrstice s podvojenimi datumi v drugih vrsticah so bile najdene: {list}
-DocType: Topic,Topic Name,Ime temo
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37,Atleast one of the Selling or Buying must be selected,Mora biti izbran Atleast eden prodaji ali nakupu
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +290,Select an employee to get the employee advance.,"Izberite zaposlenega, da zaposleni vnaprej napreduje."
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56,Please select a valid Date,Izberite veljaven datum
-apps/erpnext/erpnext/public/js/setup_wizard.js +36,Select the nature of your business.,Izberite naravo vašega podjetja.
-DocType: Lab Test Template,"Single for results which require only a single input, result UOM and normal value 
-<br>
-Compound for results which require multiple input fields with corresponding event names, result UOMs and normal values
-<br>
-Descriptive for tests which have multiple result components and corresponding result entry fields. 
-<br>
-Grouped for test templates which are a group of other test templates.
-<br>
-No Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.","Single za rezultate, ki zahtevajo le en vhod, rezultat UOM in normalno vrednost <br> Sestavina za rezultate, ki zahtevajo več vhodnih polj z ustreznimi imeni dogodkov, rezultati UOM in normalne vrednosti <br> Opisno za teste, ki imajo več sestavin rezultatov in ustrezna polja vnosa rezultatov. <br> Združene za preskusne predloge, ki so skupina drugih preskusnih predlog. <br> Brez rezultata za preskuse brez rezultatov. Prav tako ni ustvarjen laboratorijski test. npr. Sub testi za skupinske rezultate."
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +81,Row #{0}: Duplicate entry in References {1} {2},Vrstica # {0}: Duplikat vnos v Referenčni {1} {2}
-apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,Kjer so proizvodni postopki.
-apps/erpnext/erpnext/education/doctype/instructor/instructor.js +18,As Examiner,Kot preizkuševalec
-DocType: Asset Movement,Source Warehouse,Vir Skladišče
-DocType: Installation Note,Installation Date,Datum vgradnje
-apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js +30,Share Ledger,Delež knjige
-apps/erpnext/erpnext/controllers/accounts_controller.py +605,Row #{0}: Asset {1} does not belong to company {2},Row # {0}: Asset {1} ne pripada družbi {2}
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206,Sales Invoice {0} created,Ustvarjen je račun za prodajo {0}
-DocType: Employee,Confirmation Date,Datum potrditve
-DocType: C-Form,Total Invoiced Amount,Skupaj Obračunani znesek
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +50,Min Qty can not be greater than Max Qty,Min Količina ne sme biti večja od Max Kol
-DocType: Soil Texture,Silty Clay,Silty Clay
-DocType: Account,Accumulated Depreciation,Bilančni Amortizacija
-DocType: Supplier Scorecard Scoring Standing,Standing Name,Stalno ime
-DocType: Stock Entry,Customer or Supplier Details,Stranka ali dobavitelj Podrobnosti
-DocType: Employee Loan Application,Required by Date,Zahtevana Datum
-DocType: Lead,Lead Owner,Lastnik ponudbe
-DocType: Production Plan,Sales Orders Detail,Prodajna naročila Podrobnosti
-DocType: Bin,Requested Quantity,Zahtevana količina
-DocType: Patient,Marital Status,Zakonski stan
-DocType: Stock Settings,Auto Material Request,Auto Material Zahteva
-DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Dostopno Serija Količina na IZ SKLADIŠČA
-DocType: Customer,CUST-,CUST-
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50,Idevise,Idevise
-DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Bruto plača - Skupaj Odbitek - Posojilo Povračilo
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +29,Current BOM and New BOM can not be same,Trenutni BOM in New BOM ne more biti enaka
-apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +45,Salary Slip ID,Plača Slip ID
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +118,Date Of Retirement must be greater than Date of Joining,Datum upokojitve mora biti večji od datuma pridružitve
-apps/erpnext/erpnext/stock/doctype/item/item.js +68,Multiple Variants,Večkratne različice
-DocType: Sales Invoice,Against Income Account,Proti dohodkov
-apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% Dostavljeno
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +107,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Postavka {0}: Ž Kol {1} ne more biti nižja od minimalne naročila Kol {2} (opredeljeno v točki).
-DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Mesečni Distribution Odstotek
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +49,Please login as another user.,Prijavite se kot drugi uporabnik.
-DocType: Daily Work Summary Group User,Daily Work Summary Group User,Uporabnik dnevnega dela Povzetek dela
-DocType: Territory,Territory Targets,Territory cilji
-DocType: Soil Analysis,Ca/Mg,Ca / Mg
-DocType: Delivery Note,Transporter Info,Transporter Info
-apps/erpnext/erpnext/accounts/utils.py +502,Please set default {0} in Company {1},"Prosim, nastavite privzeto {0} v družbi {1}"
-DocType: Cheque Print Template,Starting position from top edge,Začetni položaj od zgornjega roba
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +33,Same supplier has been entered multiple times,Enako dobavitelj je bila vpisana večkrat
-apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Kosmati dobiček / izguba
-,Warehouse wise Item Balance Age and Value,Skladiščno pametno Postavka Balansna doba in vrednost
-DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Nakup Sklep Postavka Priložena
-apps/erpnext/erpnext/public/js/setup_wizard.js +94,Company Name cannot be Company,Ime podjetja ne more biti podjetje
-apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Letter Glave za tiskane predloge.
-apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,"Naslovi za tiskane predloge, npr predračunu."
-DocType: Program Enrollment,Walking,Hoditi
-DocType: Student Guardian,Student Guardian,študent Guardian
-DocType: Member,Member Name,Ime člana
-DocType: Stock Settings,Use Naming Series,Uporabite Naming Series
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218,Valuation type charges can not marked as Inclusive,Stroški Tip vrednotenje ni mogoče označiti kot Inclusive
-DocType: POS Profile,Update Stock,Posodobi zalogo
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,in the subscription,v naročnini
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100,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.,"Drugačna UOM za artikle bo privedlo do napačne (skupno) Neto teža vrednosti. Prepričajte se, da je neto teža vsake postavke v istem UOM."
-DocType: Membership,Payment Details,Podatki o plačilu
-apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,BOM Rate
-DocType: Asset,Journal Entry for Scrap,Journal Entry za pretep
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83,Please pull items from Delivery Note,Prosimo povlecite predmete iz dobavnice
-apps/erpnext/erpnext/accounts/utils.py +472,Journal Entries {0} are un-linked,Revija Vnosi {0} so un-povezani
-apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.","Evidenca vseh komunikacij tipa elektronski pošti, telefonu, klepet, obisk, itd"
-DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Ocenjevalno ocenjevalno točko dobavitelja
-DocType: Manufacturer,Manufacturers used in Items,"Proizvajalci, ki se uporabljajo v postavkah"
-apps/erpnext/erpnext/accounts/general_ledger.py +168,Please mention Round Off Cost Center in Company,Navedite zaokrožijo stroškovno mesto v družbi
-DocType: Purchase Invoice,Terms,Pogoji
-DocType: Academic Term,Term Name,izraz Ime
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +332,Credit ({0}),Kredit ({0})
-DocType: Buying Settings,Purchase Order Required,Naročilnica obvezno
-,Item-wise Sales History,Element-pametno Sales Zgodovina
-DocType: Expense Claim,Total Sanctioned Amount,Skupaj sankcionirano Znesek
-DocType: Land Unit,Land Unit,Land enota
-,Purchase Analytics,Odkupne Analytics
-DocType: Sales Invoice Item,Delivery Note Item,Dostava Opomba Postavka
-DocType: Asset Maintenance Log,Task,Naloga
-DocType: Purchase Taxes and Charges,Reference Row #,Referenčna Row #
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76,Batch number is mandatory for Item {0},Serijska številka je obvezna za postavko {0}
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13,This is a root sales person and cannot be edited.,To je koren prodaje oseba in jih ni mogoče urejati.
-DocType: Salary Detail,"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, je vrednost navedena ali izračunana pri tem delu ne bo prispevalo k zaslužka ali odbitkov. Kljub temu, da je vrednost se lahko sklicujejo na druge sestavne dele, ki se lahko dodajo ali odbitih."
-DocType: Salary Detail,"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, je vrednost navedena ali izračunana pri tem delu ne bo prispevalo k zaslužka ali odbitkov. Kljub temu, da je vrednost se lahko sklicujejo na druge sestavne dele, ki se lahko dodajo ali odbitih."
-DocType: Asset Settings,Number of Days in Fiscal Year,Število dni v poslovnem letu
-,Stock Ledger,Stock Ledger
-apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Stopnja: {0}
-DocType: Company,Exchange Gain / Loss Account,Exchange Gain / izida
-apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Zaposlenih in postrežbo
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +92,Purpose must be one of {0},Cilj mora biti eden od {0}
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +100,Fill the form and save it,Izpolnite obrazec in ga shranite
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Forum Skupnost
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52,Actual qty in stock,Dejanska kol v zalogi
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52,Actual qty in stock,Dejanska kol v zalogi
-DocType: Homepage,"URL for ""All Products""",URL za »Vsi izdelki«
-DocType: Leave Application,Leave Balance Before Application,Pustite Stanje pred uporabo
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +46,Send SMS,Pošlji SMS
-DocType: Supplier Scorecard Criteria,Max Score,Najvišji rezultat
-DocType: Cheque Print Template,Width of amount in word,Širina zneska z besedo
-DocType: Company,Default Letter Head,Privzeta glava pisma
-DocType: Purchase Order,Get Items from Open Material Requests,Dobili predmetov iz Odpri Material Prošnje
-DocType: Hotel Room Amenity,Billable,Plačljivo
-DocType: Lab Test Template,Standard Selling Rate,Standardni Prodajni tečaj
-DocType: Account,Rate at which this tax is applied,"Hitrost, s katero se ta davek"
-DocType: Cash Flow Mapper,Section Name,Ime oddelka
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +77,Reorder Qty,Preureditev Kol
-apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28,Current Job Openings,Razpisana delovna
-DocType: Company,Stock Adjustment Account,Račun prilagoditev zaloge
-apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,Odpisati
-DocType: Timesheet Detail,Operation ID,Operacija ID
-DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","Sistem uporabniku (login) ID. Če je nastavljeno, bo postala privzeta za vse oblike HR."
-apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}: Od {1}
-DocType: Task,depends_on,odvisno od
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +60,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Vrstni red za posodobitev najnovejše cene v vseh gradivih. Traja lahko nekaj minut.
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,"Ime novega računa. Opomba: Prosimo, da ne ustvarjajo računov za kupce in dobavitelje"
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,"Prosimo, nastavite imena serije za {0} prek Setup&gt; Settings&gt; Series Naming"
-apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Država pametno privzeti naslov Predloge
-DocType: Water Analysis,Appearance,Videz
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Buying Price List Rate,Povpr. Nakup cenik seznam
-DocType: Sales Order Item,Supplier delivers to Customer,Dobavitelj zagotavlja naročniku
-apps/erpnext/erpnext/config/non_profit.py +23,Member information.,Podatki o članih.
-apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / Item / {0}) ni na zalogi
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +58,Asset Maintenance,Vzdrževanje sredstev
-,Sales Payment Summary,Povzetek prodaje plačila
-DocType: Restaurant,Restaurant,Restavracija
-apps/erpnext/erpnext/accounts/party.py +321,Due / Reference Date cannot be after {0},Zaradi / Referenčni datum ne more biti po {0}
-apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Uvoz in izvoz podatkov
-DocType: Patient,Account Details,podrobnosti računa
-DocType: Crop,Materials Required,Potrebni materiali
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76,No students Found,Najdeno študenti
-DocType: Medical Department,Medical Department,Medicinski oddelek
-DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Merila ocenjevanja rezultatov ocenjevanja dobavitelja
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55,Invoice Posting Date,Račun Napotitev Datum
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,Prodaja
-DocType: Purchase Invoice,Rounded Total,Zaokroženo skupaj
-DocType: Product Bundle,List items that form the package.,"Seznam predmetov, ki tvorijo paket."
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +39,Not permitted. Please disable the Test Template,"Ni dovoljeno. Prosimo, onemogočite preskusno predlogo"
-apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Odstotek dodelitve mora biti enaka 100%
-DocType: Crop Cycle,Linked Land Unit,Povezana zemljiška enota
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584,Please select Posting Date before selecting Party,Izberite datum objave pred izbiro stranko
-DocType: Program Enrollment,School House,šola House
-DocType: Serial No,Out of AMC,Od AMC
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +82,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Število amortizacije naročene ne sme biti večja od skupnega št amortizacije
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Naredite Maintenance obisk
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +222,Please contact to the user who have Sales Master Manager {0} role,"Prosimo, obrnite se na uporabnika, ki imajo Sales Master Manager {0} vlogo"
-DocType: Company,Default Cash Account,Privzeti gotovinski račun
-apps/erpnext/erpnext/config/accounts.py +62,Company (not Customer or Supplier) master.,Company (ne stranka ali dobavitelj) gospodar.
-apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,Ta temelji na prisotnosti tega Študent
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Ni Študenti
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +179,Add more items or open full form,Dodajte več predmetov ali odprto popolno obliko
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Dobavnic {0} je treba preklicati pred preklicem te Sales Order
-apps/erpnext/erpnext/utilities/user_progress.py +256,Go to Users,Pojdi na uporabnike
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,Paid amount + Write Off Amount can not be greater than Grand Total,Plačan znesek + odpis Znesek ne sme biti večja od Grand Skupaj
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,{0} is not a valid Batch Number for Item {1},{0} ni veljavna številka serije za postavko {1}
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +131,Note: There is not enough leave balance for Leave Type {0},Opomba: Ni dovolj bilanca dopust za dopust tipa {0}
-apps/erpnext/erpnext/regional/india/utils.py +16,Invalid GSTIN or Enter NA for Unregistered,Neveljavna GSTIN ali Enter NA za Neregistrirani
-DocType: Training Event,Seminar,seminar
-DocType: Program Enrollment Fee,Program Enrollment Fee,Program Vpis Fee
-DocType: Item,Supplier Items,Dobavitelj Items
-DocType: Opportunity,Opportunity Type,Priložnost Type
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16,New Company,Novo podjetje
-apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17,Transactions can only be deleted by the creator of the Company,Transakcije se lahko izbriše le s ustvarjalca družbe
-apps/erpnext/erpnext/accounts/general_ledger.py +21,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Nepravilno število General Ledger Entries našel. Morda ste izbrali napačen račun v transakciji.
-DocType: Employee,Prefered Contact Email,Prednostna Kontaktni e-naslov
-DocType: Cheque Print Template,Cheque Width,Ček Širina
-DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Potrdite prodajna cena za postavko proti Nakup mero ali vrednotenja
-DocType: Fee Schedule,Fee Schedule,Razpored Fee
-DocType: Hub Settings,Publish Availability,Objavite Razpoložljivost
-DocType: Company,Create Chart Of Accounts Based On,"Ustvariti kontni okvir, ki temelji na"
-apps/erpnext/erpnext/projects/doctype/task/task.js +91,Cannot convert it to non-group. Child Tasks exist.,Ne morete ga pretvoriti v ne-skupino. Otroške naloge obstajajo.
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +112,Date of Birth cannot be greater than today.,"Datum rojstva ne more biti večji, od današnjega."
-,Stock Ageing,Staranje zaloge
-apps/erpnext/erpnext/education/doctype/student/student.py +38,Student {0} exist against student applicant {1},Študent {0} obstaja proti študentskega prijavitelja {1}
-DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Prilagajanje zaokroževanja (valuta podjetja)
-apps/erpnext/erpnext/projects/doctype/task/task.js +39,Timesheet,Evidenca prisotnosti
-DocType: Volunteer,Afternoon,Popoldne
-apps/erpnext/erpnext/controllers/accounts_controller.py +257,{0} '{1}' is disabled,{0} {1} &quot;je onemogočena
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Nastavi kot Odpri
-DocType: Cheque Print Template,Scanned Cheque,skeniranih Ček
-DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Pošlji samodejne elektronske pošte v Contacts o posredovanju transakcij.
-DocType: Timesheet,Total Billable Amount,Skupaj Odgovorni Znesek
-DocType: Customer,Credit Limit and Payment Terms,Kreditno omejitev in plačilni pogoji
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Postavka 3
-apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6,Order Entry,Vnos naročila
-DocType: Purchase Order,Customer Contact Email,Customer Contact Email
-DocType: Warranty Claim,Item and Warranty Details,Točka in Garancija Podrobnosti
-DocType: Chapter,Chapter Members,Članice poglavja
-DocType: Sales Team,Contribution (%),Prispevek (%)
-apps/erpnext/erpnext/controllers/accounts_controller.py +101,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Opomba: Začetek Plačilo se ne bodo ustvarili, saj &quot;gotovinski ali bančni račun&quot; ni bil podan"
-apps/erpnext/erpnext/projects/doctype/project/project.py +69,Project {0} already exists,Projekt {0} že obstaja
-DocType: Medical Department,Nursing User,Uporabnik zdravstvene nege
-DocType: Plant Analysis,Plant Analysis Criterias,Kriteriji za analizo rastlin
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238,Responsibilities,Odgovornosti
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125,Validity period of this quotation has ended.,Obdobje veljavnosti te ponudbe se je končalo.
-DocType: Expense Claim Account,Expense Claim Account,Expense Zahtevek računa
-DocType: Accounts Settings,Allow Stale Exchange Rates,Dovoli tečajne menjalne tečaje
-DocType: Sales Person,Sales Person Name,Prodaja Oseba Name
-apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,Vnesite atleast 1 račun v tabeli
-apps/erpnext/erpnext/utilities/user_progress.py +244,Add Users,Dodaj uporabnike
-DocType: POS Item Group,Item Group,Element Group
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16,Student Group: ,Študentska skupina:
-DocType: Item,Safety Stock,Varnostna zaloga
-DocType: Healthcare Settings,Healthcare Settings,Nastavitve zdravstva
-apps/erpnext/erpnext/projects/doctype/task/task.py +54,Progress % for a task cannot be more than 100.,"Napredek% za nalogo, ne more biti več kot 100."
-DocType: Stock Reconciliation Item,Before reconciliation,Pred uskladitvijo
-apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12,To {0},Za {0}
-DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Davki in dajatve na dodano vrednost (Company Valuta)
-apps/erpnext/erpnext/stock/doctype/item/item.py +475,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Postavka Davčna Row {0} morajo upoštevati vrste davka ali prihodek ali odhodek ali Obdavčljivi
-DocType: Sales Order,Partly Billed,Delno zaračunavajo
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Točka {0} mora biti osnovno sredstvo postavka
-apps/erpnext/erpnext/stock/doctype/item/item.js +343,Make Variants,Make Variants
-DocType: Item,Default BOM,Privzeto BOM
-DocType: Project,Total Billed Amount (via Sales Invoices),Skupni fakturirani znesek (prek prodajnih računov)
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +113,Debit Note Amount,Opomin Znesek
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +106,"There are inconsistencies between the rate, no of shares and the amount calculated","Obstajajo neskladja med stopnjo, brez delnic in izračunanim zneskom"
-apps/erpnext/erpnext/setup/doctype/company/company.js +89,Please re-type company name to confirm,"Prosimo, ponovno tip firma za potrditev"
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +211,Total Outstanding Amt,Skupaj Izjemna Amt
-DocType: Journal Entry,Printing Settings,Nastavitve tiskanja
-DocType: Employee Advance,Advance Account,Predplačniški račun
-DocType: Job Offer,Job Offer Terms,Pogoji ponudb za delo
-DocType: Sales Invoice,Include Payment (POS),Vključujejo plačilo (POS)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,Total Debit must be equal to Total Credit. The difference is {0},Skupaj obremenitve mora biti enaka celotnemu kreditnemu. Razlika je {0}
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11,Automotive,Avtomobilizem
-DocType: Vehicle,Insurance Company,Zavarovalnica
-DocType: Asset Category Account,Fixed Asset Account,Fiksna račun premoženja
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414,Variable,spremenljivka
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Od dobavnica
-DocType: Chapter,Members,Člani
-DocType: Student,Student Email Address,Študent e-poštni naslov
-DocType: Item,Hub Warehouse,Vozliščno skladišče
-DocType: Assessment Plan,From Time,Od časa
-DocType: Hotel Settings,Hotel Settings,Hotelske nastavitve
-apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock: ,Na zalogi:
-DocType: Notification Control,Custom Message,Sporočilo po meri
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33,Investment Banking,Investicijsko bančništvo
-DocType: Purchase Invoice,input,vnos
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79,Cash or Bank Account is mandatory for making payment entry,Gotovina ali bančnega računa je obvezen za izdelavo vnos plačila
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,študent Naslov
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,študent Naslov
-DocType: Purchase Invoice,Price List Exchange Rate,Cenik Exchange Rate
-apps/erpnext/erpnext/accounts/doctype/account/account.py +251,Account Number {0} already used in account {1},Številka računa {0} je že uporabljena v računu {1}
-DocType: POS Profile,POS Profile Name,Ime profila profila POS
-DocType: Hotel Room Reservation,Booked,Rezervirano
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45,CompAuxLib,CompAuxLib
-DocType: Purchase Invoice Item,Rate,Vrednost
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104,Intern,Intern
-DocType: Delivery Stop,Address Name,naslov Ime
-DocType: Stock Entry,From BOM,Od BOM
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +639,Splitting {0} units of {1},Razdelitev {0} enot {1}
-DocType: Assessment Code,Assessment Code,Koda ocena
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73,Basic,Osnovni
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Zaloga transakcije pred {0} so zamrznjeni
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219,Please click on 'Generate Schedule',"Prosimo, kliknite na &quot;ustvarjajo Seznamu&quot;"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122,Reference No is mandatory if you entered Reference Date,"Referenčna številka je obvezna, če ste vnesli Referenčni datum"
-DocType: Bank Reconciliation Detail,Payment Document,plačilo dokumentov
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37,Error evaluating the criteria formula,Napaka pri ocenjevanju formule za merila
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +115,Date of Joining must be greater than Date of Birth,Datum pridružitva mora biti večji od datuma rojstva
-DocType: Salary Slip,Salary Structure,Struktura Plače
-DocType: Account,Bank,Banka
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9,Airline,Airline
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +853,Issue Material,Vprašanje Material
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,An error occured while creating recurring,Pri ustvarjanju ponavljajoče se napake
-DocType: Material Request Item,For Warehouse,Za Skladišče
-DocType: Employee,Offer Date,Ponudba Datum
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,Ponudbe
-apps/erpnext/erpnext/accounts/page/pos/pos.js +735,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 naložiti, dokler imate omrežje."
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,ustvaril nobene skupine študentov.
-DocType: Purchase Invoice Item,Serial No,Zaporedna številka
-apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119,Monthly Repayment Amount cannot be greater than Loan Amount,Mesečni Povračilo Znesek ne sme biti večja od zneska kredita
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143,Please enter Maintaince Details first,"Prosimo, da najprej vnesete Maintaince Podrobnosti"
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Vrstica # {0}: Pričakovani datum dostave ne sme biti pred datumom naročila
-DocType: Purchase Invoice,Print Language,Jezik tiskanja
-DocType: Salary Slip,Total Working Hours,Skupaj Delovni čas
-DocType: Sales Invoice,Customer PO Details,Podrobnosti kupca PO
-DocType: Subscription,Next Schedule Date,Naslednji datum načrta
-DocType: Stock Entry,Including items for sub assemblies,"Vključno s postavkami, za sklope"
-DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Začasni odpiranje računa
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1962,Enter value must be positive,Vnesite vrednost mora biti pozitivna
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +446,All Territories,Vse Territories
-DocType: Purchase Invoice,Items,Predmeti
-apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34,Student is already enrolled.,Študent je že vpisan.
-DocType: Fiscal Year,Year Name,Leto Name
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +240,There are more holidays than working days this month.,Obstaja več prazniki od delovnih dneh tega meseca.
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +78,PDC/LC Ref,PDC / LC Ref
-DocType: Product Bundle Item,Product Bundle Item,Izdelek Bundle Postavka
-DocType: Sales Partner,Sales Partner Name,Prodaja Partner Name
-apps/erpnext/erpnext/hooks.py +136,Request for Quotations,Zahteva za Citati
-DocType: Payment Reconciliation,Maximum Invoice Amount,Največja Znesek računa
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50,Montantdevise,Montantdevise
-apps/erpnext/erpnext/healthcare/setup.py +210,Haematology,Hematologija
-DocType: Normal Test Items,Normal Test Items,Normalni preskusni elementi
-DocType: Student Language,Student Language,študent jezik
-apps/erpnext/erpnext/config/selling.py +23,Customers,Stranke
-DocType: Cash Flow Mapping,Is Working Capital,Je delovni kapital
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Naročilo / quot%
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Naročilo / quot%
-apps/erpnext/erpnext/config/healthcare.py +25,Record Patient Vitals,Zapišite bolnike vitale
-DocType: Fee Schedule,Institution,ustanova
-DocType: Asset,Partially Depreciated,delno amortiziranih
-DocType: Issue,Opening Time,Otvoritev čas
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +92,From and To dates required,Od in Do datumov zahtevanih
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46,Securities & Commodity Exchanges,Vrednostnih papirjev in blagovne borze
-apps/erpnext/erpnext/stock/doctype/item/item.py +688,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Privzeto mersko enoto za Variant &#39;{0}&#39; mora biti enaka kot v predlogo &#39;{1}&#39;
-DocType: Shipping Rule,Calculate Based On,Izračun temelji na
-DocType: Delivery Note Item,From Warehouse,Iz skladišča
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59,No employees for the mentioned criteria,Za omenjena merila ni zaposlenih
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +946,No Items with Bill of Materials to Manufacture,Ni Postavke z Bill materialov za Izdelava
-DocType: Hotel Settings,Default Customer,Privzeta stranka
-DocType: Assessment Plan,Supervisor Name,Ime nadzornik
-DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,"Ne potrdite, če je sestanek ustvarjen za isti dan"
-DocType: Program Enrollment Course,Program Enrollment Course,Program Vpis tečaj
-DocType: Program Enrollment Course,Program Enrollment Course,Program Vpis tečaj
-DocType: Purchase Taxes and Charges,Valuation and Total,Vrednotenje in Total
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11,Scorecards,Oglednice
-DocType: Tax Rule,Shipping City,Dostava Mesto
-DocType: Notification Control,Customize the Notification,Prilagodite Obvestilo
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24,Cash Flow from Operations,Denarni tok iz poslovanja
-DocType: Purchase Invoice,Shipping Rule,Pravilo za dostavo
-DocType: Patient Relation,Spouse,Zakonec
-DocType: Lab Test Groups,Add Test,Dodaj test
-DocType: Manufacturer,Limited to 12 characters,Omejena na 12 znakov
-DocType: Journal Entry,Print Heading,Glava postavk
-apps/erpnext/erpnext/config/stock.py +146,Delivery Trip service tours to customers.,Dostava Trip potovanja službe za stranke.
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57,Total cannot be zero,Skupaj ne more biti nič
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,"""Dnevi od zadnjega naročila"" morajo biti večji ali enak nič"
-DocType: Plant Analysis Criteria,Maximum Permissible Value,Najvišja dovoljena vrednost
-DocType: Journal Entry Account,Employee Advance,Napredek zaposlenih
-DocType: Payroll Entry,Payroll Frequency,izplačane Frequency
-DocType: Lab Test Template,Sensitivity,Občutljivost
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +932,Raw Material,Surovina
-DocType: Leave Application,Follow via Email,Sledite preko e-maila
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55,Plants and Machineries,Rastline in stroje
-DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Davčna Znesek Po Popust Znesek
-DocType: Daily Work Summary Settings,Daily Work Summary Settings,Dnevni Nastavitve Delo Povzetek
-apps/erpnext/erpnext/controllers/buying_controller.py +457,Please enter Reqd by Date,Vnesite Reqd po datumu
-DocType: Payment Entry,Internal Transfer,Interni prenos
-DocType: Asset Maintenance,Maintenance Tasks,Vzdrževalna opravila
-apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,Bodisi ciljna kol ali ciljna vrednost je obvezna
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366,Please select Posting Date first,"Prosimo, izberite datumom knjiženja najprej"
-apps/erpnext/erpnext/public/js/account_tree_grid.js +210,Opening Date should be before Closing Date,Pričetek mora biti pred Zapiranje Datum
-DocType: Leave Control Panel,Carry Forward,Carry Forward
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cost Center with existing transactions can not be converted to ledger,Stroškovno Center z obstoječimi transakcij ni mogoče pretvoriti v knjigo terjatev
-DocType: Department,Days for which Holidays are blocked for this department.,"Dni, za katere so Holidays blokirana za ta oddelek."
-DocType: Crop Cycle,Detected Disease,Detektirana bolezen
-,Produced,Proizvedena
-DocType: Item,Item Code for Suppliers,Oznaka za dobavitelje
-DocType: Issue,Raised By (Email),Postavljeno Z (e-naslov)
-DocType: Training Event,Trainer Name,Ime Trainer
-DocType: Mode of Payment,General,Splošno
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Zadnje sporočilo
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Zadnje sporočilo
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Ne more odbiti, če je kategorija za &quot;vrednotenje&quot; ali &quot;Vrednotenje in Total&quot;"
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +234,Serial Nos Required for Serialized Item {0},Serijska št Zahtevano za zaporednimi postavki {0}
-apps/erpnext/erpnext/config/accounts.py +144,Match Payments with Invoices,Match plačila z računov
-DocType: Journal Entry,Bank Entry,Banka Začetek
-DocType: Authorization Rule,Applicable To (Designation),Ki se uporabljajo za (Oznaka)
-,Profitability Analysis,Analiza dobičkonosnosti
-DocType: Fees,Student Email,Student Email
-DocType: Supplier,Prevent POs,Preprečevanje PO
-DocType: Patient,"Allergies, Medical and Surgical History","Alergije, medicinska in kirurška zgodovina"
-apps/erpnext/erpnext/templates/generators/item.html +77,Add to Cart,Dodaj v voziček
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Skupina S
-DocType: Guardian,Interests,Zanima
-apps/erpnext/erpnext/config/accounts.py +298,Enable / disable currencies.,Omogoči / onemogoči valute.
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +110,Dr {0} on Half day Leave on {1},Dr {0} na poldnevni dan pustite {1}
-DocType: Production Plan,Get Material Request,Get Zahteva material
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Postal Expenses,Poštni stroški
-apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Skupaj (Amt)
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26,Entertainment & Leisure,Zabava &amp; prosti čas
-,Item Variant Details,Podrobnosti o elementu Variante
-DocType: Quality Inspection,Item Serial No,Postavka Zaporedna številka
-apps/erpnext/erpnext/utilities/activation.py +135,Create Employee Records,Ustvari zaposlencev zapisov
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Present,Skupaj Present
-apps/erpnext/erpnext/config/accounts.py +105,Accounting Statements,računovodski izkazi
-DocType: Drug Prescription,Hour,Ura
-DocType: Restaurant Order Entry,Last Sales Invoice,Zadnji račun za prodajo
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +789,Please select Qty against item {0},Izberite količino proti elementu {0}
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Nova serijska številka ne more imeti skladišče. Skladišče mora nastaviti borze vstopu ali Potrdilo o nakupu
-DocType: Lead,Lead Type,Tip ponudbe
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +115,You are not authorized to approve leaves on Block Dates,Niste pooblaščeni za odobritev liste na Block termini
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +392,All these items have already been invoiced,Vsi ti artikli so že bili obračunani
-DocType: Company,Monthly Sales Target,Mesečni prodajni cilj
-apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Mogoče odobriti {0}
-DocType: Hotel Room,Hotel Room Type,Tip sobe hotela
-DocType: Item,Default Material Request Type,Privzeto Material Vrsta Zahteva
-DocType: Supplier Scorecard,Evaluation Period,Ocenjevalno obdobje
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13,Unknown,Neznan
-DocType: Shipping Rule,Shipping Rule Conditions,Pogoji dostavnega pravila
-DocType: Purchase Invoice,Export Type,Izvozna vrsta
-DocType: Salary Slip Loan,Salary Slip Loan,Posojilo za plačilo
-DocType: BOM Update Tool,The new BOM after replacement,Novi BOM po zamenjavi
-,Point of Sale,Prodajno mesto
-DocType: Payment Entry,Received Amount,prejela znesek
-DocType: Patient,Widow,Vdova
-DocType: GST Settings,GSTIN Email Sent On,"GSTIN e-pošti,"
-DocType: Program Enrollment,Pick/Drop by Guardian,Pick / znižala za Guardian
-DocType: Crop,Planting UOM,Sajenje UOM
-DocType: Account,Tax,Davčna
-apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,ne Označeno
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1,Opening Invoices Summary,Povzetek povzetka računov
-DocType: Education Settings,Education Manager,Vodja izobraževanja
-DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Najmanjša dolžina med posameznimi rastlinami na polju za optimalno rast
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry",Združena Točka {0} ni mogoče posodobiti uporabo zaloga spravi namesto uporabiti zaloga Entry
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry",Združena Točka {0} ni mogoče posodobiti uporabo zaloga spravi namesto uporabiti zaloga Entry
-DocType: Quality Inspection,Report Date,Poročilo Datum
-DocType: Student,Middle Name,Srednje ime
-DocType: C-Form,Invoices,Računi
-DocType: Water Analysis,Type of Sample,Vrsta vzorca
-DocType: Batch,Source Document Name,Vir Ime dokumenta
-DocType: Batch,Source Document Name,Vir Ime dokumenta
-DocType: Production Plan,Get Raw Materials For Production,Pridobite surovine za proizvodnjo
-DocType: Job Opening,Job Title,Job Naslov
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84,"{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 podal ponudbe, ampak cene vseh postavk so navedene. Posodabljanje statusa ponudb RFQ."
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1012,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Največji vzorci - {0} so bili že shranjeni za serijo {1} in element {2} v seriji {3}.
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +125,Please Set Supplier Type in Buying Settings.,V nastavitvah nakupa izberite dobavitelja.
-DocType: Manufacturing Settings,Update BOM Cost Automatically,Posodobi BOM stroškov samodejno
-DocType: Lab Test,Test Name,Ime preskusa
-apps/erpnext/erpnext/utilities/activation.py +99,Create Users,Ustvari uporabnike
-apps/erpnext/erpnext/utilities/user_progress.py +144,Gram,gram
-DocType: Supplier Scorecard,Per Month,Na mesec
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +433,Quantity to Manufacture must be greater than 0.,Količina na Izdelava mora biti večja od 0.
-DocType: Asset Settings,Calculate Prorated Depreciation Schedule Based on Fiscal Year,Izračunajte proporcionalno amortizacijsko shemo na podlagi davčnega leta
-apps/erpnext/erpnext/config/maintenance.py +17,Visit report for maintenance call.,Obiščite poročilo za vzdrževalna klic.
-DocType: Stock Entry,Update Rate and Availability,Posodobitev Oceni in razpoložljivost
-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 ste dovoljeno prejemati ali dostaviti bolj proti količine naročenega. Na primer: Če ste naročili 100 enot. in vaš dodatek za 10%, potem ste lahko prejeli 110 enot."
-DocType: POS Customer Group,Customer Group,Skupina za stranke
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +128,New Batch ID (Optional),Nova Serija ID (po želji)
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201,Expense account is mandatory for item {0},Expense račun je obvezna za postavko {0}
-DocType: BOM,Website Description,Spletna stran Opis
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +47,Net Change in Equity,Neto sprememba v kapitalu
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +220,Please cancel Purchase Invoice {0} first,Prosim za prekinitev računu o nakupu {0} najprej
-apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"Email Address must be unique, already exists for {0}","E-poštni naslov mora biti edinstven, že obstaja za {0}"
-DocType: Serial No,AMC Expiry Date,AMC preteka Datum
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +871,Receipt,prejem
-,Sales Register,Prodaja Register
-DocType: Daily Work Summary Group,Send Emails At,Pošlji e-pošte na
-DocType: Quotation,Quotation Lost Reason,Kotacija Lost Razlog
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374,Transaction reference no {0} dated {1},Referenčna transakcija ni {0} dne {1}
-apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Nič ni za urejanje.
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116,Summary for this month and pending activities,Povzetek za ta mesec in v teku dejavnosti
-apps/erpnext/erpnext/utilities/user_progress.py +245,"Add users to your organization, other than yourself.","Dodajte uporabnike v svojo organizacijo, razen sebe."
-DocType: Customer Group,Customer Group Name,Skupina Ime stranke
-apps/erpnext/erpnext/public/js/pos/pos.html +98,No Customers yet!,Ni še nobene stranke!
-apps/erpnext/erpnext/public/js/financial_statements.js +56,Cash Flow Statement,Izkaz denarnih tokov
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +472,No material request created,Ni ustvarjeno nobeno materialno zahtevo
-apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23,Loan Amount cannot exceed Maximum Loan Amount of {0},Kredita vrednosti ne sme preseči najvišji možen kredit znesku {0}
-apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22,License,licenca
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +491,Please remove this Invoice {0} from C-Form {1},"Prosimo, odstranite tej fakturi {0} od C-Form {1}"
-DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,"Prosimo, izberite Carry Forward, če želite vključiti tudi v preteklem poslovnem letu je bilanca prepušča tem fiskalnem letu"
-DocType: GL Entry,Against Voucher Type,Proti bon Type
-DocType: Physician,Phone (R),Telefon (R)
-apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +50,Time slots added,Dodane so časovne reže
-DocType: Item,Attributes,Atributi
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31,Enable Template,Omogoči predlogo
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226,Please enter Write Off Account,Vnesite račun za odpis
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Zadnja Datum naročila
-DocType: Patient,B Negative,B Negativno
-apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25,Maintenance Status has to be Cancelled or Completed to Submit,"Stanje vzdrževanja je treba preklicati ali končati, da ga pošljete"
-DocType: Hotel Room,Hotel Room,Hotelska soba
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47,Account {0} does not belongs to company {1},Račun {0} ne pripada podjetju {1}
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +884,Serial Numbers in row {0} does not match with Delivery Note,Številke v vrstici {0} se ne ujema z dobavnice
-DocType: Student,Guardian Details,Guardian Podrobnosti
-DocType: C-Form,C-Form,C-Form
-apps/erpnext/erpnext/config/hr.py +18,Mark Attendance for multiple employees,Mark Udeležba za več zaposlenih
-DocType: Agriculture Task,Start Day,Začni dan
-DocType: Vehicle,Chassis No,podvozje ni
-DocType: Payment Request,Initiated,Začela
-DocType: Production Order,Planned Start Date,Načrtovani datum začetka
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +613,Please select a BOM,Izberite BOM
-DocType: Purchase Invoice,Availed ITC Integrated Tax,Uporabil integrirani davek ITC
-DocType: Serial No,Creation Document Type,Creation Document Type
-DocType: Project Task,View Timesheet,Ogled Timesheet
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54,End date must be greater than start date,Končni datum mora biti večji od začetnega datuma
-DocType: Leave Type,Is Encash,Je vnovči
-DocType: Leave Allocation,New Leaves Allocated,Nove Listi Dodeljena
-apps/erpnext/erpnext/controllers/trends.py +269,Project-wise data is not available for Quotation,Podatki projekt pametno ni na voljo za ponudbo
-apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30,End on,Končaj naprej
-DocType: Project,Expected End Date,Pričakovani datum zaključka
-DocType: Budget Account,Budget Amount,proračun Znesek
-DocType: Donor,Donor Name,Ime donatorja
-DocType: Appraisal Template,Appraisal Template Title,Cenitev Predloga Naslov
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39,From Date {0} for Employee {1} cannot be before employee's joining Date {2},Od datuma {0} za zaposlenih {1} ne more biti pred povezuje Datum delavca {2}
-apps/erpnext/erpnext/utilities/user_progress_utils.py +29,Commercial,Commercial
-DocType: Patient,Alcohol Current Use,Alkoholna trenutna uporaba
-DocType: Student Admission Program,Student Admission Program,Program sprejema študentov
-DocType: Payment Entry,Account Paid To,Račun Izplača
-apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24,Parent Item {0} must not be a Stock Item,Parent Item {0} ne sme biti Stock Postavka
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +461,"Could not submit any Salary Slip <br>\
-			Possible reasons: <br>\
-			1. Net pay is less than 0. <br>\
-			2. Company Email Address specified in employee master is not valid. <br>","Ni bilo mogoče predložiti plačilnega lista <br> \ Možni razlogi: <br> \ 1. Neto plačilo je manjše od 0. <br> \ 2. E-poštni naslov podjetja, ki je naveden v poveljniku zaposlenega, ni veljaven. <br>"
-apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Vse izdelke ali storitve.
-DocType: Expense Claim,More Details,Več podrobnosti
-DocType: Supplier Quotation,Supplier Address,Dobavitelj Naslov
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} proračun za račun {1} na {2} {3} je {4}. Bo prekoračen za {5}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +695,Row {0}# Account must be of type 'Fixed Asset',Vrstica {0} # računa mora biti tipa &quot;osnovno sredstvo&quot;
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Out Kol
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,and unchcked Disabled in the,in unchcked Onemogočeno v
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +46,Series is mandatory,Serija je obvezna
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28,Financial Services,Finančne storitve
-DocType: Student Sibling,Student ID,Student ID
-apps/erpnext/erpnext/config/projects.py +46,Types of activities for Time Logs,Vrste dejavnosti za Čas Dnevniki
-DocType: Opening Invoice Creation Tool,Sales,Prodaja
-DocType: Stock Entry Detail,Basic Amount,Osnovni znesek
-DocType: Training Event,Exam,Izpit
-DocType: Complaint,Complaint,Pritožba
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +462,Warehouse required for stock Item {0},Skladišče je potrebna za borzo postavki {0}
-DocType: Leave Allocation,Unused leaves,Neizkoriščene listi
-DocType: Patient,Alcohol Past Use,Pretekla uporaba alkohola
-DocType: Fertilizer Content,Fertilizer Content,Vsebina gnojil
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +187,Cr,Cr
-DocType: Tax Rule,Billing State,Država za zaračunavanje
-DocType: Share Transfer,Transfer,Prenos
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +917,Fetch exploded BOM (including sub-assemblies),Fetch eksplodiral BOM (vključno podsklopov)
-DocType: Authorization Rule,Applicable To (Employee),Ki se uporabljajo za (zaposlenih)
-apps/erpnext/erpnext/controllers/accounts_controller.py +136,Due Date is mandatory,Datum zapadlosti je obvezno
-apps/erpnext/erpnext/controllers/item_variant.py +82,Increment for Attribute {0} cannot be 0,Prirastek za Attribute {0} ne more biti 0
-apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19,Rooms Booked,Sobe Rezervirano
-DocType: Journal Entry,Pay To / Recd From,Pay / Recd Od
-DocType: Naming Series,Setup Series,Nastavitve zaporedja
-DocType: Payment Reconciliation,To Invoice Date,Če želite Datum računa
-DocType: Shareholder,Contact HTML,Kontakt HTML
-apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19,Registration fee can not be Zero,Prijavnina ne sme biti nič
-DocType: Disease,Treatment Period,Obdobje zdravljenja
-apps/erpnext/erpnext/education/api.py +338,Result already Submitted,Rezultat že oddan
-apps/erpnext/erpnext/controllers/buying_controller.py +169,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Rezervirano skladišče je obvezno za postavko {0} v dobavljenih surovinah
-,Inactive Customers,neaktivne stranke
-DocType: Student Admission Program,Maximum Age,Najvišja starost
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28,Please wait 3 days before resending the reminder.,Počakajte 3 dni pred ponovnim pošiljanjem opomnika.
-DocType: Landed Cost Voucher,LCV,LCV
-DocType: Landed Cost Voucher,Purchase Receipts,Odkupne Prejemki
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29,How Pricing Rule is applied?,Kako se uporablja cenovno pravilo?
-DocType: Stock Entry,Delivery Note No,Dostava Opomba Ne
-DocType: Cheque Print Template,Message to show,Sporočilo za prikaz
-apps/erpnext/erpnext/public/js/setup_wizard.js +28,Retail,Maloprodaja
-DocType: Student Attendance,Absent,Odsoten
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591,Product Bundle,Bundle izdelek
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38,Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,"Rezultate ni mogoče najti od {0}. Imeti morate stoječe rezultate, ki pokrivajo od 0 do 100"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212,Row {0}: Invalid reference {1},Vrstica {0}: Neveljavna referenčna {1}
-DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Nakup davki in dajatve Template
-DocType: Timesheet,TS-,TS-
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: zahtevan je debetni ali kreditni znesek za {2}
-DocType: GL Entry,Remarks,Opombe
-DocType: Hotel Room Amenity,Hotel Room Amenity,Hotelska ugodnost
-DocType: Payment Entry,Account Paid From,Račun se plača iz
-DocType: Purchase Order Item Supplied,Raw Material Item Code,Raw Material Oznaka
-DocType: Task,Parent Task,Naloga staršev
-DocType: Journal Entry,Write Off Based On,Odpisuje temelji na
-apps/erpnext/erpnext/utilities/activation.py +65,Make Lead,Naredite Lead
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112,Print and Stationery,Tiskanje in Pisalne
-DocType: Stock Settings,Show Barcode Field,Prikaži Barcode Field
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +809,Send Supplier Emails,Pošlji Dobavitelj e-pošte
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +97,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Plača je že pripravljena za obdobje med {0} in {1}, Pusti obdobje uporabe ne more biti med tem časovnem obdobju."
-DocType: Chapter Member,Leave Reason,Pustite razlog
-DocType: Guardian Interest,Guardian Interest,Guardian Obresti
-DocType: Volunteer,Availability,Razpoložljivost
-apps/erpnext/erpnext/config/accounts.py +319,Setup default values for POS Invoices,Nastavitev privzetih vrednosti za račune POS
-apps/erpnext/erpnext/config/hr.py +182,Training,usposabljanje
-DocType: Timesheet,Employee Detail,Podrobnosti zaposleni
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 E-ID
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 E-ID
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68,Next Date's day and Repeat on Day of Month must be equal,"Naslednji datum za dan in ponovite na dnevih v mesecu, mora biti enaka"
-DocType: Lab Prescription,Test Code,Testna koda
-apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Nastavitve za spletni strani
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +40,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ-ji niso dovoljeni za {0} zaradi postavke ocene rezultatov {1}
-DocType: Job Offer,Awaiting Response,Čakanje na odgovor
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60,Above,Nad
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1462,Total Amount {0},Skupni znesek {0}
-apps/erpnext/erpnext/controllers/item_variant.py +303,Invalid attribute {0} {1},Neveljaven atribut {0} {1}
-DocType: Supplier,Mention if non-standard payable account,Omemba če nestandardni plača račun
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +25,Please select the assessment group other than 'All Assessment Groups',"Izberite ocenjevalne skupine, razen &quot;vseh skupin za presojo&quot;"
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67,Row {0}: Cost center is required for an item {1},Vrstica {0}: Za postavko je potreben stroškovni center {1}
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43,EcritureDate,EcritureDate
-DocType: Training Event Employee,Optional,Neobvezno
-DocType: Salary Slip,Earning & Deduction,Zaslužek &amp; Odbitek
-DocType: Agriculture Analysis Criteria,Water Analysis,Analiza vode
-DocType: Chapter,Region,Regija
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38,Optional. This setting will be used to filter in various transactions.,Neobvezno. Ta nastavitev bo uporabljena za filtriranje v različnih poslih.
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +110,Negative Valuation Rate is not allowed,Negativno Oceni Vrednotenje ni dovoljeno
-DocType: Holiday List,Weekly Off,Tedenski Off
-apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7,Reload Linked Analysis,Ponovno naloži povezano analizo
-DocType: Fiscal Year,"For e.g. 2012, 2012-13","Za primer leta 2012, 2012-13"
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96,Provisional Profit / Loss (Credit),Začasna dobiček / izguba (Credit)
-DocType: Sales Invoice,Return Against Sales Invoice,Vrni proti prodajne fakture
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32,Item 5,Postavka 5
-DocType: Serial No,Creation Time,Čas ustvarjanja
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62,Total Revenue,Skupni prihodki
-DocType: Patient,Other Risk Factors,Drugi dejavniki tveganja
-DocType: Sales Invoice,Product Bundle Help,Izdelek Bundle Pomoč
-,Monthly Attendance Sheet,Mesečni Udeležba Sheet
-DocType: Production Order Item,Production Order Item,Proizvodnja nakup Izdelek
-apps/erpnext/erpnext/healthcare/report/lab_test_report/lab_test_report.py +15,No record found,Nobenega zapisa najdenih
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140,Cost of Scrapped Asset,Stroški izločeni sredstvi
-apps/erpnext/erpnext/controllers/stock_controller.py +236,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Stroškovno mesto je zahtevano za postavko {2}
-DocType: Vehicle,Policy No,Pravilnik št
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +686,Get Items from Product Bundle,Dobili predmetov iz Bundle izdelkov
-DocType: Asset,Straight Line,Ravna črta
-DocType: Project User,Project User,projekt Uporabnik
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +72,Split,Split
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +72,Split,Split
-DocType: GL Entry,Is Advance,Je Advance
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,Udeležba Od datuma in udeležba na Datum je obvezna
-apps/erpnext/erpnext/controllers/buying_controller.py +156,Please enter 'Is Subcontracted' as Yes or No,"Prosimo, vpišite &quot;Je v podizvajanje&quot;, kot DA ali NE"
-DocType: Item,Default Purchase Unit of Measure,Privzeta nabavna enota ukrepa
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Zadnje Sporočilo Datum
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Zadnje Sporočilo Datum
-DocType: Sales Team,Contact No.,Kontakt št.
-DocType: Bank Reconciliation,Payment Entries,Plačilni vnosi
-DocType: Land Unit,Land Unit Details,Podrobnosti o kopenskih enotah
-DocType: Land Unit,Latitude,Zemljepisna širina
-DocType: Production Order,Scrap Warehouse,ostanki Skladišče
-DocType: Production Order,Check if material transfer entry is not required,"Preverite, ali je vpis prenosa materiala ni potrebno"
-DocType: Production Order,Check if material transfer entry is not required,"Preverite, ali je vpis prenosa materiala ni potrebno"
-DocType: Program Enrollment Tool,Get Students From,Dobili študenti iz
-apps/erpnext/erpnext/config/learn.py +263,Publish Items on Website,Objavite elementov na spletni strani
-apps/erpnext/erpnext/utilities/activation.py +126,Group your students in batches,Skupina učenci v serijah
-DocType: Authorization Rule,Authorization Rule,Dovoljenje Pravilo
-DocType: POS Profile,Offline POS Section,Brezplačen oddelek POS
-DocType: Sales Invoice,Terms and Conditions Details,Pogoji in Podrobnosti
-apps/erpnext/erpnext/templates/generators/item.html +100,Specifications,Tehnični podatki
-DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Prodajne Davki in dajatve predloge
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68,Total (Credit),Skupaj (Credit)
-DocType: Repayment Schedule,Payment Date,Dan plačila
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +122,New Batch Qty,Nova Serija Kol
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +122,New Batch Qty,Nova Serija Kol
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10,Apparel & Accessories,Oblačila in dodatki
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91,Could not solve weighted score function. Make sure the formula is valid.,"Funkcije uteženih rezultatov ni bilo mogoče rešiti. Prepričajte se, da formula velja."
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,Število reda
-DocType: Item Group,HTML / Banner that will show on the top of product list.,"HTML pasica, ki se bo prikazala na vrhu seznama izdelkov."
-DocType: Shipping Rule,Specify conditions to calculate shipping amount,Navedite pogoje za izračun zneska ladijskega
-DocType: Program Enrollment,Institute's Bus,Inštitutski avtobus
-DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,"Vloga dovoliti, da določijo zamrznjenih računih in uredi Zamrznjen Entries"
-DocType: Supplier Scorecard Scoring Variable,Path,Pot
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28,Cannot convert Cost Center to ledger as it has child nodes,"Ni mogoče pretvoriti v stroškovni center za knjigo, saj ima otrok vozlišč"
-DocType: Production Plan,Total Planned Qty,Skupno načrtovano število
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68,Opening Value,Otvoritev Vrednost
-DocType: Salary Detail,Formula,Formula
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47,Serial #,Serial #
-DocType: Lab Test Template,Lab Test Template,Lab Test Template
-apps/erpnext/erpnext/setup/doctype/company/company.py +181,Sales Account,Prodajni račun
-DocType: Purchase Invoice Item,Total Weight,Totalna teža
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94,Commission on Sales,Komisija za prodajo
-DocType: Job Offer Term,Value / Description,Vrednost / Opis
-apps/erpnext/erpnext/controllers/accounts_controller.py +629,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Row # {0}: Asset {1} ni mogoče predložiti, je že {2}"
-DocType: Tax Rule,Billing Country,Zaračunavanje Država
-DocType: Purchase Order Item,Expected Delivery Date,Pričakuje Dostava Datum
-DocType: Restaurant Order Entry,Restaurant Order Entry,Vnos naročila restavracij
-apps/erpnext/erpnext/accounts/general_ledger.py +132,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debetnih in kreditnih ni enaka za {0} # {1}. Razlika je {2}.
-DocType: Asset Maintenance Task,Assign To Name,Dodeli imenu
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98,Entertainment Expenses,Zabava Stroški
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +98,Make Material Request,Naredite Zahteva material
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},Odprti Točka {0}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Račun {0} je potrebno preklicati pred preklicom tega prodajnega naročila
-DocType: Consultation,Age,Starost
-DocType: Sales Invoice Timesheet,Billing Amount,Zaračunavanje Znesek
-DocType: Cash Flow Mapping,Select Maximum Of 1,Izberite največ 1
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,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."
-DocType: Company,Default Employee Advance Account,Privzeti račun zaposlenega
-apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Vloge za dopust.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +164,Account with existing transaction can not be deleted,Račun z obstoječim poslom ni mogoče izbrisati
-DocType: Vehicle,Last Carbon Check,Zadnja Carbon Check
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Legal Expenses,Pravni stroški
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140,Please select quantity on row ,Izberite količino na vrsti
-apps/erpnext/erpnext/config/accounts.py +277,Make Opening Sales and Purchase Invoices,Izdelava računov za prodajo in nakup
-DocType: Purchase Invoice,Posting Time,Ura vnosa
-DocType: Timesheet,% Amount Billed,% Zaračunani znesek
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +130,"""Time Per Appointment"" hasn""t been set for Dr {0}. Add it in Physician master.","""Čas na sestanek"" ni bil nastavljen za Dr. {0}. Dodajte ga v Upravnik zdravnikov."
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,Telephone Expenses,Telefonske Stroški
-DocType: Sales Partner,Logo,Logo
-DocType: Naming Series,Check this if you want to force the user to select a series before saving. There will be no default if you check this.,"Označite to, če želite, da prisili uporabnika, da izberete vrsto pred shranjevanjem. Tam ne bo privzeto, če to preverite."
-apps/erpnext/erpnext/stock/get_item_details.py +131,No Item with Serial No {0},Ne Postavka s serijsko št {0}
-DocType: Email Digest,Open Notifications,Odprte Obvestila
-DocType: Payment Entry,Difference Amount (Company Currency),Razlika Znesek (družba Valuta)
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79,Direct Expenses,Neposredni stroški
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,New Customer Prihodki
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119,Travel Expenses,Potni stroški
-DocType: Maintenance Visit,Breakdown,Zlomiti se
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50,Add custom field Subscription in the doctype {0},Dodajanje po meri naročenega polja v doctype {0}
-apps/erpnext/erpnext/controllers/accounts_controller.py +813,Account: {0} with currency: {1} can not be selected,Račun: {0} z valuti: ne more biti izbran {1}
-DocType: Purchase Receipt Item,Sample Quantity,Količina vzorca
-DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.",Na podlagi najnovejšega razmerja cene / cene cenika / zadnje stopnje nakupa surovin samodejno posodobite stroške BOM prek načrtovalca.
-DocType: Bank Reconciliation Detail,Cheque Date,Ček Datum
-apps/erpnext/erpnext/accounts/doctype/account/account.py +50,Account {0}: Parent account {1} does not belong to company: {2},Račun {0}: Matični račun {1} ne pripada podjetju: {2}
-apps/erpnext/erpnext/setup/doctype/company/company.js +106,Successfully deleted all transactions related to this company!,Uspešno izbrisana vse transakcije v zvezi s to družbo!
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +21,As on Date,Kot na datum
-DocType: Appraisal,HR,Človeški viri
-DocType: Program Enrollment,Enrollment Date,Datum včlanitve
-DocType: Healthcare Settings,Out Patient SMS Alerts,Out Patient SMS Opozorila
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100,Probation,Poskusno delo
-apps/erpnext/erpnext/config/hr.py +115,Salary Components,komponente plače
-DocType: Program Enrollment Tool,New Academic Year,Novo študijsko leto
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +811,Return / Credit Note,Nazaj / dobropis
-DocType: Stock Settings,Auto insert Price List rate if missing,Auto insert stopnja Cenik če manjka
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +112,Total Paid Amount,Skupaj Plačan znesek
-DocType: GST Settings,B2C Limit,Omejitev B2C
-DocType: Production Order Item,Transferred Qty,Prenese Kol
-apps/erpnext/erpnext/config/learn.py +11,Navigating,Krmarjenje
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188,Planning,Načrtovanje
-DocType: Share Balance,Issued,Izdala
-apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14,Student Activity,študent dejavnost
-apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80,Supplier Id,Dobavitelj Id
-DocType: Payment Request,Payment Gateway Details,Plačilo Gateway Podrobnosti
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +277,Quantity should be greater than 0,Količina mora biti večja od 0
-DocType: Journal Entry,Cash Entry,Cash Začetek
-DocType: Production Plan,Get Items For Production Order,Pridobite elemente za proizvodni naročilo
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,Child nodes can be only created under 'Group' type nodes,Otroški vozlišča lahko ustvari samo na podlagi tipa vozlišča &quot;skupina&quot;
-DocType: Leave Application,Half Day Date,Poldnevni datum
-DocType: Academic Year,Academic Year Name,Ime študijsko leto
-DocType: Sales Partner,Contact Desc,Kontakt opis izdelka
-apps/erpnext/erpnext/config/hr.py +65,"Type of leaves like casual, sick etc.","Vrsta listov kot priložnostno, bolni itd"
-DocType: Email Digest,Send regular summary reports via Email.,Pošlji redna zbirna poročila preko e-maila.
-DocType: Payment Entry,PE-,PE-
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +280,Please set default account in Expense Claim Type {0},"Prosim, nastavite privzetega računa v Tip Expense Terjatve {0}"
-DocType: Assessment Result,Student Name,Student Ime
-DocType: Brand,Item Manager,Element Manager
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Payroll Payable,Plače plačljivo
-DocType: Buying Settings,Default Supplier Type,Privzeta Dobavitelj Type
-DocType: Plant Analysis,Collection Datetime,Zbirka Datetime
-DocType: Production Order,Total Operating Cost,Skupni operativni stroški
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171,Note: Item {0} entered multiple times,Opomba: Točka {0} vpisana večkrat
-apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Vsi stiki.
-apps/erpnext/erpnext/public/js/setup_wizard.js +71,Company Abbreviation,Kratica podjetja
-apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +57,User {0} does not exist,Uporabnik {0} ne obstaja
-DocType: Payment Term,Day(s) after invoice date,Dan (dan) po datumu računa
-DocType: Payment Schedule,Payment Schedule,Urnik plačila
-DocType: Subscription,SUB-,SUB-
-DocType: Item Attribute Value,Abbreviation,Kratica
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +182,Payment Entry already exists,Plačilo vnos že obstaja
-apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,"Ne authroized saj je {0}, presega meje"
-apps/erpnext/erpnext/config/hr.py +110,Salary template master.,Plača predlogo gospodar.
-apps/erpnext/erpnext/healthcare/setup.py +241,Pathology,Patologija
-DocType: Restaurant Order Entry,Restaurant Table,Restavracija Tabela
-DocType: Hotel Room,Hotel Manager,Hotel Manager
-DocType: Leave Type,Max Days Leave Allowed,Max dni dopusta Dovoljeno
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63,Set Tax Rule for shopping cart,Nastavite Davčna pravilo za nakupovalno košarico
-DocType: Purchase Invoice,Taxes and Charges Added,Davki in dajatve Dodano
-,Sales Funnel,Prodaja toka
-apps/erpnext/erpnext/setup/doctype/company/company.py +49,Abbreviation is mandatory,Kratica je obvezna
-DocType: Project,Task Progress,naloga Progress
-apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7,Cart,Košarica
-,Qty to Transfer,Količina Prenos
-apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,Ponudbe za interesente ali stranke.
-DocType: Stock Settings,Role Allowed to edit frozen stock,Vloga Dovoljeno urediti zamrznjeno zalog
-,Territory Target Variance Item Group-Wise,Ozemlje Ciljna Varianca Postavka Group-Wise
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,All Customer Groups,Vse skupine strank
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114,Accumulated Monthly,Bilančni Mesečni
-apps/erpnext/erpnext/controllers/accounts_controller.py +774,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je obvezen. Mogoče zapis Menjalnega tečaja ni ustvarjen za {1} v {2}.
-apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +43,Tax Template is mandatory.,Davčna Predloga je obvezna.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +44,Account {0}: Parent account {1} does not exist,Račun {0}: Matični račun {1} ne obstaja
-DocType: Purchase Invoice Item,Price List Rate (Company Currency),Cenik Rate (družba Valuta)
-DocType: Products Settings,Products Settings,Nastavitve izdelki
-,Item Price Stock,Cena artikla
-DocType: Lab Prescription,Test Created,Ustvarjeno testiranje
-DocType: Healthcare Settings,Custom Signature in Print,Podpis po meri v tisku
-DocType: Account,Temporary,Začasna
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +102,Customer LPO No.,Stranka LPO št.
-DocType: Program,Courses,Tečaji
-DocType: Monthly Distribution Percentage,Percentage Allocation,Odstotek dodelitve
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128,Secretary,Sekretar
-DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Če onemogočiti, &quot;z besedami&quot; polja ne bo vidna v vsakem poslu"
-DocType: Serial No,Distinct unit of an Item,Ločena enota Postavka
-DocType: Supplier Scorecard Criteria,Criteria Name,Ime merila
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1295,Please set Company,Nastavite Company
-DocType: Pricing Rule,Buying,Nabava
-apps/erpnext/erpnext/config/agriculture.py +24,Diseases & Fertilizers,Bolezni in gnojila
-DocType: HR Settings,Employee Records to be created by,"Zapisi zaposlenih, ki ga povzročajo"
-DocType: Patient,AB Negative,AB Negativno
-DocType: Sample Collection,SMPL-,SMPL-
-DocType: POS Profile,Apply Discount On,Uporabi popust na
-DocType: Member,Membership Type,Vrsta članstva
-,Reqd By Date,Reqd po Datum
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140,Creditors,Upniki
-DocType: Assessment Plan,Assessment Name,Ime ocena
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +88,Show PDC in Print,Prikažite PDC v tisku
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +96,Row # {0}: Serial No is mandatory,Vrstica # {0}: Zaporedna številka je obvezna
-DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Postavka Wise Davčna Detail
-apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,Job Offer,Zaposlitvena ponudba
-apps/erpnext/erpnext/public/js/setup_wizard.js +71,Institute Abbreviation,Kratica inštituta
-,Item-wise Price List Rate,Element-pametno Cenik Rate
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1073,Supplier Quotation,Dobavitelj za predračun
-DocType: Quotation,In Words will be visible once you save the Quotation.,"V besedi bo viden, ko boste prihranili citata."
-apps/erpnext/erpnext/utilities/transaction_base.py +160,Quantity ({0}) cannot be a fraction in row {1},Količina ({0}) ne more biti komponenta v vrstici {1}
-apps/erpnext/erpnext/utilities/transaction_base.py +160,Quantity ({0}) cannot be a fraction in row {1},Količina ({0}) ne more biti komponenta v vrstici {1}
-DocType: Consultation,C-,C-
-DocType: Attendance,ATT-,ATT-
-apps/erpnext/erpnext/stock/doctype/item/item.py +491,Barcode {0} already used in Item {1},Barcode {0} že uporabljajo v postavki {1}
-apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Pravila za dodajanje stroškov dostave.
-DocType: Hotel Room,Extra Bed Capacity,Zmogljivost dodatnega ležišča
-DocType: Item,Opening Stock,Začetna zaloga
-apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Je potrebno kupca
-DocType: Lab Test,Result Date,Datum oddaje
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +77,PDC/LC Date,PDC / LC Datum
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,{0} je obvezen za povračilo
-DocType: Purchase Order,To Receive,Prejeti
-apps/erpnext/erpnext/utilities/user_progress.py +249,user@example.com,user@example.com
-DocType: Asset,Asset Owner,Lastnik sredstev
-DocType: Employee,Personal Email,Osebna Email
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57,Total Variance,Skupne variance
-DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Če je omogočeno, bo sistem objavili računovodske vnose za popis samodejno."
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15,Brokerage,Posredništvo
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +196,Attendance for employee {0} is already marked for this day,Udeležba na zaposlenega {0} je že označen za ta dan
-DocType: Production Order Operation,"in Minutes
-Updated via 'Time Log'",v minutah Posodobljeno preko &quot;Čas Logu&quot;
-DocType: Customer,From Lead,Iz ponudbe
-apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Naročila sprosti za proizvodnjo.
-apps/erpnext/erpnext/public/js/account_tree_grid.js +66,Select Fiscal Year...,Izberite poslovno leto ...
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +567,POS Profile required to make POS Entry,"POS Profil zahteva, da POS Entry"
-DocType: Program Enrollment Tool,Enroll Students,včlanite Študenti
-DocType: Lab Test,Approved Date,Odobren datum
-apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Standardna Prodaja
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +152,Atleast one warehouse is mandatory,Atleast eno skladišče je obvezna
-DocType: Serial No,Out of Warranty,Iz garancije
-DocType: BOM Update Tool,Replace,Zamenjaj
-apps/erpnext/erpnext/templates/includes/product_list.js +42,No products found.,Ni izdelkov.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360,{0} against Sales Invoice {1},{0} za Račun {1}
-DocType: Antibiotic,Laboratory User,Laboratorijski uporabnik
-DocType: Sales Invoice,SINV-,SINV-
-DocType: Request for Quotation Item,Project Name,Ime projekta
-DocType: Customer,Mention if non-standard receivable account,Omemba če nestandardno terjatve račun
-DocType: Journal Entry Account,If Income or Expense,Če prihodek ali odhodek
-DocType: Production Order,Required Items,Zahtevani Točke
-DocType: Stock Ledger Entry,Stock Value Difference,Stock Value Razlika
-apps/erpnext/erpnext/config/learn.py +229,Human Resource,Človeški vir
-DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Plačilo Sprava Plačilo
-DocType: Disease,Treatment Task,Naloga zdravljenja
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38,Tax Assets,Davčni Sredstva
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +653,Production Order has been {0},Proizvodnja naročilo je {0}
-DocType: BOM Item,BOM No,BOM Ne
-DocType: Instructor,INS/,INS /
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +160,Journal Entry {0} does not have account {1} or already matched against other voucher,Journal Entry {0} nima računa {1} ali že primerjali z drugimi kupon
-DocType: Item,Moving Average,Moving Average
-DocType: BOM Update Tool,The BOM which will be replaced,BOM ki bo nadomestila
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46,Electronic Equipments,elektronske naprave
-DocType: Asset,Maintenance Required,Potrebno vzdrževanje
-DocType: Account,Debit,Debet
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49,Leaves must be allocated in multiples of 0.5,Listi morajo biti dodeljen v večkratnikih 0.5
-DocType: Production Order,Operation Cost,Delovanje Stroški
-apps/erpnext/erpnext/config/hr.py +29,Upload attendance from a .csv file,Naloži udeležbo iz .csv datoteke
-apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45,Outstanding Amt,Izjemna Amt
-DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Določiti cilje Postavka Group-pametno za te prodaje oseba.
-DocType: Stock Settings,Freeze Stocks Older Than [Days],Freeze Zaloge Older Than [dni]
-apps/erpnext/erpnext/controllers/accounts_controller.py +599,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Row # {0}: Sredstvo je obvezna za osnovno sredstvo nakupu / prodaji
-DocType: Asset Maintenance Team,Maintenance Team Name,Ime ekipe za vzdrževanje
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42,"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 dva ali več Cenik Pravilnik ugotovila na podlagi zgoraj navedenih pogojev, se uporablja Prioriteta. Prednostno je število med 0 do 20, medtem ko privzeta vrednost nič (prazno). Višja številka pomeni, da bo prednost, če obstaja več cenovnih Pravila z enakimi pogoji."
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +197,Customer is mandatory if 'Opportunity From' is selected as Customer,"Stranka je obvezna, če je »Možnost od« izbrana kot naročnik"
-apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Poslovno leto: {0} ne obstaja
-DocType: Currency Exchange,To Currency,Valutnemu
-DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,"Pustimo, da se naslednji uporabniki za odobritev dopusta Aplikacije za blok dni."
-apps/erpnext/erpnext/config/hr.py +137,Types of Expense Claim.,Vrste Expense zahtevka.
-apps/erpnext/erpnext/controllers/selling_controller.py +147,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},stopnjo za zapisu Prodajni {0} nižja kot njegovi {1}. Prodajni manj morajo vsebovati vsaj {2}
-apps/erpnext/erpnext/controllers/selling_controller.py +147,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},stopnjo za zapisu Prodajni {0} nižja kot njegovi {1}. Prodajni manj morajo vsebovati vsaj {2}
-DocType: Item,Taxes,Davki
-DocType: Purchase Invoice,capital goods,investicijsko blago
-DocType: Purchase Invoice Item,Weight Per Unit,Teža na enoto
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344,Paid and Not Delivered,Plačana in ni podal
-DocType: Project,Default Cost Center,Privzet Stroškovni Center
-DocType: Bank Guarantee,End Date,Končni datum
-apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Zaloga Transakcije
-DocType: Budget,Budget Accounts,Proračun računi
-DocType: Employee,Internal Work History,Notranji Delo Zgodovina
-DocType: Depreciation Schedule,Accumulated Depreciation Amount,Bilančni Amortizacija Znesek
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42,Private Equity,Private Equity
-DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Spremenljivka Scorecard spremenljivke
-DocType: Employee Loan,Fully Disbursed,celoti izplačano
-DocType: Maintenance Visit,Customer Feedback,Customer Feedback
-DocType: Account,Expense,Expense
-apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +54,Score cannot be greater than Maximum Score,Rezultat ne sme biti večja od najvišjo oceno
-apps/erpnext/erpnext/utilities/user_progress.py +126,Customers and Suppliers,Kupci in dobavitelji
-DocType: Item Attribute,From Range,Od Območje
-DocType: BOM,Set rate of sub-assembly item based on BOM,Nastavite količino predmeta sestavljanja na podlagi BOM
-DocType: Hotel Room Reservation,Invoiced,Fakturirani
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98,Syntax error in formula or condition: {0},Skladenjska napaka v formuli ali stanje: {0}
-DocType: Daily Work Summary Settings Company,Daily Work Summary Settings Company,Daily Delo Povzetek Nastavitve Company
-apps/erpnext/erpnext/stock/utils.py +125,Item {0} ignored since it is not a stock item,"Postavka {0} prezrta, ker ne gre za element parka"
-DocType: Appraisal,APRSL,APRSL
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +109,Submit this Production Order for further processing.,Predloži ta proizvodnja red za nadaljnjo predelavo.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Da ne uporabljajo Cenovno pravilo v posameznem poslu, bi morali vsi, ki se uporabljajo pravila za oblikovanje cen so onemogočeni."
-DocType: Payment Term,Day(s) after the end of the invoice month,Dan (e) po koncu računa na mesec
-DocType: Assessment Group,Parent Assessment Group,Skupina Ocena Parent
-apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27,Jobs,Jobs
-,Sales Order Trends,Sales Order Trendi
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,The 'From Package No.' field must neither be empty nor it's value less than 1.,&quot;Od paketa št.&quot; polje ne sme biti prazno niti je vrednost manjša od 1.
-DocType: Employee,Held On,Datum
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +36,Production Item,Proizvodnja Postavka
-,Employee Information,Informacije zaposleni
-DocType: Stock Entry Detail,Additional Cost,Dodatne Stroški
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +48,"Can not filter based on Voucher No, if grouped by Voucher","Filter ne more temeljiti na kupona št, če je združena s Voucher"
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +918,Make Supplier Quotation,Naredite Dobavitelj predračun
-DocType: Quality Inspection,Incoming,Dohodni
-apps/erpnext/erpnext/setup/doctype/company/company.js +70,Default tax templates for sales and purchase are created.,Ustvari so privzete davčne predloge za prodajo in nakup.
-apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +57,Assessment Result record {0} already exists.,Ocenjevanje Rezultat zapisa {0} že obstaja.
-DocType: BOM,Materials Required (Exploded),Potreben materiali (eksplodirala)
-apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60,Please set Company filter blank if Group By is 'Company',"Nastavite Podjetje filtriranje prazno, če skupina Z je &quot;Podjetje&quot;"
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66,Posting Date cannot be future date,Napotitev datum ne more biti prihodnji datum
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +101,Row # {0}: Serial No {1} does not match with {2} {3},Vrstica # {0}: Serijska št {1} ne ujema z {2} {3}
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,for generating the recurring,za generiranje ponavljajočih se
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86,Casual Leave,Casual Zapusti
-DocType: Agriculture Task,End Day,Konec dneva
-DocType: Batch,Batch ID,Serija ID
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380,Note: {0},Opomba: {0}
-,Delivery Note Trends,Dobavnica Trendi
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112,This Week's Summary,Povzetek Ta teden je
-apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22,In Stock Qty,Na zalogi Količina
-DocType: Delivery Trip,Calculate Estimated Arrival Times,Izračunajte predvideni čas prihoda
-apps/erpnext/erpnext/accounts/general_ledger.py +111,Account: {0} can only be updated via Stock Transactions,Račun: {0} se lahko posodobi samo preko delniških poslov
-DocType: Student Group Creation Tool,Get Courses,Get Tečaji
-DocType: GL Entry,Party,Zabava
-DocType: Healthcare Settings,Patient Name,Ime bolnika
-DocType: Variant Field,Variant Field,Različno polje
-DocType: Sales Order,Delivery Date,Datum dostave
-DocType: Opportunity,Opportunity Date,Priložnost Datum
-DocType: Purchase Receipt,Return Against Purchase Receipt,Vrni Proti Potrdilo o nakupu
-DocType: Water Analysis,Person Responsible,Odgovorna oseba
-DocType: Request for Quotation Item,Request for Quotation Item,Zahteva za ponudbo točki
-DocType: Purchase Order,To Bill,Billu
-DocType: Material Request,% Ordered,% Naročeno
-DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.","Za Študentske skupine temelji igrišče, bo tečaj se potrdi za vsakega študenta od vpisanih Tečaji v programu vpis."
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103,Piecework,Akord
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Avg. Buying Rate,Avg. Odkup tečaj
-DocType: Share Balance,From No,Od št
-DocType: Task,Actual Time (in Hours),Dejanski čas (v urah)
-DocType: Employee,History In Company,Zgodovina v družbi
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +270,New Message from {sender},Novo sporočilo od {pošiljatelja}
-DocType: Customer,Customer Primary Address,Primarni naslov stranke
-apps/erpnext/erpnext/config/learn.py +107,Newsletters,Glasila
-DocType: Drug Prescription,Description/Strength,Opis / moč
-DocType: Share Balance,Is Company,Je podjetje
-DocType: Stock Ledger Entry,Stock Ledger Entry,Stock Ledger Entry
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83,Same item has been entered multiple times,Enako postavka je bila vpisana večkrat
-DocType: Department,Leave Block List,Pustite Block List
-DocType: Purchase Invoice,Tax ID,Davčna številka
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192,Item {0} is not setup for Serial Nos. Column must be blank,Postavka {0} ni setup za Serijska št. Kolona mora biti prazno
-DocType: Accounts Settings,Accounts Settings,Računi Nastavitve
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11,Approve,odobri
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +69,"Malformatted address for {0}, please fix to continue.","Malformatiran naslov za {0}, popravite, da nadaljujete."
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28,"Number of new Account, it will be included in the account name as a prefix",Številka novega računa bo vključena v ime računa kot predpono
-DocType: Maintenance Team Member,Team Member,Član ekipe
-apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151,No Result to submit,Ni zadetka
-DocType: Customer,Sales Partner and Commission,Prodaja Partner in Komisija
-DocType: Employee Loan,Rate of Interest (%) / Year,Obrestna mera (%) / leto
-,Project Quantity,projekt Količina
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Skupno {0} za vse postavke je nič, morda bi morali spremeniti &quot;Razdeli stroškov na osnovi&quot;"
-DocType: Opportunity,To Discuss,Razpravljati
-apps/erpnext/erpnext/stock/stock_ledger.py +377,{0} units of {1} needed in {2} to complete this transaction.,{0} enot {1} potrebnih v {2} za dokončanje te transakcije.
-DocType: Loan Type,Rate of Interest (%) Yearly,Obrestna mera (%) Letna
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71,Temporary Accounts,Začasni računi
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207,Black,Črna
-DocType: BOM Explosion Item,BOM Explosion Item,BOM Eksplozija Postavka
-DocType: Shareholder,Contact List,Seznam kontaktov
-DocType: Account,Auditor,Revizor
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +132,{0} items produced,{0} postavke proizvedene
-apps/erpnext/erpnext/utilities/user_progress.py +55,Learn More,Nauči se več
-DocType: Cheque Print Template,Distance from top edge,Oddaljenost od zgornjega roba
-apps/erpnext/erpnext/stock/get_item_details.py +367,Price List {0} is disabled or does not exist,Cenik {0} je onemogočena ali pa ne obstaja
-DocType: Purchase Invoice,Return,Return
-DocType: Production Order Operation,Production Order Operation,Proizvodnja naročite Delovanje
-DocType: Pricing Rule,Disable,Onemogoči
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +178,Mode of payment is required to make a payment,"Način plačila je potrebno, da bi plačilo"
-DocType: Project Task,Pending Review,Dokler Pregled
-apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14,"Edit in full page for more options like assets, serial nos, batches etc.","Uredite na celotni strani za več možnosti, kot so sredstva, serijski nosi, serije itd."
-apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10,Appointments and Consultations,Imenovanja in posvetovanja
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} ni vpisan v serijo {2}
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113,"Asset {0} cannot be scrapped, as it is already {1}","Sredstvo {0} ne more biti izločeni, saj je že {1}"
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +72,Cheques Required,Potrebna je preverjanja
-DocType: Task,Total Expense Claim (via Expense Claim),Total Expense zahtevek (preko Expense zahtevka)
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,Mark Odsoten
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40,Failed to setup company,Podjetje za nastavitev ni uspelo
-DocType: Asset Repair,Asset Repair,Popravilo sredstev
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +142,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: Journal Entry Account,Exchange Rate,Menjalni tečaj
-DocType: Patient,Additional information regarding the patient,Dodatne informacije o bolniku
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +585,Sales Order {0} is not submitted,Naročilo {0} ni predloženo
-DocType: Homepage,Tag Line,tag Line
-DocType: Fee Component,Fee Component,Fee Component
-apps/erpnext/erpnext/config/hr.py +204,Fleet Management,Fleet management
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1071,Add items from,Dodaj artikle iz
-apps/erpnext/erpnext/config/agriculture.py +7,Crops & Lands,Rastline in zemljišča
-DocType: Cheque Print Template,Regular,redno
-DocType: Fertilizer,Density (if liquid),Gostota (če je tekoča)
-apps/erpnext/erpnext/education/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Skupaj weightage vseh ocenjevalnih meril mora biti 100%
-DocType: Purchase Order Item,Last Purchase Rate,Zadnja Purchase Rate
-DocType: Account,Asset,Asset
-DocType: Project Task,Task ID,Naloga ID
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84,Stock cannot exist for Item {0} since has variants,"Stock ne more obstajati za postavko {0}, saj ima variant"
-DocType: Lab Test,Mobile,Mobile
-,Sales Person-wise Transaction Summary,Prodaja Oseba pametno Transakcijski Povzetek
-DocType: Training Event,Contact Number,Kontaktna številka
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0} does not exist,Skladišče {0} ne obstaja
-DocType: Monthly Distribution,Monthly Distribution Percentages,Mesečni Distribucijski Odstotki
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +110,The selected item cannot have Batch,Izbrana postavka ne more imeti Batch
-DocType: Delivery Note,% of materials delivered against this Delivery Note,% materiala dobavljeno po tej dobavnici
-DocType: Asset Maintenance Log,Has Certificate,Ima certifikat
-DocType: Project,Customer Details,Podrobnosti strank
-DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,"Preverite, ali sredstva potrebujejo preventivno vzdrževanje ali kalibracijo"
-apps/erpnext/erpnext/public/js/setup_wizard.js +87,Company Abbreviation cannot have more than 5 characters,Kratica podjetja ne sme imeti več kot 5 znakov
-DocType: Employee,Reports to,Poročila
-,Unpaid Expense Claim,Neplačana Expense zahtevek
-DocType: Payment Entry,Paid Amount,Znesek Plačila
-apps/erpnext/erpnext/utilities/user_progress.py +155,Explore Sales Cycle,Raziščite prodajne cikle
-DocType: Assessment Plan,Supervisor,nadzornik
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +869,Retention Stock Entry,Vstop v zaloge
-,Available Stock for Packing Items,Zaloga za embalirane izdelke
-DocType: Item Variant,Item Variant,Postavka Variant
-DocType: Assessment Result Tool,Assessment Result Tool,Ocena Rezultat orodje
-apps/erpnext/erpnext/education/doctype/instructor/instructor.js +24,As Supervisor,Kot nadzornik
-DocType: BOM Scrap Item,BOM Scrap Item,BOM Odpadno Item
-apps/erpnext/erpnext/accounts/page/pos/pos.js +895,Submitted orders can not be deleted,Predložene naročila ni mogoče izbrisati
-apps/erpnext/erpnext/accounts/doctype/account/account.py +114,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Stanje na računu je že ""bremenitev"", ni dovoljeno nastaviti ""Stanje mora biti"" kot ""kredit"""
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118,Quality Management,Upravljanje kakovosti
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +41,Item {0} has been disabled,Točka {0} je bila onemogočena
-DocType: Project,Total Billable Amount (via Timesheets),Skupni znesek zneska (prek časopisov)
-DocType: Agriculture Task,Previous Business Day,Prejšnji delovni dan
-DocType: Employee Loan,Repay Fixed Amount per Period,Povrne fiksni znesek na obdobje
-apps/erpnext/erpnext/buying/utils.py +47,Please enter quantity for Item {0},Vnesite količino za postavko {0}
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +210,Credit Note Amt,Credit Opomba Amt
-DocType: Employee External Work History,Employee External Work History,Delavec Zunanji Delo Zgodovina
-DocType: Opening Invoice Creation Tool,Purchase,Nakup
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Balance Kol
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,Cilji ne morejo biti prazna
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +15,Enrolling students,Vpis študentov
-DocType: Item Group,Parent Item Group,Parent Item Group
-DocType: Appointment Type,Appointment Type,Vrsta imenovanja
-apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} za {1}
-DocType: Healthcare Settings,Valid number of days,Veljavno število dni
-apps/erpnext/erpnext/setup/doctype/company/company.js +39,Cost Centers,Stroškovna mesta
-DocType: Land Unit,Linked Plant Analysis,Analiza povezanih naprav
-DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,"Obrestna mera, po kateri dobavitelj je valuti, se pretvori v osnovni valuti družbe"
-apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Vrstica # {0}: čase v nasprotju z vrsto {1}
-DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Dovoli ničelni stopnji vrednotenja
-DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Dovoli ničelni stopnji vrednotenja
-DocType: Training Event Employee,Invited,povabljen
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +177,Multiple active Salary Structures found for employee {0} for the given dates,Več aktivne strukture plač iskanja za zaposlenega {0} za datumoma
-apps/erpnext/erpnext/config/accounts.py +308,Setup Gateway accounts.,Gateway račune.
-DocType: Employee,Employment Type,Vrsta zaposlovanje
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42,Fixed Assets,Osnovna sredstva
-DocType: Payment Entry,Set Exchange Gain / Loss,Set Exchange dobiček / izguba
-,GST Purchase Register,DDV Nakup Registracija
-,Cash Flow,Denarni tok
-apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25,Combined invoice portion must equal 100%,Kombinirani del na računu mora biti enak 100%
-DocType: Item Group,Default Expense Account,Privzeto Expense račun
-DocType: GST Account,CGST Account,Račun CGST
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,Študent Email ID
-DocType: Employee,Notice (days),Obvestilo (dni)
-DocType: Tax Rule,Sales Tax Template,Sales Tax Predloga
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2494,Select items to save the invoice,"Izberite predmete, da shranite račun"
-DocType: Employee,Encashment Date,Vnovčevanje Datum
-DocType: Training Event,Internet,internet
-DocType: Special Test Template,Special Test Template,Posebna preskusna predloga
-DocType: Account,Stock Adjustment,Prilagoditev zaloge
-apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34,Default Activity Cost exists for Activity Type - {0},Obstaja Stroški Privzeta aktivnost za vrsto dejavnosti - {0}
-DocType: Production Order,Planned Operating Cost,Načrtovana operacijski stroškov
-DocType: Academic Term,Term Start Date,Izraz Datum začetka
-apps/erpnext/erpnext/config/accounts.py +471,List of all share transactions,Seznam vseh deležev transakcij
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opp Štetje
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opp Štetje
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +244,Please find attached {0} #{1},V prilogi vam pošiljamo {0} # {1}
-apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52,Average Rate,Povprečna hitrost
-apps/erpnext/erpnext/controllers/accounts_controller.py +721,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Skupni znesek plačila v urniku plačil mora biti enak znesku zaokroženo / zaokroženo
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Banka Izjava ravnotežje kot na glavno knjigo
-DocType: Job Applicant,Applicant Name,Predlagatelj Ime
-DocType: Authorization Rule,Customer / Item Name,Stranka / Item Name
-DocType: Buying Settings,"If enabled, last purchase details of items will not be fetched from previous purchase order or purchase receipt","Če je omogočeno, zadnji podatki o nakupu predmetov ne bodo pridobljeni iz prejšnjega naročila ali potrdila o nakupu"
-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","Agregat skupina ** Items ** v drugo ** postavki **. To je uporabno, če ste združevanje neka ** Items ** v paketu in jo vzdrževati zalogo pakiranih ** Items ** in ne agregat ** item **. Paket ** Item ** bodo imeli &quot;Je Stock Postavka&quot; kot &quot;ne&quot; in &quot;Je Sales Item&quot;, kot je &quot;Yes&quot;. Na primer: Če prodajate Prenosniki in nahrbtniki ločeno in imajo posebno ceno, če kupec kupi tako, potem bo Laptop + nahrbtnik nov Bundle Izdelek točka. Opomba: BOM = Bill of Materials"
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42,Serial No is mandatory for Item {0},Zaporedna številka je obvezna za postavko {0}
-DocType: Item Variant Attribute,Attribute,Lastnost
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43,Please specify from/to range,"Prosimo, navedite iz / v razponu"
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28,Opening {0} Invoice created,Odpiranje {0} Ustvarjen račun
-DocType: Serial No,Under AMC,Pod AMC
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55,Item valuation rate is recalculated considering landed cost voucher amount,Stopnja vrednotenje sredstev se preračuna razmišlja pristali stroškovno vrednost kupona
-apps/erpnext/erpnext/config/selling.py +153,Default settings for selling transactions.,Privzete nastavitve za prodajne transakcije.
-DocType: Guardian,Guardian Of ,Guardian Of
-DocType: Grading Scale Interval,Threshold,prag
-DocType: BOM Update Tool,Current BOM,Trenutni BOM
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +25,Balance (Dr - Cr),Ravnotežje (Dr - Cr)
-apps/erpnext/erpnext/public/js/utils.js +55,Add Serial No,Dodaj Serijska št
-DocType: Production Order Item,Available Qty at Source Warehouse,Na voljo Količina na Vir Warehouse
-apps/erpnext/erpnext/config/support.py +22,Warranty,garancija
-DocType: Purchase Invoice,Debit Note Issued,Opomin Izdano
-DocType: Production Order,Warehouses,Skladišča
-apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} sredstev ni mogoče prenesti
-DocType: Hotel Room Pricing,Hotel Room Pricing,Cene hotelske sobe
-apps/erpnext/erpnext/stock/doctype/item/item.js +80,This Item is a Variant of {0} (Template).,Ta element je različica {0} (predloga).
-DocType: Workstation,per hour,na uro
-apps/erpnext/erpnext/config/buying.py +7,Purchasing,Purchasing
-DocType: Announcement,Announcement,Obvestilo
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +84,Customer LPO,Stranka LPO
-DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",Za Študentske skupine temelji Serija bo študent Serija biti potrjena za vse učence od programa vpis.
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +51,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Skladišče ni mogoče črtati, saj obstaja vnos stock knjiga za to skladišče."
-apps/erpnext/erpnext/public/js/setup_wizard.js +25,Distribution,Porazdelitev
-DocType: Expense Claim Advance,Expense Claim Advance,Advance Claim Advance
-DocType: Lab Test,Report Preference,Prednost poročila
-apps/erpnext/erpnext/config/non_profit.py +43,Volunteer information.,Informacije o prostovoljcih.
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133,Project Manager,Project Manager
-,Quoted Item Comparison,Citirano Točka Primerjava
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34,Overlap in scoring between {0} and {1},Prekrivanje v dosegu med {0} in {1}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114,Dispatch,Dispatch
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +74,Max discount allowed for item: {0} is {1}%,Max popust dovoljena za postavko: {0} je {1}%
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176,Net Asset value as on,"Čista vrednost sredstev, kot je na"
-DocType: Crop,Produce,Produkt
-DocType: Hotel Settings,Default Taxes and Charges,Privzete Davki in dajatve
-DocType: Account,Receivable,Terjatev
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Vrstica # {0}: ni dovoljeno spreminjati Dobavitelj kot Naročilo že obstaja
-DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,"Vloga, ki jo je dovoljeno vložiti transakcije, ki presegajo omejitve posojil zastavili."
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +980,Select Items to Manufacture,Izberite artikel v Izdelava
-DocType: Delivery Stop,Delivery Stop,Dostava Stop
-apps/erpnext/erpnext/accounts/page/pos/pos.js +963,"Master data syncing, it might take some time","Master podatkov sinhronizacijo, lahko traja nekaj časa"
-DocType: Item,Material Issue,Material Issue
-DocType: Employee Education,Qualification,Kvalifikacije
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +42,View Salary Slips,Oglejte si članke o plačah
-DocType: Item Price,Item Price,Item Cena
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48,Soap & Detergent,Soap &amp; Detergent
-DocType: BOM,Show Items,prikaži Točke
-apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,Od časa ne sme biti večja od do časa.
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +92,Do you want to notify all the customers by email?,Ali želite obvestiti vse stranke po elektronski pošti?
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36,Motion Picture & Video,Motion Picture &amp; Video
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Naročeno
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51,Resume,Nadaljuj
-DocType: Salary Detail,Component,Komponenta
-DocType: Assessment Criteria,Assessment Criteria Group,Skupina Merila ocenjevanja
-DocType: Healthcare Settings,Patient Name By,Ime bolnika z
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +72,Opening Accumulated Depreciation must be less than equal to {0},Odpiranje nabrano amortizacijo sme biti manjša od enako {0}
-DocType: Warehouse,Warehouse Name,Skladišče Name
-DocType: Naming Series,Select Transaction,Izberite Transaction
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,Vnesite Odobritev vloge ali Potrditev uporabnika
-DocType: Journal Entry,Write Off Entry,Napišite Off Entry
-DocType: BOM,Rate Of Materials Based On,Oceni materialov na osnovi
-apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Podpora Analtyics
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102,Uncheck all,Odznači vse
-DocType: POS Profile,Terms and Conditions,Pravila in pogoji
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49,To Date should be within the Fiscal Year. Assuming To Date = {0},"Do datuma mora biti v poslovnem letu. Ob predpostavki, da želite Datum = {0}"
-DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Tukaj lahko hranite višino, težo, alergije, zdravstvene pomisleke in podobno"
-DocType: Leave Block List,Applies to Company,Velja za podjetja
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +231,Cannot cancel because submitted Stock Entry {0} exists,"Ni mogoče preklicati, ker je predložila Stock Začetek {0} obstaja"
-DocType: Employee Loan,Disbursement Date,izplačilo Datum
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80,'Recipients' not specified,&quot;Prejemniki&quot; niso navedeni
-DocType: BOM Update Tool,Update latest price in all BOMs,Posodobi najnovejšo ceno v vseh BOM
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +39,Medical Record,Medicinski zapis
-DocType: Vehicle,Vehicle,vozila
-DocType: Purchase Invoice,In Words,V besedi
-apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15,{0} must be submitted,{0} je treba vložiti
-DocType: POS Profile,Item Groups,postavka Skupine
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +221,Today is {0}'s birthday!,Danes je {0} &#39;s rojstni dan!
-DocType: Sales Order Item,For Production,Za proizvodnjo
-DocType: Payment Request,payment_url,payment_url
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +186,Please add a Temporary Opening account in Chart of Accounts,"Prosimo, dodajte račun za začasno odpiranje v kontnem okvirju"
-DocType: Customer,Customer Primary Contact,Primarni kontakt s strankami
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +154,Period Closing Journal,Časovno zaključni časopis
-DocType: Project Task,View Task,Ogled Task
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,OPP / svinec%
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,OPP / svinec%
-DocType: Material Request,MREQ-,MREQ-
-DocType: Payment Schedule,Invoice Portion,Delež računa
-,Asset Depreciations and Balances,Premoženjem amortizacije in Stanja
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +363,Amount {0} {1} transferred from {2} to {3},Znesek {0} {1} je preselil iz {2} na {3}
-DocType: Sales Invoice,Get Advances Received,Get prejeti predujmi
-DocType: Email Digest,Add/Remove Recipients,Dodaj / Odstrani prejemnike
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +498,Transaction not allowed against stopped Production Order {0},Transakcija ni dovoljena zoper ustavili proizvodnjo naročite {0}
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","Če želite nastaviti to poslovno leto kot privzeto, kliknite na &quot;Set as Default&quot;"
-DocType: Production Plan,Include Subcontracted Items,Vključite predmete s podizvajalci
-apps/erpnext/erpnext/projects/doctype/project/project.py +218,Join,pridruži se
-apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21,Shortage Qty,Pomanjkanje Kol
-apps/erpnext/erpnext/stock/doctype/item/item.py +671,Cannot change Variant properties after stock transction. You will have to make a new Item to do this.,Lastnosti variant ni mogoče spremeniti po pretovarjanju zalog. Za to morate narediti novo postavko.
-apps/erpnext/erpnext/stock/doctype/item/item.py +713,Item variant {0} exists with same attributes,Obstaja postavka varianta {0} z enakimi atributi
-DocType: Employee Loan,Repay from Salary,Poplačilo iz Plača
-DocType: Leave Application,LAP/,LAP /
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +347,Requesting payment against {0} {1} for amount {2},Zahteva plačilo pred {0} {1} za znesek {2}
-DocType: Salary Slip,Salary Slip,Plača listek
-DocType: Lead,Lost Quotation,Izgubljeno Kotacija
-apps/erpnext/erpnext/utilities/user_progress.py +218,Student Batches,Študentski paketi
-DocType: Pricing Rule,Margin Rate or Amount,Razlika v stopnji ali količini
-apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48,'To Date' is required,"""Do datuma"" je obvezno polje"
-DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Ustvarjajo dobavnic, da paketi dostavi. Uporablja se za uradno številko paketa, vsebino paketa in njegovo težo."
-DocType: Sales Invoice Item,Sales Order Item,Artikel naročila
-DocType: Salary Slip,Payment Days,Plačilni dnevi
-DocType: Stock Settings,Convert Item Description to Clean HTML,Preoblikovati postavko Opis za čiščenje HTML
-DocType: Patient,Dormant,mirujočih
-DocType: Salary Slip,Total Interest Amount,Skupni znesek obresti
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +125,Warehouses with child nodes cannot be converted to ledger,Skladišča z otrok vozlišča ni mogoče pretvoriti v knjigo terjatev
-DocType: BOM,Manage cost of operations,Upravljati stroške poslovanja
-DocType: Accounts Settings,Stale Days,Stale dni
-DocType: Notification Control,"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.","Ko kateri koli od pregledanih transakcij &quot;Objavil&quot;, e-pop-up samodejno odpre, da pošljete e-pošto s pripadajočim &quot;stik&quot; v tem poslu, s poslom, kot prilogo. Uporabnik lahko ali pa ne pošljete e-pošto."
-apps/erpnext/erpnext/config/setup.py +14,Global Settings,Globalni Nastavitve
-DocType: Crop,Row Spacing UOM,Razmik vrstic UOM
-DocType: Assessment Result Detail,Assessment Result Detail,Ocena Rezultat Podrobnosti
-DocType: Employee Education,Employee Education,Izobraževanje delavec
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53,Duplicate item group found in the item group table,Dvojnik postavka skupina je našla v tabeli točka skupine
-DocType: Land Unit,Parent Land Unit,Matična enota
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1113,It is needed to fetch Item Details.,"To je potrebno, da prinese Element Podrobnosti."
-DocType: Fertilizer,Fertilizer Name,Ime gnojila
-DocType: Salary Slip,Net Pay,Neto plača
-DocType: Cash Flow Mapping Accounts,Account,Račun
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217,Serial No {0} has already been received,Serijska št {0} je že prejela
-,Requested Items To Be Transferred,Zahtevane blago prenaša
-DocType: Expense Claim,Vehicle Log,vozilo Log
-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 vročine (temp&gt; 38,5 ° C / 101,3 ° F ali trajne temp&gt; 38 ° C / 100,4 ° F)"
-DocType: Customer,Sales Team Details,Sales Team Podrobnosti
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1351,Delete permanently?,Izbriši trajno?
-DocType: Expense Claim,Total Claimed Amount,Skupaj zahtevani znesek
-apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Potencialne možnosti za prodajo.
-DocType: Shareholder,Folio no.,Folio št.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +246,Invalid {0},Neveljavna {0}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90,Sick Leave,Bolniški dopust
-DocType: Email Digest,Email Digest,Email Digest
-DocType: Delivery Note,Billing Address Name,Zaračunavanje Naslov Name
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22,Department Stores,Veleblagovnice
-,Item Delivery Date,Datum dobave artikla
-DocType: Production Plan,Material Requested,Zahtevani material
-DocType: Warehouse,PIN,PIN
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +116,Error '{0}' occured. Arguments {1}.,Prišlo je do napake &#39;{0}&#39;. Argumenti {1}.
-DocType: Bin,Reserved Qty for sub contract,Rezervirano Kol za podizvajalsko pogodbo
-DocType: Sales Invoice,Base Change Amount (Company Currency),Osnovna Sprememba Znesek (družba Valuta)
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304,No accounting entries for the following warehouses,Ni vknjižbe za naslednjih skladiščih
-apps/erpnext/erpnext/projects/doctype/project/project.js +111,Save the document first.,Shranite dokument na prvem mestu.
-apps/erpnext/erpnext/shopping_cart/cart.py +74,Only {0} in stock for item {1},Samo za {0} na zalogi za predmet {1}
-DocType: Account,Chargeable,Obračuna
-DocType: Company,Change Abbreviation,Spremeni kratico
-DocType: Expense Claim Detail,Expense Date,Expense Datum
-DocType: Item,Max Discount (%),Max Popust (%)
-apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30,Credit Days cannot be a negative number,Kreditni dnevi ne smejo biti negativni
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Zadnja naročite Znesek
-DocType: Cash Flow Mapper,e.g Adjustments for:,npr. prilagoditve za:
-apps/erpnext/erpnext/stock/doctype/item/item.py +274," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Ohrani Vzorec temelji na seriji, preverite ali Ima številko serije, da ohranite vzorec serije"
-DocType: Task,Is Milestone,je Milestone
-DocType: Delivery Stop,Email Sent To,E-pošta poslana
-DocType: Budget,Warn,Opozori
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81,Are you sure you want to unregister?,"Ali ste prepričani, da se želite odjaviti?"
-DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Kakršne koli druge pripombe, omembe vredna napora, da bi moral iti v evidencah."
-DocType: Asset Maintenance,Manufacturing User,Proizvodnja Uporabnik
-DocType: Purchase Invoice,Raw Materials Supplied,"Surovin, dobavljenih"
-DocType: C-Form,Series,Zaporedje
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +283,Currency of the price list {0} must be {1} or {2},Valuta cenika {0} mora biti {1} ali {2}
-DocType: Appraisal,Appraisal Template,Cenitev Predloga
-DocType: Soil Texture,Ternary Plot,Ternary plot
-DocType: Item Group,Item Classification,Postavka Razvrstitev
-DocType: Driver,License Number,Številka licence
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131,Business Development Manager,Business Development Manager
-DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Vzdrževanje Obiščite Namen
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19,Invoice Patient Registration,Registracija računa pacientov
-DocType: Crop,Period,Obdobje
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +18,General Ledger,Glavna knjiga
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33,Employee {0} on Leave on {1},Zaposlenih {0} v odhod {1}
-apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Poglej ponudbe
-DocType: Program Enrollment Tool,New Program,Nov program
-DocType: Item Attribute Value,Attribute Value,Vrednosti atributa
-,Itemwise Recommended Reorder Level,Itemwise Priporočena Preureditev Raven
-DocType: Salary Detail,Salary Detail,plača Podrobnosti
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1043,Please select {0} first,"Prosimo, izberite {0} najprej"
-DocType: Appointment Type,Physician,Zdravnik
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +858,Batch {0} of Item {1} has expired.,Serija {0} od Postavka {1} je potekla.
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,Posvetovanja
-DocType: Sales Invoice,Commission,Komisija
-apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Čas List za proizvodnjo.
-apps/erpnext/erpnext/templates/pages/cart.html +37,Subtotal,Vmesni seštevek
-DocType: Physician,Charges,Dajatve
-DocType: Salary Detail,Default Amount,Privzeti znesek
-DocType: Lab Test Template,Descriptive,Opisno
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +95,Warehouse not found in the system,Skladišče ni mogoče najti v sistemu
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115,This Month's Summary,Povzetek tega meseca je
-DocType: Quality Inspection Reading,Quality Inspection Reading,Kakovost Inšpekcijski Reading
-apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25,`Freeze Stocks Older Than` should be smaller than %d days.,`Zamrzni zaloge starejše od` mora biti manjša od %d dni.
-DocType: Tax Rule,Purchase Tax Template,Nakup Davčna Template
-apps/erpnext/erpnext/utilities/user_progress.py +45,Set a sales goal you'd like to achieve for your company.,"Določite prodajni cilj, ki ga želite doseči za vaše podjetje."
-,Project wise Stock Tracking,Projekt pametno Stock Tracking
-DocType: GST HSN Code,Regional,regionalno
-apps/erpnext/erpnext/config/healthcare.py +40,Laboratory,Laboratorij
-DocType: Stock Entry Detail,Actual Qty (at source/target),Dejanska Količina (pri viru / cilju)
-DocType: Item Customer Detail,Ref Code,Ref Code
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75,Customer Group is Required in POS Profile,Skupina strank je potrebna v profilu POS
-apps/erpnext/erpnext/config/hr.py +12,Employee records.,Evidence zaposlenih.
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +98,Please set Next Depreciation Date,"Prosim, nastavite Naslednja Amortizacija Datum"
-DocType: HR Settings,Payroll Settings,Nastavitve plače
-apps/erpnext/erpnext/config/accounts.py +146,Match non-linked Invoices and Payments.,Match nepovezane računov in plačil.
-DocType: POS Settings,POS Settings,POS nastavitve
-apps/erpnext/erpnext/templates/pages/cart.html +16,Place Order,Naročiti
-DocType: Email Digest,New Purchase Orders,Nova naročila
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,Root cannot have a parent cost center,Root ne more imeti matična stroškovno mesto v
-apps/erpnext/erpnext/public/js/stock_analytics.js +57,Select Brand...,Izberi znamko ...
-apps/erpnext/erpnext/public/js/setup_wizard.js +32,Non Profit (beta),Neprofitna (beta)
-apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18,Training Events/Results,Usposabljanje Dogodki / Rezultati
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152,Accumulated Depreciation as on,"Nabrano amortizacijo, na"
-DocType: Sales Invoice,C-Form Applicable,"C-obliki, ki velja"
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +438,Operation Time must be greater than 0 for Operation {0},"Delovanje Čas mora biti večja od 0, za obratovanje {0}"
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +106,Warehouse is mandatory,Skladišče je obvezna
-DocType: Shareholder,Address and Contacts,Naslov in kontakti
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67,Failed to create website,Spletne strani ni bilo mogoče ustvariti
-DocType: Soil Analysis,Mg/K,Mg / K
-DocType: UOM Conversion Detail,UOM Conversion Detail,UOM Conversion Detail
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +924,Retention Stock Entry already created or Sample Quantity not provided,"Zaprta zaloga, ki je že bila ustvarjena, ali količina vzorca ni zagotovljena"
-DocType: Program,Program Abbreviation,Kratica programa
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +426,Production Order cannot be raised against a Item Template,Proizvodnja naročilo ne more biti postavljeno pred Predloga Postavka
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52,Charges are updated in Purchase Receipt against each item,Dajatve so posodobljeni v Potrdilo o nakupu ob vsaki postavki
-DocType: Warranty Claim,Resolved By,Rešujejo s
-DocType: Bank Guarantee,Start Date,Datum začetka
-apps/erpnext/erpnext/config/hr.py +75,Allocate leaves for a period.,Dodeli liste za obdobje.
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Čeki in depoziti nepravilno izbil
-apps/erpnext/erpnext/accounts/doctype/account/account.py +46,Account {0}: You can not assign itself as parent account,Račun {0}: ne moreš dodeliti samega sebe kot matični račun
-DocType: Purchase Invoice Item,Price List Rate,Cenik Rate
-apps/erpnext/erpnext/utilities/activation.py +72,Create customer quotes,Ustvari ponudbe kupcev
-DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Pokaži &quot;Na zalogi&quot; ali &quot;Ni na zalogi&quot;, ki temelji na zalogi na voljo v tem skladišču."
-apps/erpnext/erpnext/config/manufacturing.py +38,Bill of Materials (BOM),Kosovnica (BOM)
-DocType: Item,Average time taken by the supplier to deliver,"Povprečen čas, ki ga dobavitelj dostaviti"
-DocType: Sample Collection,Collected By,Zbrane z
-apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +35,Assessment Result,ocena Rezultat
-DocType: Hotel Room Package,Hotel Room Package,Paket za hotelske sobe
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,Ur
-DocType: Project,Expected Start Date,Pričakovani datum začetka
-DocType: Purchase Invoice,04-Correction in Invoice,04-Popravek na računu
-apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant Details Report,Poročilo o variantah
-DocType: Setup Progress Action,Setup Progress Action,Akcijski program Setup Progress
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +36,Buying Price List,Nakupni cenik
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49,Remove item if charges is not applicable to that item,"Odstranite element, če stroški ne nanaša na to postavko"
-apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21,Please select Maintenance Status as Completed or remove Completion Date,Izberite stanje vzdrževanja kot dokončano ali odstranite datum zaključka
-DocType: Supplier,Default Payment Terms Template,Predloga za privzete plačilne pogoje
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34,Transaction currency must be same as Payment Gateway currency,Transakcijski valuta mora biti enaka kot vplačilo valuto
-DocType: Payment Entry,Receive,Prejeti
-apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,Ponudbe:
-DocType: Maintenance Visit,Fully Completed,V celoti končana
-apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}% končano
-DocType: Employee,Educational Qualification,Izobraževalni Kvalifikacije
-DocType: Workstation,Operating Costs,Obratovalni stroški
-DocType: Budget,Action if Accumulated Monthly Budget Exceeded,"Ukrep, če skupna mesečna Proračun Prekoračitev"
-DocType: Subscription,Submit on creation,Predloži na ustvarjanje
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +476,Currency for {0} must be {1},Valuta za {0} mora biti {1}
-DocType: Asset,Disposal Date,odstranjevanje Datum
-DocType: Daily Work Summary Settings,"Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.","E-pošta bo poslana vsem aktivnih zaposlenih v družbi na določeni uri, če nimajo počitnic. Povzetek odgovorov bo poslano ob polnoči."
-DocType: Employee Leave Approver,Employee Leave Approver,Zaposleni Leave odobritelj
-apps/erpnext/erpnext/stock/doctype/item/item.py +509,Row {0}: An Reorder entry already exists for this warehouse {1},Vrstica {0}: Vpis Preureditev že obstaja za to skladišče {1}
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99,"Cannot declare as lost, because Quotation has been made.","Ne more razglasiti kot izgubljena, ker je bil predračun postavil."
-apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16,Training Feedback,Predlogi za usposabljanje
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +495,Production Order {0} must be submitted,Proizvodnja naročite {0} je treba predložiti
-DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Merila ocenjevalnih meril za dobavitelje
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149,Please select Start Date and End Date for Item {0},"Prosimo, izberite Start in končni datum za postavko {0}"
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},Seveda je obvezna v vrsti {0}
-apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,Do danes ne more biti pred od datuma
-DocType: Supplier Quotation Item,Prevdoc DocType,Prevdoc DOCTYPE
-DocType: Cash Flow Mapper,Section Footer,Noga odseka
-apps/erpnext/erpnext/stock/doctype/item/item.js +275,Add / Edit Prices,Dodaj / Uredi Cene
-DocType: Batch,Parent Batch,nadrejena Serija
-DocType: Batch,Parent Batch,nadrejena Serija
-DocType: Cheque Print Template,Cheque Print Template,Ček Print Predloga
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36,Chart of Cost Centers,Grafikon stroškovnih mest
-DocType: Lab Test Template,Sample Collection,Zbiranje vzorcev
-,Requested Items To Be Ordered,Zahtevane Postavke naloži
-apps/erpnext/erpnext/public/js/hub/hub_page.js +137,My Orders,Moja naročila
-DocType: Price List,Price List Name,Cenik Ime
-DocType: BOM,Manufacturing,Predelovalne dejavnosti
-,Ordered Items To Be Delivered,Naročeno Točke je treba dostaviti
-DocType: Account,Income,Prihodki
-DocType: Industry Type,Industry Type,Industrija Type
-apps/erpnext/erpnext/templates/includes/cart.js +150,Something went wrong!,Nekaj je šlo narobe!
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +106,Warning: Leave application contains following block dates,Opozorilo: Pustite prijava vsebuje naslednje datume blok
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +275,Sales Invoice {0} has already been submitted,Račun {0} je že bil predložen
-DocType: Supplier Scorecard Scoring Criteria,Score,ocena
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Poslovno leto {0} ne obstaja
-DocType: Asset Maintenance Log,Completion Date,datum dokončanja
-DocType: Purchase Invoice Item,Amount (Company Currency),Znesek (družba Valuta)
-DocType: Agriculture Analysis Criteria,Agriculture User,Kmetijski uporabnik
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38,Valid till date cannot be before transaction date,Veljaven do datuma ne more biti pred datumom transakcije
-apps/erpnext/erpnext/stock/stock_ledger.py +381,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} enot {1} potrebnih v {2} na {3} {4} za {5} za dokončanje te transakcije.
-DocType: Fee Schedule,Student Category,študent kategorije
-DocType: Announcement,Student,študent
-apps/erpnext/erpnext/config/hr.py +238,Organization unit (department) master.,"Organizacijska enota (oddelek), master."
-DocType: Shipping Rule,Shipping Rule Type,Vrsta pravilnika o dostavi
-apps/erpnext/erpnext/utilities/user_progress.py +236,Go to Rooms,Pojdi v sobe
-apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,Vnesite sporočilo pred pošiljanjem
-DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DVOJNIK dobavitelja
-DocType: Email Digest,Pending Quotations,Dokler Citati
-apps/erpnext/erpnext/config/accounts.py +318,Point-of-Sale Profile,Point-of-Sale profila
-apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +24,{0} should be a value between 0 and 100,{0} mora biti vrednost med 0 in 100
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +94,Next Depreciation Date cannot be before Available-for-use Date,"Naslednji amortizacijski datum ne sme biti pred datumom, razpoložljivim za uporabo"
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156,Unsecured Loans,Nezavarovana posojila
-DocType: Cost Center,Cost Center Name,Stalo Ime Center
-DocType: Student,B+,B +
-DocType: HR Settings,Max working hours against Timesheet,Max delovne ure pred Timesheet
-DocType: Maintenance Schedule Detail,Scheduled Date,Načrtovano Datum
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +209,Total Paid Amt,Total Paid Amt
-DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,"Sporočila večji od 160 znakov, bo razdeljeno v več sporočilih"
-DocType: Purchase Receipt Item,Received and Accepted,Prejme in potrdi
-DocType: Hub Settings,Company and Seller Profile,Profil podjetja in prodajalca
-,GST Itemised Sales Register,DDV Razčlenjeni prodaje Registracija
-DocType: Soil Texture,Silt Loam,Silt Loam
-,Serial No Service Contract Expiry,Zaporedna številka Service Contract preteka
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299,You cannot credit and debit same account at the same time,"Ne, ne moreš kreditnih in debetnih isti račun ob istem času"
-DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Stopnja pulza odraslih je med 50 in 80 utripov na minuto.
-DocType: Naming Series,Help HTML,Pomoč HTML
-DocType: Student Group Creation Tool,Student Group Creation Tool,Študent orodje za oblikovanje skupine
-DocType: Item,Variant Based On,"Varianta, ki temelji na"
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53,Total weightage assigned should be 100%. It is {0},Skupaj weightage dodeljena mora biti 100%. To je {0}
-apps/erpnext/erpnext/utilities/user_progress.py +106,Your Suppliers,Vaše Dobavitelji
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,Please correct the,Prosim popravite
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80,Cannot set as Lost as Sales Order is made.,"Ni mogoče nastaviti kot izgubili, kot je narejena Sales Order."
-DocType: Request for Quotation Item,Supplier Part No,Šifra dela dobavitelj
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',"ne more odbiti, če je kategorija za &quot;vrednotenje&quot; ali &quot;Vaulation in Total&quot;"
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +370,Received From,Prejela od
-DocType: Lead,Converted,Pretvorjena
-DocType: Item,Has Serial No,Ima serijsko številko
-DocType: Employee,Date of Issue,Datum izdaje
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222,"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}","Kot je na Nastavitve Nakup če Nakup Reciept Zahtevano == &quot;DA&quot;, nato pa za ustvarjanje računu o nakupu, uporabnik potreba ustvariti Nakup listek najprej za postavko {0}"
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167,Row #{0}: Set Supplier for item {1},Vrstica # {0}: Nastavite Dobavitelj za postavko {1}
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,Row {0}: Hours value must be greater than zero.,Vrstica {0}: Ure vrednost mora biti večja od nič.
-apps/erpnext/erpnext/stock/doctype/item/item.py +194,Website Image {0} attached to Item {1} cannot be found,Spletna stran slike {0} pritrjena na postavki {1} ni mogoče najti
-DocType: Issue,Content Type,Vrsta vsebine
-DocType: Asset,Assets,Sredstva
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17,Computer,Računalnik
-DocType: Item,List this Item in multiple groups on the website.,Seznam ta postavka v več skupinah na spletni strani.
-DocType: Payment Term,Due Date Based On,Datum na podlagi datuma
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +85,Please set default customer group and territory in Selling Settings,"Prosimo, nastavite privzeto skupino strank in ozemlje v nastavitvah prodaj"
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,{0} {1} does not exist,{0} {1} ne obstaja
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323,Please check Multi Currency option to allow accounts with other currency,"Prosimo, preverite Multi Valuta možnost, da se omogoči račune pri drugi valuti"
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +87,Item: {0} does not exist in the system,Postavka: {0} ne obstaja v sistemu
-apps/erpnext/erpnext/accounts/doctype/account/account.py +106,You are not authorized to set Frozen value,Nimate dovoljenja za nastavitev Zamrznjena vrednost
-DocType: Payment Reconciliation,Get Unreconciled Entries,Pridobite neusklajene vnose
-DocType: Payment Reconciliation,From Invoice Date,Od Datum računa
-DocType: Healthcare Settings,Laboratory Settings,Laboratorijske nastavitve
-apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97,Successfully Set Supplier,Uspešno nastavite dobavitelja
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75,Leave Encashment,pustite Vnovčevanje
-apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,Kaj to naredi?
-DocType: Crop,Byproducts,Stranski produkti
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +84,To Warehouse,Za skladišča
-apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26,All Student Admissions,Vse Študentski Sprejemi
-,Average Commission Rate,Povprečen Komisija Rate
-DocType: Share Balance,No of Shares,Število delnic
-apps/erpnext/erpnext/stock/doctype/item/item.py +447,'Has Serial No' can not be 'Yes' for non-stock item,"""Ima serijsko številko"" ne more biti 'Da' za postavko brez zalog"
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +62,Select Status,Izberite Stanje
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41,Attendance can not be marked for future dates,Udeležba ni mogoče označiti za prihodnje datume
-DocType: Pricing Rule,Pricing Rule Help,Cen Pravilo Pomoč
-DocType: School House,House Name,Naslov
-DocType: Fee Schedule,Total Amount per Student,Skupni znesek na študenta
-DocType: Purchase Taxes and Charges,Account Head,Račun Head
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153,Electrical,Električno
-apps/erpnext/erpnext/utilities/activation.py +100,Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,Dodajte preostanek organizacije kot uporabnike. Dodate lahko tudi povabi stranke na vašem portalu jih dodate iz imenika
-DocType: Stock Entry,Total Value Difference (Out - In),Skupna vrednost Razlika (Out - IN)
-DocType: Grant Application,Requested Amount,Zahtevani znesek
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348,Row {0}: Exchange Rate is mandatory,Vrstica {0}: Menjalni tečaj je obvezen
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,User ID not set for Employee {0},ID uporabnika ni nastavljena za Employee {0}
-DocType: Vehicle,Vehicle Value,Vrednost vozila
-DocType: Crop Cycle,Detected Diseases,Detektirane bolezni
-DocType: Stock Entry,Default Source Warehouse,Privzeto Vir Skladišče
-DocType: Item,Customer Code,Koda za stranke
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +220,Birthday Reminder for {0},"Opomnik za rojstni dan, za {0}"
-DocType: Asset Maintenance Task,Last Completion Date,Zadnji datum zaključka
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72,Days Since Last Order,Dni od zadnjega naročila
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +365,Debit To account must be a Balance Sheet account,Bremenitev računa mora biti bilanca računa
-DocType: Buying Settings,Naming Series,Poimenovanje zaporedja
-DocType: Leave Block List,Leave Block List Name,Pustite Ime Block List
-apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14,Insurance Start date should be less than Insurance End date,Datum zavarovanje Začetek sme biti manjša od datuma zavarovanje End
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Zaloga Sredstva
-DocType: Timesheet,Production Detail,proizvodnja Podrobnosti
-DocType: Restaurant,Active Menu,Aktivni meni
-DocType: Target Detail,Target Qty,Ciljna Kol
-DocType: Shopping Cart Settings,Checkout Settings,Naročilo Nastavitve
-DocType: Student Attendance,Present,Present
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,Delivery Note {0} must not be submitted,Dobavnica {0} ni treba predložiti
-DocType: Notification Control,Sales Invoice Message,Prodaja Račun Sporočilo
-apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,Zapiranje račun {0} mora biti tipa odgovornosti / kapital
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +324,Salary Slip of employee {0} already created for time sheet {1},Plača Slip delavca {0} že ustvarili za časa stanja {1}
-DocType: Vehicle Log,Odometer,števec kilometrov
-DocType: Production Plan Item,Ordered Qty,Naročeno Kol
-apps/erpnext/erpnext/stock/doctype/item/item.py +743,Item {0} is disabled,Postavka {0} je onemogočena
-DocType: Stock Settings,Stock Frozen Upto,Stock Zamrznjena Stanuje
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +930,BOM does not contain any stock item,BOM ne vsebuje nobenega elementa zaloge
-DocType: Chapter,Chapter Head,Poglavje glave
-DocType: Payment Term,Month(s) after the end of the invoice month,Mesec (i) po koncu meseca računa
-apps/erpnext/erpnext/config/projects.py +19,Project activity / task.,Projektna dejavnost / naloga.
-DocType: Vehicle Log,Refuelling Details,Oskrba z gorivom Podrobnosti
-apps/erpnext/erpnext/config/hr.py +104,Generate Salary Slips,Ustvarjajo plače kombineže
-apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +24,Lab result datetime cannot be before testing datetime,Datetime rezultatov laboratorija ne more biti pred testiranjem datetime
-DocType: POS Profile,Allow user to edit Discount,Dovoli uporabniku urejanje popusta
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +55,Get customers from,Pridobite stranke od
-DocType: Production Plan Item,Include Exploded Items,Vključi eksplodirane elemente
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +45,"Buying must be checked, if Applicable For is selected as {0}","Odkup je treba preveriti, če se uporablja za izbrana kot {0}"
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,"Popust, mora biti manj kot 100"
-DocType: Shipping Rule,Restrict to Countries,Omeji na države
-DocType: Purchase Invoice,Write Off Amount (Company Currency),Napišite enkratni znesek (družba Valuta)
-DocType: Sales Invoice Timesheet,Billing Hours,zaračunavanje storitev ure
-DocType: Project,Total Sales Amount (via Sales Order),Skupni znesek prodaje (preko prodajnega naloga)
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +548,Default BOM for {0} not found,Privzeti BOM za {0} ni bilo mogoče najti
-apps/erpnext/erpnext/stock/doctype/item/item.py +513,Row #{0}: Please set reorder quantity,Vrstica # {0}: Prosim nastavite naročniško količino
-apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,"Dotaknite predmete, da jih dodate tukaj"
-DocType: Fees,Program Enrollment,Program Vpis
-DocType: Share Transfer,To Folio No,V Folio št
-DocType: Landed Cost Voucher,Landed Cost Voucher,Pristali Stroški bon
-apps/erpnext/erpnext/public/js/queries.js +39,Please set {0},"Prosim, nastavite {0}"
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} neaktiven študent
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} neaktiven študent
-DocType: Employee,Health Details,Podrobnosti zdravja
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,To create a Payment Request reference document is required,Če želite ustvariti zahtevek za plačilo je potrebno referenčni dokument
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,To create a Payment Request reference document is required,Če želite ustvariti zahtevek za plačilo je potrebno referenčni dokument
-DocType: Soil Texture,Sandy Clay,Sandy Clay
-DocType: Grant Application,Assessment  Manager,Ocenjevalec
-DocType: Payment Entry,Allocate Payment Amount,Dodeli znesek plačila
-DocType: Employee External Work History,Salary,Plača
-DocType: Serial No,Delivery Document Type,Dostava Document Type
-DocType: Sales Order,Partly Delivered,Delno Delivered
-DocType: Item Variant Settings,Do not update variants on save,Ne shranjujte različic pri shranjevanju
-DocType: Email Digest,Receivables,Terjatve
-DocType: Lead Source,Lead Source,Vir ponudbe
-DocType: Customer,Additional information regarding the customer.,Dodatne informacije o kupcu.
-DocType: Quality Inspection Reading,Reading 5,Branje 5
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +231,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} je povezan z {2}, vendar je Račun stranke {3}"
-apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7,View Lab Tests,Oglejte si laboratorijske preiskave
-DocType: Purchase Invoice,Y,Y
-DocType: Maintenance Visit,Maintenance Date,Vzdrževanje Datum
-DocType: Purchase Invoice Item,Rejected Serial No,Zavrnjeno Zaporedna številka
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82,Year start date or end date is overlapping with {0}. To avoid please set company,"Leto datum začetka oziroma prenehanja se prekrivajo z {0}. Da bi se izognili prosim, da podjetje"
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +129,Please mention the Lead Name in Lead {0},"Prosimo, navedite vodilno ime v vodniku {0}"
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156,Start date should be less than end date for Item {0},Začetni datum mora biti manjša od končnega datuma za postavko {0}
-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 serija nastavljen in serijska številka ni navedena v transakcijah, se bo ustvaril nato samodejno serijska številka, ki temelji na tej seriji. Če ste si vedno želeli izrecno omeniti Serial številk za to postavko. pustite prazno."
-DocType: Upload Attendance,Upload Attendance,Naloži Udeležba
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +571,BOM and Manufacturing Quantity are required,BOM and Manufacturing Količina so obvezna
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Staranje Razpon 2
-DocType: SG Creation Tool Course,Max Strength,Max moč
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28,Installing presets,Namestitev prednastavitev
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +85,No Delivery Note selected for Customer {},Za kupca ni izbranega obvestila o dostavi {}
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +25,BOM replaced,BOM nadomesti
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1043,Select Items based on Delivery Date,Izberite elemente glede na datum dostave
-DocType: Grant Application,Has any past Grant Record,Ima dodeljen zapis
-,Sales Analytics,Prodajna analitika
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +127,Available {0},Na voljo {0}
-,Prospects Engaged But Not Converted,Obeti Ukvarjajo pa ne pretvorijo
-,Prospects Engaged But Not Converted,Obeti Ukvarjajo pa ne pretvorijo
-DocType: Manufacturing Settings,Manufacturing Settings,Proizvodne Nastavitve
-apps/erpnext/erpnext/config/setup.py +56,Setting up Email,Postavitev Email
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Guardian1 Mobile No
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106,Please enter default currency in Company Master,Vnesite privzeto valuto v podjetju Master
-DocType: Stock Entry Detail,Stock Entry Detail,Stock Začetek Detail
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109,Daily Reminders,Dnevni opomniki
-DocType: Products Settings,Home Page is Products,Domača stran je izdelki
-,Asset Depreciation Ledger,Sredstvo Amortizacija Ledger
-apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +90,Tax Rule Conflicts with {0},Davčna Pravilo Konflikti z {0}
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,New Account Name,Novo ime računa
-DocType: Purchase Invoice Item,Raw Materials Supplied Cost,"Surovin, dobavljenih Stroški"
-DocType: Selling Settings,Settings for Selling Module,Nastavitve za modul Prodaja
-DocType: Hotel Room Reservation,Hotel Room Reservation,Rezervacija hotelske sobe
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115,Customer Service,Storitev za stranke
-DocType: BOM,Thumbnail,Thumbnail
-DocType: Item Customer Detail,Item Customer Detail,Postavka Detail Stranka
-apps/erpnext/erpnext/config/hr.py +50,Offer candidate a Job.,Ponudba kandidat Job.
-DocType: Notification Control,Prompt for Email on Submission of,Vprašal za e-poštni ob predložitvi
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88,Total allocated leaves are more than days in the period,Skupaj dodeljena listi so več kot dni v obdobju
-DocType: Land Unit,Linked Soil Analysis,Povezana analiza tal
-DocType: Pricing Rule,Percentage,odstotek
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70,Item {0} must be a stock Item,Postavka {0} mora biti stock postavka
-DocType: Manufacturing Settings,Default Work In Progress Warehouse,Privzeto Delo v skladišču napredku
-apps/erpnext/erpnext/config/accounts.py +288,Default settings for accounting transactions.,Privzete nastavitve za računovodske posle.
-DocType: Maintenance Visit,MV,MV
-DocType: Restaurant,Default Tax Template,Privzeta davčna predloga
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +66,{0} Students have been enrolled,{0} Študenti so bili vpisani
-DocType: Fees,Student Details,Podrobnosti študenta
-DocType: Purchase Invoice Item,Stock Qty,Stock Kol
-DocType: Purchase Invoice Item,Stock Qty,Stock Kol
-DocType: Employee Loan,Repayment Period in Months,Vračilo Čas v mesecih
-apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26,Error: Not a valid id?,Napaka: Ni veljaven id?
-DocType: Naming Series,Update Series Number,Posodobi številko zaporedja
-DocType: Account,Equity,Kapital
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,"{0} {1}: ""Izkaz poslovnega izida"" tip računa {2} ni dovoljen v Otvoritvenem zapisu"
-DocType: Sales Order,Printing Details,Tiskanje Podrobnosti
-DocType: Task,Closing Date,Zapiranje Datum
-DocType: Sales Order Item,Produced Quantity,Proizvedena količina
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126,Engineer,Inženir
-DocType: Journal Entry,Total Amount Currency,Skupni znesek Valuta
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Iskanje sklope
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171,Item Code required at Row No {0},Oznaka zahteva pri Row št {0}
-DocType: GST Account,SGST Account,Račun SGST
-apps/erpnext/erpnext/utilities/user_progress.py +151,Go to Items,Pojdi na elemente
-DocType: Sales Partner,Partner Type,Partner Type
-DocType: Purchase Taxes and Charges,Actual,Actual
-DocType: Restaurant Menu,Restaurant Manager,Upravitelj restavracij
-DocType: Authorization Rule,Customerwise Discount,Customerwise Popust
-apps/erpnext/erpnext/config/projects.py +41,Timesheet for tasks.,Timesheet za naloge.
-DocType: Purchase Invoice,Against Expense Account,Proti Expense račun
-DocType: Production Order,Production Order,Proizvodnja naročilo
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +282,Installation Note {0} has already been submitted,Je že bil predložen Namestitev Opomba {0}
-DocType: Bank Reconciliation,Get Payment Entries,Dobili plačila Entries
-DocType: Quotation Item,Against Docname,Proti Docname
-DocType: SMS Center,All Employee (Active),Vsi zaposlenih (Active)
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9,View Now,Oglejte si zdaj
-DocType: BOM,Raw Material Cost,Raw Material Stroški
-DocType: Item Reorder,Re-Order Level,Ponovno naročila ravni
-apps/erpnext/erpnext/projects/doctype/project/project.js +64,Gantt Chart,Gantogram
-DocType: Crop Cycle,Cycle Type,Vrsta cikla
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99,Part-time,Krajši delovni čas
-DocType: Employee,Applicable Holiday List,Velja Holiday Seznam
-DocType: Employee,Cheque,Ček
-DocType: Training Event,Employee Emails,Emails za zaposlene
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +59,Series Updated,Zaporedje posodobljeno
-apps/erpnext/erpnext/accounts/doctype/account/account.py +159,Report Type is mandatory,Vrsta poročila je obvezna
-DocType: Item,Serial Number Series,Serijska številka zaporedja
-apps/erpnext/erpnext/buying/utils.py +68,Warehouse is mandatory for stock Item {0} in row {1},Skladišče je obvezna za borzo postavki {0} v vrstici {1}
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45,Retail & Wholesale,Trgovina na drobno in na debelo
-DocType: Issue,First Responded On,Najprej odgovorila
-DocType: Website Item Group,Cross Listing of Item in multiple groups,Cross Uvrstitev točke v več skupinah
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Fiskalna Leto Start Date in fiskalno leto End Date so že določeni v proračunskem letu {0}
-DocType: Projects Settings,Ignore User Time Overlap,Prezreti preklop uporabniškega časa
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Clearance Date updated,Potrditev Datum posodobljeni
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +146,Split Batch,Split Serija
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +146,Split Batch,Split Serija
-DocType: Stock Settings,Batch Identification,Identifikacija serije
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132,Successfully Reconciled,Uspešno usklajeno
-DocType: Request for Quotation Supplier,Download PDF,Prenos PDF
-DocType: Production Order,Planned End Date,Načrtovan End Date
-DocType: Shareholder,Hidden list maintaining the list of contacts linked to Shareholder,"Skrit seznam, ki vodi seznam kontaktov, povezanih z delničarjem"
-apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Podatki o donatorju.
-DocType: Request for Quotation,Supplier Detail,Dobavitelj Podrobnosti
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100,Error in formula or condition: {0},Napaka v formuli ali stanja: {0}
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +94,Invoiced Amount,Obračunani znesek
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47,Criteria weights must add up to 100%,Uteži meril morajo biti do 100%
-apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,Udeležba
-apps/erpnext/erpnext/public/js/pos/pos.html +104,Stock Items,zalogi
-DocType: BOM,Materials,Materiali
-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 izbrana, bo seznam je treba dodati, da vsak oddelek, kjer je treba uporabiti."
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +111,Creating {0},Ustvarjanje {0}
-apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Vir in Target skladišča ne more biti enaka
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +573,Posting date and posting time is mandatory,"Napotitev datum in čas objavljate, je obvezna"
-apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Davčna predloga za nabavne transakcije
-,Item Prices,Postavka Cene
-DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,"V besedi bo viden, ko boste prihranili naročilnico."
-DocType: Period Closing Voucher,Period Closing Voucher,Obdobje Closing bon
-DocType: Consultation,Review Details,Pregled podrobnosti
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +185,The shareholder does not belong to this company,Delničar ne pripada tej družbi
-DocType: Dosage Form,Dosage Form,Odmerni obrazec
-apps/erpnext/erpnext/config/selling.py +67,Price List master.,Cenik gospodar.
-DocType: Task,Review Date,Pregled Datum
-DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Serija za vpis vrednosti amortizacije (dnevnik)
-DocType: Membership,Member Since,Član od
-DocType: Purchase Invoice,Advance Payments,Predplačila
-DocType: Purchase Taxes and Charges,On Net Total,On Net Total
-apps/erpnext/erpnext/controllers/item_variant.py +92,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Vrednost atributa {0} mora biti v razponu od {1} do {2} v korakih po {3} za postavko {4}
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +175,Target warehouse in row {0} must be same as Production Order,Ciljna skladišče v vrstici {0} mora biti enaka kot Production reda
-DocType: Restaurant Reservation,Waitlisted,Waitlisted
-apps/erpnext/erpnext/accounts/doctype/account/account.py +124,Currency can not be changed after making entries using some other currency,"Valuta ni mogoče spremeniti, potem ko vnose uporabljate kakšno drugo valuto"
-DocType: Shipping Rule,Fixed,Popravljeno
-DocType: Vehicle Service,Clutch Plate,sklopka Plate
-DocType: Company,Round Off Account,Zaokrožijo račun
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93,Administrative Expenses,Administrativni stroški
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18,Consulting,Consulting
-DocType: Customer Group,Parent Customer Group,Parent Customer Group
-DocType: Journal Entry,Subscription,Naročnina
-DocType: Purchase Invoice,Contact Email,Kontakt E-pošta
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Čakanje v kreiranju
-DocType: Appraisal Goal,Score Earned,Rezultat Zaslužili
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +240,Notice Period,Odpovedni rok
-DocType: Asset Category,Asset Category Name,Sredstvo Kategorija Ime
-apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,This is a root territory and cannot be edited.,To je koren ozemlje in ga ni mogoče urejati.
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5,New Sales Person Name,Ime New Sales oseba
-DocType: Packing Slip,Gross Weight UOM,Bruto Teža UOM
-DocType: Asset Maintenance Task,Preventive Maintenance,Preventivno vzdrževanje
-DocType: Delivery Note Item,Against Sales Invoice,Za račun
-DocType: Purchase Invoice,07-Others,07-Drugo
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151,Please enter serial numbers for serialized item ,Vnesite serijske številke za serialized postavko
-DocType: Bin,Reserved Qty for Production,Rezervirano Količina za proizvodnjo
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43,EcritureNum,EcritureNum
-DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,"Pustite neoznačeno, če ne želite, da razmisli serije, hkrati pa seveda temelji skupin."
-DocType: Asset,Frequency of Depreciation (Months),Pogostost amortizacijo (meseci)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +500,Credit Account,Credit račun
-DocType: Landed Cost Item,Landed Cost Item,Pristali Stroški Postavka
-apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57,Show zero values,Prikaži ničelnimi vrednostmi
-DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Količina postavke pridobljeno po proizvodnji / prepakiranja iz danih količin surovin
-DocType: Lab Test,Test Group,Testna skupina
-DocType: Payment Reconciliation,Receivable / Payable Account,Terjatve / plačljivo račun
-DocType: Delivery Note Item,Against Sales Order Item,Proti Sales Order Postavka
-DocType: Company,Company Logo,Logo podjetja
-apps/erpnext/erpnext/stock/doctype/item/item.py +708,Please specify Attribute Value for attribute {0},"Prosimo, navedite Lastnost vrednost za atribut {0}"
-DocType: Item,Default Warehouse,Privzeto Skladišče
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45,Budget cannot be assigned against Group Account {0},Proračun ne more biti dodeljena pred Group račun {0}
-DocType: Healthcare Settings,Patient Registration,Registracija pacientov
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22,Please enter parent cost center,Vnesite stroškovno mesto matično
-DocType: Delivery Note,Print Without Amount,Natisni Brez Znesek
-apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57,Depreciation Date,Amortizacija Datum
-DocType: Issue,Support Team,Support Team
-apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36,Expiry (In Days),Iztek (v dnevih)
-DocType: Appraisal,Total Score (Out of 5),Skupna ocena (od 5)
-DocType: Fee Structure,FS.,FS.
-DocType: Student Attendance Tool,Batch,Serija
-DocType: Donor,Donor Type,Vrsta donatorja
-apps/erpnext/erpnext/stock/doctype/item/item.js +27,Balance,Bilanca
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66,Please select the Company,Izberite podjetje
-DocType: Room,Seating Capacity,Število sedežev
-DocType: Issue,ISS-,ISS-
-DocType: Lab Test Groups,Lab Test Groups,Laboratorijske skupine
-DocType: Project,Total Expense Claim (via Expense Claims),Total Expense zahtevek (preko Expense zahtevkov)
-DocType: GST Settings,GST Summary,DDV Povzetek
-apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py +16,Please enable default incoming account before creating Daily Work Summary Group,"Prosimo, omogočite privzeti dohodni račun, preden ustvarite skupino povzetkov dnevnega reda"
-DocType: Assessment Result,Total Score,Skupni rezultat
-DocType: Journal Entry,Debit Note,Opomin
-DocType: Stock Entry,As per Stock UOM,Kot je na borzi UOM
-apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Ni potekel
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +49,ValidDate,ValidDate
-DocType: Student Log,Achievement,dosežek
-DocType: Batch,Source Document Type,Vir Vrsta dokumenta
-DocType: Batch,Source Document Type,Vir Vrsta dokumenta
-apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24,Following course schedules were created,Ustanovljeni so bili naslednji razporedi tečaja
-DocType: Journal Entry,Total Debit,Skupaj Debetna
-DocType: Manufacturing Settings,Default Finished Goods Warehouse,Privzete Končano Blago Skladišče
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +124,Please select Patient,Izberite Patient
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76,Sales Person,Prodaja oseba
-DocType: Hotel Room Package,Amenities,Amenities
-apps/erpnext/erpnext/config/accounts.py +233,Budget and Cost Center,Proračun in Center Stroški
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65,Multiple default mode of payment is not allowed,Večkratni način plačila ni dovoljen
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,for the,za
-,Appointment Analytics,Imenovanje Analytics
-DocType: Vehicle Service,Half Yearly,Polletni
-DocType: Lead,Blog Subscriber,Blog Subscriber
-DocType: Guardian,Alternate Number,namestnik Število
-DocType: Healthcare Settings,Consultations in valid days,Posvetovanja v veljavnih dneh
-DocType: Assessment Plan Criteria,Maximum Score,Najvišja ocena
-apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,"Ustvarite pravila za omejitev transakcije, ki temeljijo na vrednotah."
-DocType: Cash Flow Mapping Accounts,Cash Flow Mapping Accounts,Računovodski pregledi denarnih tokov
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Številka skupine
-DocType: Batch,Manufacturing Date,Datum izdelave
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Ustvarjanje provizij ni uspelo
-DocType: Opening Invoice Creation Tool,Create Missing Party,Ustvari manjkajočo stranko
-DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Pustite prazno, če bi študenti skupin na leto"
-DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Pustite prazno, če bi študenti skupin na leto"
-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 označeno, Total no. delovnih dni bo vključeval praznike, in to se bo zmanjšala vrednost plač dan na"
-DocType: Purchase Invoice,Total Advance,Skupaj predplačila
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27,Change Template Code,Spremeni kodo šablone
-apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +23,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Izraz Končni datum ne more biti zgodnejši od datuma Term Start. Popravite datum in poskusite znova.
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,quot Štetje
-,BOM Stock Report,BOM Stock Poročilo
-DocType: Stock Reconciliation Item,Quantity Difference,količina Razlika
-DocType: Employee Advance,EA-,EA-
-DocType: Opportunity Item,Basic Rate,Osnovni tečaj
-DocType: GL Entry,Credit Amount,Credit Znesek
-DocType: Cheque Print Template,Signatory Position,podpisnik Položaj
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +173,Set as Lost,Nastavi kot Lost
-DocType: Timesheet,Total Billable Hours,Skupaj plačljivih ur
-apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,Prejem plačilnih Note
-apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,Ta temelji na transakcijah zoper to stranko. Oglejte si časovnico spodaj za podrobnosti
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +162,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},"Vrstica {0}: Dodeljena količina {1}, mora biti manjša ali enaka plačila za vnos zneska {2}"
-DocType: Program Enrollment Tool,New Academic Term,Novi akademski izraz
-,Course wise Assessment Report,Seveda pametno poročilo o oceni
-DocType: Purchase Invoice,Availed ITC State/UT Tax,Izkoristil davčno olajšavo države / UT
-DocType: Tax Rule,Tax Rule,Davčna Pravilo
-DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Ohraniti ista stopnja V celotnem ciklu prodaje
-DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Načrtujte čas dnevnike zunaj Workstation delovnih ur.
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +120,Dr {0} does not have a Physician Schedule. Add it in Physician master,Dr {0} nima urnika zdravnika. Dodajte ga v glavnega zdravnika
-apps/erpnext/erpnext/public/js/pos/pos.html +87,Customers in Queue,Stranke v vrsti
-DocType: Driver,Issuing Date,Datum izdaje
-DocType: Student,Nationality,državljanstvo
-,Items To Be Requested,"Predmeti, ki bodo zahtevana"
-DocType: Purchase Order,Get Last Purchase Rate,Get zadnjega nakupa Rate
-DocType: Company,Company Info,Informacije o podjetju
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1384,Select or add new customer,Izberite ali dodati novo stranko
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +171,Cost center is required to book an expense claim,Stroškovno mesto je potrebno rezervirati odhodek zahtevek
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Uporaba sredstev (sredstva)
-apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,Ta temelji na prisotnosti tega zaposlenega
-DocType: Assessment Result,Summary,Povzetek
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Označi udeležbo
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +494,Debit Account,Debetni račun
-DocType: Fiscal Year,Year Start Date,Leto Start Date
-DocType: Attendance,Employee Name,ime zaposlenega
-DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Vnos naročila restavracije
-DocType: Purchase Invoice,Rounded Total (Company Currency),Zaokrožena Skupaj (Company Valuta)
-apps/erpnext/erpnext/accounts/doctype/account/account.py +96,Cannot covert to Group because Account Type is selected.,"Ne more prikrite skupini, saj je izbrana vrsta računa."
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260,{0} {1} has been modified. Please refresh.,{0} {1} je bila spremenjena. Osvežite.
-DocType: Leave Block List,Stop users from making Leave Applications on following days.,Stop uporabnike iz česar dopusta aplikacij na naslednjih dneh.
-DocType: Asset Maintenance Team,Maintenance Team Members,Člani vzdrževalne ekipe
-apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63,Purchase Amount,Znesek nakupa
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +261,Supplier Quotation {0} created,Dobavitelj za predračun {0} ustvaril
-apps/erpnext/erpnext/accounts/report/financial_statements.py +101,End Year cannot be before Start Year,Konec leta ne more biti pred začetkom leta
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +233,Employee Benefits,Zaslužki zaposlencev
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +264,Packed quantity must equal quantity for Item {0} in row {1},Pakirana količina mora biti enaka količini za postavko {0} v vrstici {1}
-DocType: Production Order,Manufactured Qty,Izdelano Kol
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +78,The shares don't exist with the {0},Delnice ne obstajajo z {0}
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64,Invoice Created,Račun ustvarjen
-DocType: Asset,Out of Order,Ne deluje
-DocType: Purchase Receipt Item,Accepted Quantity,Accepted Količina
-DocType: Projects Settings,Ignore Workstation Time Overlap,Prezri čas prekrivanja delovne postaje
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +242,Please set a default Holiday List for Employee {0} or Company {1},Nastavite privzeto Hiša List za zaposlenega {0} ali podjetja {1}
-apps/erpnext/erpnext/accounts/party.py +31,{0}: {1} does not exists,{0}: {1} ne obstaja
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76,Select Batch Numbers,Izberite številke Serija
-apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Računi zbrana strankam.
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,ID Projekta
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +534,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Vrstica št {0}: količina ne more biti večja od Dokler Znesek proti Expense zahtevka {1}. Dokler Znesek je {2}
-DocType: Assessment Plan,Schedule,Urnik
-DocType: Account,Parent Account,Matični račun
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266,Available,Na voljo
-DocType: Quality Inspection Reading,Reading 3,Branje 3
-,Hub,Vozlišče
-DocType: GL Entry,Voucher Type,Bon Type
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1716,Price List not found or disabled,Cenik ni mogoče najti ali onemogočena
-DocType: Student Applicant,Approved,Odobreno
-apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15,Price,Cena
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +266,Employee relieved on {0} must be set as 'Left',Zaposleni razrešen na {0} mora biti nastavljen kot &quot;levo&quot;
-DocType: Hub Settings,Last Sync On,Zadnja sinhronizacija je vključena
-DocType: Guardian,Guardian,Guardian
-DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Ustvari manjkajočo stranko ali dobavitelja.
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,Cenitev {0} ustvarjena za Employee {1} v določenem časovnem obdobju
-DocType: Academic Term,Education,Izobraževanje
-apps/erpnext/erpnext/public/js/pos/pos.html +78,Del,del
-DocType: Selling Settings,Campaign Naming By,Imenovanje akcija Z
-DocType: Employee,Current Address Is,Trenutni Naslov je
-apps/erpnext/erpnext/utilities/user_progress.py +48,Monthly Sales Target (,Mesečna prodajna tarča (
-apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,spremenjene
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43,"Optional. Sets company's default currency, if not specified.","Neobvezno. Nastavi privzeto valuto družbe, če ni določeno."
-DocType: Sales Invoice,Customer GSTIN,GSTIN stranka
-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 izbran, bo samodejno dodal seznam nalog, ki se ukvarjajo z boleznijo"
-DocType: Asset Repair,Repair Status,Stanje popravila
-apps/erpnext/erpnext/config/accounts.py +67,Accounting journal entries.,Vpisi računovodstvo lista.
-DocType: Delivery Note Item,Available Qty at From Warehouse,Na voljo Količina na IZ SKLADIŠČA
-DocType: POS Profile,Account for Change Amount,Račun za znesek spremembe
-DocType: Purchase Invoice,input service,vnosna storitev
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Vrstica {0}: Party / račun se ne ujema z {1} / {2} v {3} {4}
-DocType: Maintenance Team Member,Maintenance Team Member,Član vzdrževalne ekipe
-DocType: Agriculture Analysis Criteria,Soil Analysis,Analiza tal
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +13,Course Code: ,Šifra predmeta:
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240,Please enter Expense Account,Vnesite Expense račun
-DocType: Account,Stock,Zaloga
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1068,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Row # {0}: Reference Vrsta dokumenta mora biti eden od narocilo, Nakup računa ali Journal Entry"
-DocType: Employee,Current Address,Trenutni naslov
-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 postavka je varianta drug element, potem opis, slike, cene, davki, itd bo določil iz predloge, razen če je izrecno določeno"
-DocType: Serial No,Purchase / Manufacture Details,Nakup / Izdelava Podrobnosti
-DocType: Assessment Group,Assessment Group,Skupina ocena
-apps/erpnext/erpnext/config/stock.py +329,Batch Inventory,Serija Inventory
-DocType: Employee,Contract End Date,Naročilo End Date
-DocType: Sales Order,Track this Sales Order against any Project,Sledi tej Sales Order proti kateri koli projekt
-DocType: Sales Invoice Item,Discount and Margin,Popust in Margin
-DocType: Lab Test,Prescription,Predpis
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +98,Not Available,Ni na voljo
-DocType: Pricing Rule,Min Qty,Min Kol
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36,Disable Template,Onemogoči predlogo
-DocType: GL Entry,Transaction Date,Transakcijski Datum
-DocType: Production Plan Item,Planned Qty,Načrtovano Kol
-apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Skupna davčna
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +191,For Quantity (Manufactured Qty) is mandatory,Za Količina (Izdelano Kol) obvezna
-DocType: Stock Entry,Default Target Warehouse,Privzeto Target Skladišče
-DocType: Purchase Invoice,Net Total (Company Currency),Net Total (družba Valuta)
-apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Leto Končni datum ne more biti zgodnejši od datuma Leto Start. Popravite datum in poskusite znova.
-DocType: Notification Control,Purchase Receipt Message,Potrdilo o nakupu Sporočilo
-DocType: BOM,Scrap Items,ostanki Točke
-DocType: Production Order,Actual Start Date,Dejanski datum začetka
-DocType: Sales Order,% of materials delivered against this Sales Order,% materiala dobavljeno po tej naročilnici
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62,Set default mode of payment,Nastavite privzeti način plačila
-DocType: Grant Application,Withdrawn,umaknjena
-DocType: Hub Settings,Hub Settings,Nastavitve vozlišča
-DocType: Project,Gross Margin %,Gross Margin%
-DocType: BOM,With Operations,Pri poslovanju
-apps/erpnext/erpnext/accounts/party.py +260,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Vknjižbe so že bili sprejeti v valuti {0} za družbo {1}. Izberite terjatve ali obveznosti račun z valuto {0}.
-DocType: Asset,Is Existing Asset,Je obstoječemu sredstvu
-DocType: Salary Detail,Statistical Component,Statistični Komponenta
-DocType: Salary Detail,Statistical Component,Statistični Komponenta
-DocType: Warranty Claim,If different than customer address,Če je drugačen od naslova kupca
-DocType: Purchase Invoice,Without Payment of Tax,Brez plačila davka
-DocType: BOM Operation,BOM Operation,BOM Delovanje
-apps/erpnext/erpnext/config/stock.py +141,Fulfilment,Izpolnjevanje
-DocType: Purchase Taxes and Charges,On Previous Row Amount,Na prejšnje vrstice Znesek
-DocType: Item,Has Expiry Date,Ima rok veljavnosti
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +282,Transfer Asset,prenos sredstev
-DocType: POS Profile,POS Profile,POS profila
-DocType: Training Event,Event Name,Ime dogodka
-DocType: Physician,Phone (Office),Telefon (Office)
-apps/erpnext/erpnext/hooks.py +151,Admission,sprejem
-apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29,Admissions for {0},Vstopnine za {0}
-apps/erpnext/erpnext/config/accounts.py +257,"Seasonality for setting budgets, targets etc.","Sezonskost za nastavitev proračunov, cilji itd"
-DocType: Supplier Scorecard Scoring Variable,Variable Name,Ime spremenljivke
-apps/erpnext/erpnext/stock/get_item_details.py +144,"Item {0} is a template, please select one of its variants","Postavka {0} je predlogo, izberite eno od njenih različic"
-DocType: Asset,Asset Category,sredstvo Kategorija
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31,Net pay cannot be negative,Neto plača ne more biti negativna
-DocType: Purchase Order,Advance Paid,Advance Paid
-DocType: Item,Item Tax,Postavka Tax
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874,Material to Supplier,Material za dobavitelja
-DocType: Soil Texture,Loamy Sand,Loamy Sand
-DocType: Production Plan,Material Request Planning,Načrtovanje materialnih zahtev
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +630,Excise Invoice,Trošarina Račun
-apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Praga {0}% pojavi več kot enkrat
-DocType: Expense Claim,Employees Email Id,Zaposleni Email Id
-DocType: Employee Attendance Tool,Marked Attendance,markirana Udeležba
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138,Current Liabilities,Kratkoročne obveznosti
-apps/erpnext/erpnext/config/selling.py +292,Send mass SMS to your contacts,Pošlji množično SMS vaših stikov
-DocType: Patient,A Positive,Pozitiven
-DocType: Program,Program Name,Ime programa
-DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Razmislite davek ali dajatev za
-DocType: Driver,Driving License Category,Kategorija vozniškega dovoljenja
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +158,No Reference,Brez reference
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Dejanska Količina je obvezna
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} ima trenutno {1} oceno dobavitelja in naročila temu dobavitelju je treba izdajati s previdnostjo
-DocType: Asset Maintenance Team,Asset Maintenance Team,Ekipa za vzdrževanje sredstev
-DocType: Employee Loan,Loan Type,posojilo Vrsta
-DocType: Scheduling Tool,Scheduling Tool,razporejanje orodje
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180,Credit Card,Credit Card
-DocType: BOM,Item to be manufactured or repacked,"Postavka, ki se proizvaja ali prepakirana"
-DocType: Employee Education,Major/Optional Subjects,Major / Izbirni predmeti
-DocType: Sales Invoice Item,Drop Ship,Drop Ship
-DocType: Driver,Suspended,Suspendirano
-DocType: Training Event,Attendees,udeleženci
-DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Tukaj lahko hranite družinske podrobnosti, kot so ime in poklic staršev, zakonca in otrok"
-DocType: Academic Term,Term End Date,Izraz Končni datum
-DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Davki in dajatve Odbitek (družba Valuta)
-DocType: Item Group,General Settings,Splošne nastavitve
-apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23,From Currency and To Currency cannot be same,Od denarja in denarja ne more biti enaka
-DocType: Stock Entry,Repack,Zapakirajte
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,"Morate Shranite obrazec, preden nadaljujete"
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113,Please select the Company first,Najprej izberite podjetje
-DocType: Item Attribute,Numeric Values,Numerične vrednosti
-apps/erpnext/erpnext/public/js/setup_wizard.js +56,Attach Logo,Priložite Logo
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +51,Stock Levels,Zaloga Ravni
-DocType: Customer,Commission Rate,Komisija Rate
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187,Created {0} scorecards for {1} between: ,Ustvarjene {0} kazalnike za {1} med:
-apps/erpnext/erpnext/stock/doctype/item/item.js +475,Make Variant,Naredite Variant
-apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Aplikacije blok dopustu oddelka.
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +150,"Payment Type must be one of Receive, Pay and Internal Transfer","Plačilo Tip mora biti eden od Prejemanje, plačati in notranji prenos"
-apps/erpnext/erpnext/config/selling.py +179,Analytics,Analytics
-apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25,Cart is Empty,Košarica je Prazna
-DocType: Vehicle,Model,Model
-DocType: Production Order,Actual Operating Cost,Dejanski operacijski stroškov
-DocType: Payment Entry,Cheque/Reference No,Ček / referenčna številka
-DocType: Soil Texture,Clay Loam,Clay Loam
-apps/erpnext/erpnext/accounts/doctype/account/account.py +81,Root cannot be edited.,Root ni mogoče urejati.
-DocType: Item,Units of Measure,Merske enote
-DocType: Manufacturing Settings,Allow Production on Holidays,Dovoli Proizvodnja na počitnicah
-DocType: Sales Invoice,Customer's Purchase Order Date,Stranke Naročilo Datum
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163,Capital Stock,Osnovni kapital
-DocType: Shopping Cart Settings,Show Public Attachments,Prikaži Javna Priključki
-DocType: Packing Slip,Package Weight Details,Paket Teža Podrobnosti
-DocType: Restaurant Reservation,Reservation Time,Čas rezervacije
-DocType: Payment Gateway Account,Payment Gateway Account,Plačilo Gateway račun
-DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Po zaključku plačila preusmeri uporabnika na izbrano stran.
-DocType: Company,Existing Company,obstoječa podjetja
-DocType: Healthcare Settings,Result Emailed,Rezultati so poslani
-apps/erpnext/erpnext/controllers/buying_controller.py +87,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Davčna kategorija se je spremenila v &quot;Skupaj&quot;, ker so vsi artikli, ki niso zalogi"
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103,Please select a csv file,Izberite csv datoteko
-DocType: Student Leave Application,Mark as Present,Označi kot Present
-DocType: Supplier Scorecard,Indicator Color,Barva indikatorja
-DocType: Purchase Order,To Receive and Bill,Za prejemanje in Bill
-apps/erpnext/erpnext/controllers/buying_controller.py +455,Row #{0}: Reqd by Date cannot be before Transaction Date,Vrstica # {0}: Reqd po datumu ne more biti pred datumom transakcije
-apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,Izbrani izdelki
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136,Designer,Oblikovalec
-apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Pogoji Template
-DocType: Serial No,Delivery Details,Dostava Podrobnosti
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +495,Cost Center is required in row {0} in Taxes table for type {1},"Stroškov Center, je potrebno v vrstici {0} v Davki miza za tip {1}"
-DocType: Program,Program Code,Program Code
-DocType: Terms and Conditions,Terms and Conditions Help,Pogoji Pomoč
-,Item-wise Purchase Register,Element-pametno Nakup Registriraj se
-DocType: Driver,Expiry Date,Rok uporabnosti
-DocType: Healthcare Settings,Employee name and designation in print,Ime in oznaka zaposlenega v tiskani obliki
-,accounts-browser,računi brskalnik
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368,Please select Category first,"Prosimo, izberite kategorijo najprej"
-apps/erpnext/erpnext/config/projects.py +13,Project master.,Master projekt.
-apps/erpnext/erpnext/controllers/status_updater.py +209,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.","Če želite, da pretirano zaračunavanje ali over-naročanje, posodobi &quot;dodatku&quot; v delniških nastavitvah ali točko."
-DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,"Ne kažejo vsak simbol, kot $ itd zraven valute."
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +431, (Half Day),(Poldnevni)
-DocType: Payment Term,Credit Days,Kreditne dnevi
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +145,Please select Patient to get Lab Tests,"Prosimo, izberite Patient, da dobite laboratorijske teste"
-apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Naj Student Batch
-DocType: Fee Schedule,FRQ.,FRQ.
-DocType: Leave Type,Is Carry Forward,Se Carry Forward
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +841,Get Items from BOM,Pridobi artikle iz BOM
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Dobavni rok dni
-DocType: Cash Flow Mapping,Is Income Tax Expense,Ali je prihodek od davka na dohodek
-apps/erpnext/erpnext/controllers/accounts_controller.py +620,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Row # {0}: Napotitev Datum mora biti enak datumu nakupa {1} od sredstva {2}
-DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,"Označite to, če je študent s stalnim prebivališčem v Hostel inštituta."
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125,Please enter Sales Orders in the above table,Vnesite Prodajne nalogov v zgornji tabeli
-,Stock Summary,Stock Povzetek
-apps/erpnext/erpnext/config/assets.py +54,Transfer an asset from one warehouse to another,Prenese sredstva iz enega skladišča v drugo
-DocType: Vehicle,Petrol,Petrol
-apps/erpnext/erpnext/config/learn.py +217,Bill of Materials,Kosovnica
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Vrstica {0}: Vrsta stranka in stranka je potrebna za terjatve / obveznosti račun {1}
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94,Ref Date,Ref Datum
-DocType: Employee,Reason for Leaving,Razlog za odhod
-DocType: BOM Operation,Operating Cost(Company Currency),Obratovalni stroški (družba Valuta)
-DocType: Employee Loan Application,Rate of Interest,Obrestna mera
-DocType: Expense Claim Detail,Sanctioned Amount,Sankcionirano Znesek
-DocType: Item,Shelf Life In Days,Rok uporabe v dnevih
-DocType: GL Entry,Is Opening,Je Odpiranje
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196,Row {0}: Debit entry can not be linked with a {1},Vrstica {0}: debetna vnos ne more biti povezano z {1}
-DocType: Journal Entry,Subscription Section,Naročniška sekcija
-apps/erpnext/erpnext/accounts/doctype/account/account.py +177,Account {0} does not exist,Račun {0} ne obstaja
-DocType: Training Event,Training Program,Program usposabljanja
-DocType: Account,Cash,Gotovina
-DocType: Employee,Short biography for website and other publications.,Kratka biografija za spletne strani in drugih publikacij.
+b'DocType: Employee',b'Salary Mode',b'Na\xc4\x8din pla\xc4\x8de'
+b'DocType: Patient',b'Divorced',b'Lo\xc4\x8den'
+b'DocType: Buying Settings',b'Allow Item to be added multiple times in a transaction',b'Dovoli da se artikel ve\xc4\x8dkrat  doda v transakciji.'
+b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33',b'Cancel Material Visit {0} before cancelling this Warranty Claim',b'Opusti Material obisk {0} pred preklicem te garancije'
+b'apps/erpnext/erpnext/config/education.py +118',b'Assessment Reports',b'Poro\xc4\x8dila o oceni'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19',b'Consumer Products',b'Consumer Products'
+b'DocType: Purchase Receipt',b'Subscription Detail',b'Podrobnosti o naro\xc4\x8dnini'
+b'DocType: Supplier Scorecard',b'Notify Supplier',b'Obvesti dobavitelja'
+b'DocType: Item',b'Customer Items',b'Artikli stranke'
+b'DocType: Project',b'Costing and Billing',b'Obra\xc4\x8dunavanje stro\xc5\xa1kov in pla\xc4\x8devanja'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +48',b'Account {0}: Parent account {1} can not be a ledger',b'Ra\xc4\x8dun {0}: Mati\xc4\x8dni ra\xc4\x8dun {1} ne more biti Glavna knjiga'
+b'DocType: Item',b'Publish Item to hub.erpnext.com',b'Objavite element na hub.erpnext.com'
+b'apps/erpnext/erpnext/config/setup.py +88',b'Email Notifications',b'E-po\xc5\xa1tna obvestila'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26',b'Evaluation',b'vrednotenje'
+b'DocType: Item',b'Default Unit of Measure',b'Privzeto mersko enoto'
+b'DocType: SMS Center',b'All Sales Partner Contact',b'Vse Sales Partner Kontakt'
+b'DocType: Employee',b'Leave Approvers',b'Pustite Approvers'
+b'DocType: Sales Partner',b'Dealer',b'Trgovec'
+b'DocType: Work Order',b'WO-',b'WO-'
+b'DocType: Consultation',b'Investigations',b'Preiskave'
+b'DocType: Restaurant Order Entry',b'Click Enter To Add',b'Kliknite Enter za dodajanje'
+b'DocType: Employee',b'Rented',b'Najemu'
+b'DocType: Purchase Order',b'PO-',b'po-'
+b'DocType: Vehicle Service',b'Mileage',b'Kilometrina'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +253',b'Do you really want to scrap this asset?',"b'Ali res \xc5\xbeelite, da ostanki ta sredstva?'"
+b'DocType: Drug Prescription',b'Update Schedule',b'Posodobi urnik'
+b'apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44',b'Select Default Supplier',b'Izberite Privzeta Dobavitelj'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37',b'Currency is required for Price List {0}',b'Valuta je potrebna za te\xc4\x8dajnico {0}'
+b'DocType: Sales Taxes and Charges Template',b'* Will be calculated in the transaction.',b'* Bo izra\xc4\x8dunano v transakciji.'
+b'DocType: Purchase Order',b'Customer Contact',b'Stranka Kontakt'
+b'DocType: Patient Appointment',b'Check availability',b'Preveri razpolo\xc5\xbeljivost'
+b'DocType: Job Applicant',b'Job Applicant',b'Job Predlagatelj'
+b'apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6',b'This is based on transactions against this Supplier. See timeline below for details',b'Ta temelji na transakcijah proti temu dobavitelju. Oglejte si \xc4\x8dasovnico spodaj za podrobnosti'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120',b'Legal',b'Pravna'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191',b'Actual type tax cannot be included in Item rate in row {0}',b'Dejanska dav\xc4\x8dna vrsta ne more biti vklju\xc4\x8den v ceno postavko v vrstici {0}'
+b'DocType: Bank Guarantee',b'Customer',b'Stranka'
+b'DocType: Purchase Receipt Item',b'Required By',b'Zahtevani Z'
+b'DocType: Delivery Note',b'Return Against Delivery Note',b'Vrni Proti dobavnica'
+b'DocType: Purchase Order',b'% Billed',b'% zara\xc4\x8dunano'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43',b'Exchange Rate must be same as {0} {1} ({2})',b'Menjalni te\xc4\x8daj mora biti enaka kot {0} {1} ({2})'
+b'DocType: Sales Invoice',b'Customer Name',b'Ime stranke'
+b'DocType: Vehicle',b'Natural Gas',b'Zemeljski plin'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64',b'Bank account cannot be named as {0}',b'Ban\xc4\x8dni ra\xc4\x8dun ne more biti imenovan kot {0}'
+b'DocType: Account',b'Heads (or groups) against which Accounting Entries are made and balances are maintained.',b'Glave (ali skupine) po katerih so narejene vknji\xc5\xbebe in se ohranjajo bilance.'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196',b'Outstanding for {0} cannot be less than zero ({1})',b'Izjemna za {0} ne more biti manj\xc5\xa1a od ni\xc4\x8d ({1})'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +348',b'There are no submitted Salary Slips to process.',b'Za obdelavo ni predlo\xc5\xbeenih pla\xc4\x8dljivih listi\xc4\x8dev.'
+b'DocType: Manufacturing Settings',b'Default 10 mins',b'Privzeto 10 minut'
+b'DocType: Leave Type',b'Leave Type Name',b'Pustite Tip Ime'
+b'apps/erpnext/erpnext/templates/pages/projects.js +62',b'Show open',b'Prika\xc5\xbei odprte'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8',b'It is necessary to take this action today itself for the above mentioned recurring',b'To akcijo je treba sprejeti sam danes za zgoraj omenjeno ponavljajo\xc4\x8de se obdobje'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +156',b'Series Updated Successfully',b'Zaporedje uspe\xc5\xa1no posodobljeno'
+b'apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6',b'Checkout',b'Naro\xc4\x8dilo'
+b'DocType: Pricing Rule',b'Apply On',b'Nanesite na'
+b'DocType: Item Price',b'Multiple Item prices.',b'Ve\xc4\x8d cene postavko.'
+,b'Purchase Order Items To Be Received',b'Naro\xc4\x8dilnica Postavke da bodo prejete'
+b'DocType: SMS Center',b'All Supplier Contact',b'Vse Dobavitelj Kontakt'
+b'DocType: Support Settings',b'Support Settings',b'Nastavitve podpora'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +75',b'Expected End Date can not be less than Expected Start Date',b'Pri\xc4\x8dakuje Kon\xc4\x8dni datum ne more biti manj\xc5\xa1i od pri\xc4\x8dakovanega za\xc4\x8detka Datum'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +121',b'Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ',b'Vrstica # {0}: Stopnja mora biti enaka kot {1}: {2} ({3} / {4})'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +241',b'New Leave Application',b'New Leave Application'
+,b'Batch Item Expiry Status',b'Serija To\xc4\x8dka preteka Status'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184',b'Bank Draft',b'Bank Osnutek'
+b'DocType: Membership',b'membership validaty section',b'\xc4\x8dlanstvo veljaven oddelek'
+b'DocType: Mode of Payment Account',b'Mode of Payment Account',b'Na\xc4\x8din pla\xc4\x8dilnega ra\xc4\x8duna'
+b'DocType: Consultation',b'Consultation',b'Posvetovanje'
+b'DocType: Accounts Settings',b'Show Payment Schedule in Print',b'Prika\xc5\xbei \xc4\x8das pla\xc4\x8dila v tisku'
+b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19',b'Sales and Returns',b'Prodaja in vrnitev'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +56',b'Show Variants',b'Prika\xc5\xbei Variante'
+b'DocType: Academic Term',b'Academic Term',b'Academic Term'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14',b'Material',b'Material'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66',b'Making website',b'Izdelava spletne strani'
+b'DocType: Opening Invoice Creation Tool Item',b'Quantity',b'Koli\xc4\x8dina'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546',b'Accounts table cannot be blank.',b'Predstavlja tabela ne more biti prazno.'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154',b'Loans (Liabilities)',b'Posojili (obveznosti)'
+b'DocType: Employee Education',b'Year of Passing',"b'Leto, ki poteka'"
+b'DocType: Item',b'Country of Origin',b'Dr\xc5\xbeava izvora'
+b'DocType: Soil Texture',b'Soil Texture Criteria',b'Kriteriji za teksturo tal'
+b'apps/erpnext/erpnext/templates/includes/product_page.js +25',b'In Stock',b'Na zalogi'
+b'apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16',b'Primary Contact Details',b'Primarni kontaktni podatki'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46',b'Open Issues',b'odprta vpra\xc5\xa1anja'
+b'DocType: Production Plan Item',b'Production Plan Item',b'Proizvodni na\xc4\x8drt Postavka'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +149',b'User {0} is already assigned to Employee {1}',b'Uporabnik {0} je \xc5\xbee dodeljen Employee {1}'
+b'DocType: Lab Test Groups',b'Add new line',b'Dodaj novo vrstico'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31',b'Health Care',b'Zdravstvo'
+b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65',b'Delay in payment (Days)',b'Zamuda pri pla\xc4\x8dilu (dnevi)'
+b'DocType: Payment Terms Template Detail',b'Payment Terms Template Detail',b'Podrobnosti o predlogi za pla\xc4\x8dila'
+b'DocType: Hotel Room Reservation',b'Guest Name',b'Ime gosta'
+b'DocType: Lab Prescription',b'Lab Prescription',b'Laboratorijski recept'
+,b'Delay Days',b'Dnevi zamude'
+b'apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26',b'Service Expense',b'Service Expense'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +899',b'Serial Number: {0} is already referenced in Sales Invoice: {1}',b'Serijska \xc5\xa1tevilka: {0} \xc5\xbee naveden v prodajne fakture: {1}'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +889',b'Invoice',b'Ra\xc4\x8dun'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +145',b'Make Retention Stock Entry',b'Naredite zadr\xc5\xbeevalni zalogi'
+b'DocType: Purchase Invoice Item',b'Item Weight Details',b'Element Te\xc5\xbea Podrobnosti'
+b'DocType: Asset Maintenance Log',b'Periodicity',b'Periodi\xc4\x8dnost'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21',b'Fiscal Year {0} is required',b'Poslovno leto {0} je potrebno'
+b'DocType: Crop Cycle',b'The minimum distance between rows of plants for optimum growth',b'Najmanj\xc5\xa1a razdalja med vrstami rastlin za optimalno rast'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21',b'Defense',b'Obramba'
+b'DocType: Salary Component',b'Abbr',b'Abbr'
+b'DocType: Appraisal Goal',b'Score (0-5)',b'Ocena (0-5)'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +225',b'Row {0}: {1} {2} does not match with {3}',b'Vrstica {0}: {1} {2} ne ujema s {3}'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +77',b'Row # {0}:',b'Vrstica # {0}:'
+b'DocType: Timesheet',b'Total Costing Amount',b'Skupaj Stanejo Znesek'
+b'DocType: Delivery Note',b'Vehicle No',b'Nobeno vozilo'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +163',b'Please select Price List',b'Izberite Cenik'
+b'DocType: Accounts Settings',b'Currency Exchange Settings',b'Nastavitve menjave valut'
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +94',b'Row #{0}: Payment document is required to complete the trasaction',b'Vrstica # {0}: Pla\xc4\x8dilo dokument je potreben za dokon\xc4\x8danje trasaction'
+b'DocType: Work Order Operation',b'Work In Progress',b'V razvoju'
+b'apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13',b'Please select date',b'Izberite datum'
+b'DocType: Daily Work Summary Group',b'Holiday List',b'Seznam praznikov'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88',b'Please setup numbering series for Attendance via Setup &gt; Numbering Series',"b'Prosimo, nastavite \xc5\xa1tevilske serije za udele\xc5\xbebo preko Setup&gt; Series Numbering'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127',b'Accountant',b'Ra\xc4\x8dunovodja'
+b'DocType: Hub Settings',b'Selling Price List',b'Prodajni cenik'
+b'DocType: Patient',b'Tobacco Current Use',b'Trenutna uporaba tobaka'
+b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +56',b'Selling Rate',b'Prodajna cena'
+b'DocType: Cost Center',b'Stock User',b'Stock Uporabnik'
+b'DocType: Soil Analysis',b'(Ca+Mg)/K',b'(Ca+Mg)/K'
+b'DocType: Company',b'Phone No',b'Telefon'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +239',b'New {0}: #{1}',b'Nov {0}: # {1}'
+b'DocType: Delivery Trip',b'Initial Email Notification Sent',b'Poslano je poslano obvestilo o e-po\xc5\xa1ti'
+,b'Sales Partners Commission',b'Partnerji Sales Komisija'
+b'DocType: Soil Texture',b'Sandy Clay Loam',b'Sandy Clay Loam'
+b'DocType: Purchase Invoice',b'Rounding Adjustment',b'Prilagajanje zaokro\xc5\xbeevanja'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +46',b'Abbreviation cannot have more than 5 characters',b'Kratica ne more imeti ve\xc4\x8d kot 5 znakov'
+b'DocType: Physician Schedule Time Slot',b'Physician Schedule Time Slot',b'\xc4\x8casovni razpored zdravnika'
+b'DocType: Payment Request',b'Payment Request',b'Pla\xc4\x8dilni Nalog'
+b'DocType: Asset',b'Value After Depreciation',b'Vrednost po amortizaciji'
+b'DocType: Student',b'O+',b'O +'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8',b'Related',b'Podobni'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43',"b""Attendance date can not be less than employee's joining date""",b'Datum udele\xc5\xbeba ne sme biti manj\xc5\xa1a od povezuje datumu zaposlenega'
+b'DocType: Grading Scale',b'Grading Scale Name',b'Ocenjevalna lestvica Ime'
+b'DocType: Subscription',b'Repeat on Day',b'Ponovi na dan'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +41',b'This is a root account and cannot be edited.',b'To je ra\xc4\x8dun root in jih ni mogo\xc4\x8de urejati.'
+b'DocType: Sales Invoice',b'Company Address',b'Naslov podjetja'
+b'DocType: BOM',b'Operations',b'Operacije'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38',b'Cannot set authorization on basis of Discount for {0}',b'Ni mogo\xc4\x8de nastaviti dovoljenja na podlagi popust za {0}'
+b'DocType: Rename Tool',"b'Attach .csv file with two columns, one for the old name and one for the new name'","b'Pripni datoteko .csv z dvema stolpcema, eno za staro ime in enega za novim imenom'"
+b'apps/erpnext/erpnext/accounts/utils.py +73',b'{0} {1} not in any active Fiscal Year.',b'{0} {1} ni v nobenem poslovnem letu'
+b'DocType: Packed Item',b'Parent Detail docname',b'Parent Detail docname'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69',"b'Reference: {0}, Item Code: {1} and Customer: {2}'",b'Referenca: {0} Oznaka: {1} in stranke: {2}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Kg',b'Kg'
+b'apps/erpnext/erpnext/config/hr.py +45',b'Opening for a Job.',b'Odpiranje za slu\xc5\xbebo.'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +114',b'BOM is not specified for subcontracting item {0} at row {1}',b'BOM ni dolo\xc4\x8den za podizvajalsko postavko {0} v vrstici {1}'
+b'apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149',b'{0} Result submittted',b'{0} vlo\xc5\xbeeno'
+b'DocType: Item Attribute',b'Increment',b'Prirastek'
+b'apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74',b'Timespan',b'\xc4\x8casovni razpon'
+b'apps/erpnext/erpnext/public/js/stock_analytics.js +58',b'Select Warehouse...',b'Izberite Skladi\xc5\xa1\xc4\x8de ...'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6',b'Advertising',b'Ogla\xc5\xa1evanje'
+b'apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22',b'Same Company is entered more than once',b'Ista dru\xc5\xbeba je vpisana ve\xc4\x8d kot enkrat'
+b'DocType: Patient',b'Married',b'Poro\xc4\x8den'
+b'apps/erpnext/erpnext/accounts/party.py +41',b'Not permitted for {0}',b'Ni dovoljeno za {0}'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593',b'Get items from',b'Pridobi artikle iz'
+b'DocType: Price List',b'Price Not UOM Dependant',b'Cena ni odvisna od UOM'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +467',b'Stock cannot be updated against Delivery Note {0}',b'Stock ni mogo\xc4\x8de posodobiti proti dobavnica {0}'
+b'apps/erpnext/erpnext/templates/pages/home.py +25',b'Product {0}',b'Izdelek {0}'
+b'apps/erpnext/erpnext/templates/generators/item_group.html +43',b'No items listed',"b'Ni elementov, navedenih'"
+b'DocType: Asset Repair',b'Error Description',b'Opis napake'
+b'DocType: Payment Reconciliation',b'Reconcile',b'Uskladitev'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30',b'Grocery',b'Trgovina z \xc5\xbeivili'
+b'DocType: Quality Inspection Reading',b'Reading 1',b'Branje 1'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40',b'Pension Funds',b'Pokojninski skladi'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +91',b'Next Depreciation Date cannot be before Purchase Date',b'Naslednja Amortizacija datum ne more biti pred Nakup Datum'
+b'DocType: Crop',b'Perennial',b'Trajen'
+b'DocType: Consultation',b'Consultation Date',b'Datum posvetovanja'
+b'DocType: Accounts Settings',b'Use Custom Cash Flow Format',b'Uporabite obliko prilagojenega denarnega toka'
+b'DocType: SMS Center',b'All Sales Person',b'Vse Sales oseba'
+b'DocType: Monthly Distribution',b'**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.',"b'**Mese\xc4\x8dna razporeditev** vam pomaga razporejati prora\xc4\x8dun/cilje po mesecih, \xc4\x8de imate sezonskost v va\xc5\xa1i dejavnosti.'"
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1753',b'Not items found',b'Ni najdenih predmetov'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +184',b'Salary Structure Missing',b'Pla\xc4\x8da Struktura Missing'
+b'DocType: Lead',b'Person Name',b'Ime oseba'
+b'DocType: Sales Invoice Item',b'Sales Invoice Item',b'Artikel na ra\xc4\x8dunu'
+b'DocType: Account',b'Credit',b'Credit'
+b'DocType: POS Profile',b'Write Off Cost Center',b'Napi\xc5\xa1ite Off stro\xc5\xa1kovni center'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +117',"b'e.g. ""Primary School"" or ""University""'",b'npr &quot;Osnovna \xc5\xa1ola&quot; ali &quot;University&quot;'
+b'apps/erpnext/erpnext/config/stock.py +28',b'Stock Reports',b'Poro\xc4\x8dila o zalogi'
+b'DocType: Warehouse',b'Warehouse Detail',b'Skladi\xc5\xa1\xc4\x8de Detail'
+b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33',b'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.',"b'Izraz Kon\xc4\x8dni datum ne more biti najpozneje do leta End Datum \xc5\xa1tudijskem letu, v katerem je izraz povezan (\xc5\xa1tudijsko leto {}). Popravite datum in poskusite znova.'"
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +269',"b'""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item'","b'""Ali je osnovno sredstvo"" ne more biti neizbrano, saj obstaja evidenca sredstev po postavki'"
+b'DocType: Delivery Trip',b'Departure Time',b'\xc4\x8cas odhoda'
+b'DocType: Vehicle Service',b'Brake Oil',b'Zavorna olja'
+b'DocType: Tax Rule',b'Tax Type',b'Dav\xc4\x8dna Type'
+,b'Completed Work Orders',b'Dokon\xc4\x8dana delovna naro\xc4\x8dila'
+b'apps/erpnext/erpnext/controllers/taxes_and_totals.py +581',b'Taxable Amount',b'Dav\xc4\x8dna osnova'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160',b'You are not authorized to add or update entries before {0}',b'Nimate dovoljenja za dodajanje ali posodobitev vnose pred {0}'
+b'DocType: BOM',b'Item Image (if not slideshow)',b'Postavka Image (\xc4\x8de ne slideshow)'
+b'DocType: Work Order Operation',b'(Hour Rate / 60) * Actual Operation Time',b'(Urna postavka / 60) * Dejanski  \xc4\x8das operacije'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1103',b'Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry',b'Vrstica # {0}: Referen\xc4\x8dni dokument mora biti eden od zahtevkov za stro\xc5\xa1ke ali vpisa v dnevnik'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +975',b'Select BOM',b'Izberite BOM'
+b'DocType: SMS Log',b'SMS Log',b'SMS Log'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27',b'Cost of Delivered Items',b'Nabavna vrednost dobavljenega predmeta'
+b'apps/erpnext/erpnext/config/hr.py +127',b'Manage advance amount given to the Employee',"b'Upravljajte znesek vnaprej, ki ga dobite zaposleni'"
+b'apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38',b'The holiday on {0} is not between From Date and To Date',"b'Praznik na {0} ni med Od datuma, do sedaj'"
+b'DocType: Student Log',b'Student Log',b'\xc5\xa1tudent Log'
+b'apps/erpnext/erpnext/config/buying.py +165',b'Templates of supplier standings.',b'Predloge dobaviteljevega polo\xc5\xbeaja.'
+b'DocType: Lead',b'Interested',b'Zanima'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +216',b'Opening',b'Otvoritev'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32',b'From {0} to {1}',b'Od {0} do {1}'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +234',b'Program: ',b'Program:'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50',b'Failed to setup taxes',b'Nastavitev davkov ni uspela'
+b'DocType: Item',b'Copy From Item Group',b'Kopiranje iz postavke skupine'
+b'DocType: Delivery Trip',b'Delivery Notification',b'Obvestilo o dostavi'
+b'DocType: Journal Entry',b'Opening Entry',b'Otvoritev Za\xc4\x8detek'
+b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25',b'Account Pay Only',b'Ra\xc4\x8dun Pay samo'
+b'DocType: Employee Loan',b'Repay Over Number of Periods',b'Odpla\xc4\x8dilo Over \xc5\xa1tevilo obdobij'
+b'DocType: Stock Entry',b'Additional Costs',b'Dodatni stro\xc5\xa1ki'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +138',b'Account with existing transaction can not be converted to group.',b'Ra\xc4\x8dun z obstoje\xc4\x8dim poslom ni mogo\xc4\x8de pretvoriti v skupini.'
+b'DocType: Lead',b'Product Enquiry',b'Povpra\xc5\xa1evanje izdelek'
+b'DocType: Education Settings',b'Validate Batch for Students in Student Group',b'Potrdite Batch za \xc5\xa1tudente v \xc5\xa1tudentskih skupine'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35',b'No leave record found for employee {0} for {1}',b'\xc5\xa0t odsotnost zapisa dalo za delavca {0} za {1}'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23',b'Please enter company first',"b'Prosimo, da najprej vnesete podjetje'"
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +365',b'Please select Company first',"b'Prosimo, izberite Company najprej'"
+b'DocType: Employee Education',b'Under Graduate',b'Pod Graduate'
+b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27',b'Target On',b'Ciljna Na'
+b'DocType: BOM',b'Total Cost',b'Skupni stro\xc5\xa1ki'
+b'DocType: Soil Analysis',b'Ca/K',b'Ca / K'
+b'DocType: Journal Entry Account',b'Employee Loan',b'zaposlenih Loan'
+b'DocType: Fee Schedule',b'Send Payment Request Email',b'Po\xc5\xa1lji e-po\xc5\xa1to za pla\xc4\x8dilni zahtevek'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +268',b'Item {0} does not exist in the system or has expired',b'Element {0} ne obstaja v sistemu ali je potekla'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44',b'Real Estate',b'Nepremi\xc4\x8dnina'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1',b'Statement of Account',b'Izkaz ra\xc4\x8duna'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41',b'Pharmaceuticals',b'Farmacevtski izdelki'
+b'DocType: Purchase Invoice Item',b'Is Fixed Asset',b'Je osnovno sredstvo'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +273',"b'Available qty is {0}, you need {1}'","b'Preberi je {0}, morate {1}'"
+b'DocType: Expense Claim Detail',b'Claim Amount',b'Trditev Znesek'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +653',b'Work Order has been {0}',b'Delovni nalog je bil {0}'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56',b'Duplicate customer group found in the cutomer group table',b'Dvojnik skupina kupcev so v tabeli cutomer skupine'
+b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31',b'Supplier Type / Supplier',b'Dobavitelj Vrsta / dobavitelj'
+b'DocType: Naming Series',b'Prefix',b'Predpona'
+b'apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7',b'Event Location',b'Lokacija dogodka'
+b'DocType: Asset Settings',b'Asset Settings',b'Nastavitve sredstva'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68',b'Consumable',b'Potro\xc5\xa1ni'
+b'DocType: Student',b'B-',b'B-'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +98',b'Successfully unregistered.',b'Uspe\xc5\xa1no neregistriran.'
+b'DocType: Assessment Result',b'Grade',b'razred'
+b'DocType: Restaurant Table',b'No of Seats',b'\xc5\xa0tevilo sede\xc5\xbeev'
+b'DocType: Subscription',"b'To add dynamic subject, use jinja tags like\n\n<div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>'","b'\xc4\x8ce \xc5\xbeelite dodati dinami\xc4\x8dni predmet, uporabite oznake z oznako <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>'"
+b'DocType: Sales Invoice Item',b'Delivered By Supplier',b'Delivered dobavitelj'
+b'DocType: Asset Maintenance Task',b'Asset Maintenance Task',b'Naloga vzdr\xc5\xbeevanja sredstev'
+b'DocType: SMS Center',b'All Contact',b'Vse Kontakt'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232',b'Annual Salary',b'Letne pla\xc4\x8de'
+b'DocType: Daily Work Summary',b'Daily Work Summary',b'Dnevni Delo Povzetek'
+b'DocType: Period Closing Voucher',b'Closing Fiscal Year',b'Zapiranje poslovno leto'
+b'apps/erpnext/erpnext/accounts/party.py +392',b'{0} {1} is frozen',b'{0} {1} je zamrznjeno'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +140',b'Please select Existing Company for creating Chart of Accounts',b'Izberite obstoje\xc4\x8do dru\xc5\xbebo za ustvarjanje kontnem na\xc4\x8drtu'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80',b'Stock Expenses',b'Zaloga Stro\xc5\xa1ki'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +111',b'Select Target Warehouse',b'Izberite Target Skladi\xc5\xa1\xc4\x8de'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +111',b'Select Target Warehouse',b'Izberite Target Skladi\xc5\xa1\xc4\x8de'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.js +80',b'Please enter Preferred Contact Email',b'Vnesite \xc5\xbdeleni Kontakt Email'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45',b'CompAuxNum',b'CompAuxNum'
+b'DocType: Journal Entry',b'Contra Entry',b'Contra Za\xc4\x8detek'
+b'DocType: Journal Entry Account',b'Credit in Company Currency',b'Kredit v podjetju valuti'
+b'DocType: Lab Test UOM',b'Lab Test UOM',b'Lab Test UOM'
+b'DocType: Delivery Note',b'Installation Status',b'Namestitev Status'
+b'DocType: BOM',b'Quality Inspection Template',b'Obrazec za pregled kakovosti'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135',b'Do you want to update attendance?<br>Present: {0}\\\n\t\t\t\t\t<br>Absent: {1}',b'Ali \xc5\xbeelite posodobiti prisotnost? <br> Sedanje: {0} \\ <br> Odsoten: {1}'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +334',b'Accepted + Rejected Qty must be equal to Received quantity for Item {0}',b'Sprejeta + Zavrnjeno Koli\xc4\x8dina mora biti enaka Prejeto koli\xc4\x8dini za postavko {0}'
+b'DocType: Request for Quotation',b'RFQ-',b'RFQ-'
+b'DocType: Item',b'Supply Raw Materials for Purchase',b'Dobava surovine za nakup'
+b'DocType: Agriculture Analysis Criteria',b'Fertilizer',b'Gnojilo'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +152',b'At least one mode of payment is required for POS invoice.',b'za POS ra\xc4\x8duna je potreben vsaj en na\xc4\x8din pla\xc4\x8dila.'
+b'DocType: Products Settings',b'Show Products as a List',b'Prika\xc5\xbei izdelke na seznamu'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +532',b'Item {0} is not active or end of life has been reached',b'Postavka {0} ni aktiven ali je bil dose\xc5\xbeen konec \xc5\xbeivljenja'
+b'DocType: Student Admission Program',b'Minimum Age',b'Najni\xc5\xbeja starost'
+b'apps/erpnext/erpnext/utilities/user_progress.py +190',b'Example: Basic Mathematics',b'Primer: Osnovna matematika'
+b'DocType: Customer',b'Primary Address',b'Primarni naslov'
+b'DocType: Production Plan',b'Material Request Detail',b'Materialna zahteva Podrobnosti'
+b'DocType: Selling Settings',b'Default Quotation Validity Days',b'Privzeti dnevi veljavnosti ponudbe'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +800',"b'To include tax in row {0} in Item rate, taxes in rows {1} must also be included'","b'Da vklju\xc4\x8dujejo davek v vrstici {0} v stopnji Element, davki v vrsticah {1} je treba vklju\xc4\x8diti tudi'"
+b'apps/erpnext/erpnext/config/hr.py +223',b'Settings for HR Module',b'Nastavitve za HR modula'
+b'DocType: SMS Center',b'SMS Center',b'SMS center'
+b'DocType: Sales Invoice',b'Change Amount',b'Znesek spremembe'
+b'DocType: GST Settings',b'Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.',"b'Nastavite vrednost ra\xc4\x8duna za B2C. B2CL in B2CS, izra\xc4\x8dunano na podlagi te fakture.'"
+b'DocType: BOM Update Tool',b'New BOM',b'New BOM'
+b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36',b'Show only POS',b'Prika\xc5\xbei samo POS'
+b'DocType: Driver',b'Driving License Categories',b'Kategorije vozni\xc5\xa1kih dovoljenj'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118',b'Please enter Delivery Date',b'Vnesite datum dostave'
+b'DocType: Depreciation Schedule',b'Make Depreciation Entry',b'Naj Amortizacija Za\xc4\x8detek'
+b'DocType: Appraisal Template Goal',b'KRA',b'KRA'
+b'DocType: Lead',b'Request Type',b'Zahteva Type'
+b'apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +17',b'Make Employee',b'Naj Zaposleni'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14',b'Broadcasting',b'Broadcasting'
+b'apps/erpnext/erpnext/config/accounts.py +313',b'Setup mode of POS (Online / Offline)',b'Na\xc4\x8din nastavitve POS (Online / Offline)'
+b'DocType: Manufacturing Settings',b'Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order',b'Onemogo\xc4\x8di ustvarjanje \xc4\x8dasovnih dnevnikov z delovnimi nalogi. Operacijam se ne sme slediti delovnemu nalogu'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191',b'Execution',b'Izvedba'
+b'apps/erpnext/erpnext/config/manufacturing.py +62',b'Details of the operations carried out.',b'Podrobnosti o poslovanju izvajajo.'
+b'DocType: Asset Maintenance Log',b'Maintenance Status',b'Status vzdr\xc5\xbeevanje'
+b'apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10',b'Membership Details',b'Podrobnosti o \xc4\x8dlanstvu'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56',b'{0} {1}: Supplier is required against Payable account {2}',b'{0} {1}: zahtevan je Dobavitelj za ra\xc4\x8dun izdatkov {2}'
+b'apps/erpnext/erpnext/config/selling.py +52',b'Items and Pricing',b'Predmeti in Pricing'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2',b'Total hours: {0}',b'Skupno \xc5\xa1tevilo ur: {0}'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43',b'From Date should be within the Fiscal Year. Assuming From Date = {0}',b'Od datuma mora biti v poslovnem letu. Ob predpostavki Od datuma = {0}'
+b'DocType: Drug Prescription',b'Interval',b'Interval'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +253',b'Preference',b'Prednost'
+b'DocType: Grant Application',b'Individual',b'Individualno'
+b'DocType: Academic Term',b'Academics User',b'akademiki Uporabnik'
+b'DocType: Cheque Print Template',b'Amount In Figure',b'Znesek v sliki'
+b'DocType: Employee Loan Application',b'Loan Info',b'posojilo Info'
+b'apps/erpnext/erpnext/config/maintenance.py +12',b'Plan for maintenance visits.',b'Na\xc4\x8drt za vzdr\xc5\xbeevanje obiskov.'
+b'DocType: Supplier Scorecard Period',b'Supplier Scorecard Period',b'Period ocenjevanja dobaviteljev'
+b'DocType: Share Transfer',b'Share Transfer',b'Prenos delnic'
+b'DocType: POS Profile',b'Customer Groups',b'Skupine uporabnikov'
+b'apps/erpnext/erpnext/public/js/financial_statements.js +51',b'Financial Statements',b'Finan\xc4\x8dne izjave'
+b'DocType: Guardian',b'Students',b'\xc5\xa1tudenti'
+b'apps/erpnext/erpnext/config/selling.py +91',b'Rules for applying pricing and discount.',b'Pravila za uporabo cene in popust.'
+b'DocType: Daily Work Summary',b'Daily Work Summary Group',b'Skupina dnevnih del'
+b'DocType: Physician Schedule',b'Time Slots',b'\xc4\x8casovne re\xc5\xbee'
+b'apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14',b'Price List must be applicable for Buying or Selling',b'Cenik mora biti primerno za nakup ali prodajo'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79',b'Installation date cannot be before delivery date for Item {0}',b'Datum namestitve ne more biti pred datumom dostave za postavko {0}'
+b'DocType: Pricing Rule',b'Discount on Price List Rate (%)',b'Popust na ceno iz cenika Stopnja (%)'
+b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112',b'Item Template',b'Predloga postavke'
+b'apps/erpnext/erpnext/healthcare/setup.py +215',b'Biochemistry',b'Biokemija'
+b'DocType: Job Offer',b'Select Terms and Conditions',b'Izberite Pogoji'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72',b'Out Value',b'iz Vrednost'
+b'DocType: Production Plan',b'Sales Orders',b'Naro\xc4\x8dila Kupcev'
+b'DocType: Purchase Taxes and Charges',b'Valuation',b'Vrednotenje'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +390',b'Set as Default',b'Nastavi kot privzeto'
+b'DocType: Production Plan',b'PLN-',b'PLN-'
+,b'Purchase Order Trends',b'Naro\xc4\x8dilnica Trendi'
+b'apps/erpnext/erpnext/utilities/user_progress.py +78',b'Go to Customers',b'Pojdi na stranke'
+b'DocType: Hotel Room Reservation',b'Late Checkin',b'Pozno preverjanje'
+b'apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7',b'The request for quotation can be accessed by clicking on the following link',b'Zahteva za ponudbo lahko dostopate s klikom na spodnjo povezavo'
+b'apps/erpnext/erpnext/config/hr.py +81',b'Allocate leaves for the year.',b'Dodeli liste za leto.'
+b'DocType: SG Creation Tool Course',b'SG Creation Tool Course',b'SG ustvarjanja orodje za golf'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +275',b'Insufficient Stock',b'nezadostna Stock'
+b'DocType: Manufacturing Settings',b'Disable Capacity Planning and Time Tracking',b'Onemogo\xc4\x8di Capacity Planning and Time Tracking'
+b'DocType: Email Digest',b'New Sales Orders',b'Novi prodajni nalogi'
+b'DocType: Bank Guarantee',b'Bank Account',b'Ban\xc4\x8dni ra\xc4\x8dun'
+b'DocType: Leave Type',b'Allow Negative Balance',b'Dovoli negativni saldo'
+b'apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13',"b""You cannot delete Project Type 'External'""",b'Ne morete izbrisati vrste projekta &quot;Zunanji&quot;'
+b'DocType: Employee',b'Create User',b'Ustvari uporabnika'
+b'DocType: Selling Settings',b'Default Territory',b'Privzeto Territory'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53',b'Television',b'Televizija'
+b'DocType: Work Order Operation',"b""Updated via 'Time Log'""",b'Posodobljeno preko &quot;\xc4\x8cas Logu&quot;'
+b'apps/erpnext/erpnext/controllers/taxes_and_totals.py +430',b'Advance amount cannot be greater than {0} {1}',b'Advance znesek ne sme biti ve\xc4\x8dja od {0} {1}'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42',b'JournalCode',b'JournalCode'
+b'DocType: Naming Series',b'Series List for this Transaction',b'Seznam zaporedij za to transakcijo'
+b'DocType: Company',b'Enable Perpetual Inventory',b'Omogo\xc4\x8di nepretrganega popisovanja'
+b'DocType: Company',b'Default Payroll Payable Account',b'Privzeto Pla\xc4\x8de pla\xc4\x8dljivo ra\xc4\x8dun'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51',b'Update Email Group',b'Posodobitev e-Group'
+b'DocType: Sales Invoice',b'Is Opening Entry',b'Je vstopna odprtina'
+b'DocType: Lab Test Template',"b'If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. '","b'\xc4\x8ce ni ozna\xc4\x8deno, element ne bo prikazan v ra\xc4\x8dunu za prodajo, temve\xc4\x8d ga lahko uporabite pri ustvarjanju skupinskih testov.'"
+b'DocType: Customer Group',b'Mention if non-standard receivable account applicable',"b'Omemba \xc4\x8de nestandardni terjatve ra\xc4\x8dun, ki se uporablja'"
+b'DocType: Course Schedule',b'Instructor Name',b'in\xc5\xa1truktor Ime'
+b'DocType: Supplier Scorecard',b'Criteria Setup',b'Nastavitev meril'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +206',b'For Warehouse is required before Submit',b'Za skladi\xc5\xa1\xc4\x8de je pred potreben Submit'
+b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8',b'Received On',b'Prejetih Na'
+b'DocType: Sales Partner',b'Reseller',b'Reseller'
+b'DocType: Codification Table',b'Medical Code',b'Zdravstvena koda'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20',b'Please enter Company',b'Vnesite Company'
+b'DocType: Delivery Note Item',b'Against Sales Invoice Item',b'Proti Sales ra\xc4\x8duna Postavka'
+b'DocType: Agriculture Analysis Criteria',b'Linked Doctype',b'Povezani Doctype'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +44',b'Net Cash from Financing',b'Neto denarni tokovi pri financiranju'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2375',"b'LocalStorage is full , did not save'","b'Lokalno shrambo je polna, ni shranil'"
+b'DocType: Lead',b'Address & Contact',b'Naslov in kontakt'
+b'DocType: Leave Allocation',b'Add unused leaves from previous allocations',b'Dodaj neuporabljene liste iz prej\xc5\xa1njih dodelitev'
+b'DocType: Sales Partner',b'Partner website',b'spletna stran partnerja'
+b'DocType: Restaurant Order Entry',b'Add Item',b'Dodaj predmet'
+b'DocType: Lab Test',b'Custom Result',b'Rezultat po meri'
+b'DocType: Delivery Stop',b'Contact Name',b'Kontaktno ime'
+b'DocType: Course Assessment Criteria',b'Course Assessment Criteria',b'Merila ocenjevanja te\xc4\x8daj'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +18',b'Tax Id: ',b'Dav\xc4\x8dna \xc5\xa1tevilka:'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +216',b'Student ID: ',b'\xc5\xa0tudentski ID:'
+b'DocType: POS Customer Group',b'POS Customer Group',b'POS Group stranke'
+b'DocType: Land Unit',b'Land Unit describing various land assets',"b'Land enota, ki opisuje razli\xc4\x8dna zemlji\xc5\xa1\xc4\x8da'"
+b'DocType: Cheque Print Template',b'Line spacing for amount in words',b'Razmik med vrsticami za znesek z besedami'
+b'DocType: Vehicle',b'Additional Details',b'Dodatne podrobnosti'
+b'apps/erpnext/erpnext/templates/generators/bom.html +85',b'No description given',b'Opis ni dana'
+b'apps/erpnext/erpnext/config/buying.py +13',b'Request for purchase.',b'Zaprosi za nakup.'
+b'DocType: Lab Test',b'Submitted Date',b'Datum predlo\xc5\xbeitve'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6',b'This is based on the Time Sheets created against this project',b'Ta temelji na \xc4\x8dasovnih preglednicah ustvarjenih pred tem projektu'
+,b'Open Work Orders',b'Odpiranje delovnih nalogov'
+b'DocType: Payment Term',b'Credit Months',b'Kreditni meseci'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409',b'Net Pay cannot be less than 0',b'Neto pla\xc4\x8da ne sme biti manj\xc5\xa1i od 0'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5',"b'To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription'","b'\xc4\x8ce \xc5\xbeelite prenehati po\xc5\xa1iljati ponavljajo\xc4\x8da obvestila o napakah iz sistema, smo v naro\xc4\x8dnini ozna\xc4\x8dili polje Disabled'"
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +121',b'Relieving Date must be greater than Date of Joining',b'Laj\xc5\xa1anje Datum mora biti ve\xc4\x8dja od Datum pridru\xc5\xbeitve'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +240',b'Leaves per Year',b'Listi na leto'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130',"b""Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.""","b'Vrstica {0}: Prosimo, preverite &quot;Je Advance&quot; proti ra\xc4\x8dun {1}, \xc4\x8de je to predujem vnos.'"
+b'apps/erpnext/erpnext/stock/utils.py +219',b'Warehouse {0} does not belong to company {1}',b'Skladi\xc5\xa1\xc4\x8de {0} ne pripada podjetju {1}'
+b'DocType: Email Digest',b'Profit & Loss',b'Profit &amp; Loss'
+b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Litre',b'Liter'
+b'DocType: Task',b'Total Costing Amount (via Time Sheet)',b'Skupaj Costing Znesek (preko \xc4\x8cas lista)'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +76',b'Please setup Students under Student Groups',"b'Prosimo, nastavite \xc5\xa0tudente v \xc5\xa1tudentskih skupinah'"
+b'DocType: Item Website Specification',b'Item Website Specification',b'Element Spletna stran Specifikacija'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +449',b'Leave Blocked',b'Pustite blokiranih'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +740',b'Item {0} has reached its end of life on {1}',b'Postavka {0} je konec \xc5\xbeivljenja na {1}'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +83',b'Bank Entries',b'ban\xc4\x8dni vnosi'
+b'DocType: Crop',b'Annual',b'Letno'
+b'DocType: Stock Reconciliation Item',b'Stock Reconciliation Item',b'Stock Sprava Postavka'
+b'DocType: Stock Entry',b'Sales Invoice No',b'Prodaja Ra\xc4\x8dun Ne'
+b'DocType: Material Request Item',b'Min Order Qty',b'Min naro\xc4\x8dilo Kol'
+b'DocType: Student Group Creation Tool Course',b'Student Group Creation Tool Course',b'Orodje za oblikovanje \xc5\xa1tudent Group te\xc4\x8daj'
+b'DocType: Lead',b'Do Not Contact',b'Ne Pi\xc5\xa1ite'
+b'apps/erpnext/erpnext/utilities/user_progress.py +210',b'People who teach at your organisation',"b'Ljudje, ki pou\xc4\x8dujejo v va\xc5\xa1i organizaciji'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135',b'Software Developer',b'Razvijalec programske opreme'
+b'DocType: Item',b'Minimum Order Qty',b'Najmanj\xc5\xa1e naro\xc4\x8dilo Kol'
+b'DocType: Pricing Rule',b'Supplier Type',b'Dobavitelj Type'
+b'DocType: Course Scheduling Tool',b'Course Start Date',b'Datum za\xc4\x8detka predmeta'
+,b'Student Batch-Wise Attendance',b'\xc5\xa0tudent \xc5\xa1ar\xc5\xbeno in postre\xc5\xbebo'
+b'DocType: POS Profile',b'Allow user to edit Rate',"b'Dovoli uporabniku, da uredite Razmerje'"
+b'DocType: Item',b'Publish in Hub',b'Objavite v Hub'
+b'DocType: Student Admission',b'Student Admission',b'\xc5\xa1tudent Sprejem'
+,b'Terretory',b'Terretory'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +762',b'Item {0} is cancelled',b'Postavka {0} je odpovedan'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1064',b'Material Request',b'Zahteva za material'
+b'DocType: Bank Reconciliation',b'Update Clearance Date',b'Posodobitev Potrditev Datum'
+,b'GSTR-2',b'GSTR-2'
+b'DocType: Item',b'Purchase Details',b'Nakup Podrobnosti'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +407',"b""Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1}""","b'Postavka {0} ni bilo mogo\xc4\x8de najti v &quot;surovin, dobavljenih&quot; mizo v narocilo {1}'"
+b'DocType: Salary Slip',b'Total Principal Amount',b'Skupni glavni znesek'
+b'DocType: Student Guardian',b'Relation',b'Razmerje'
+b'DocType: Student Guardian',b'Mother',b'mati'
+b'DocType: Restaurant Reservation',b'Reservation End Time',b'Kon\xc4\x8dni \xc4\x8das rezervacije'
+b'DocType: Crop',b'Biennial',b'Bienale'
+b'apps/erpnext/erpnext/config/selling.py +18',b'Confirmed orders from Customers.',b'Potrjena naro\xc4\x8dila od strank.'
+b'DocType: Purchase Receipt Item',b'Rejected Quantity',b'Zavrnjeno Koli\xc4\x8dina'
+b'apps/erpnext/erpnext/education/doctype/fees/fees.py +80',b'Payment request {0} created',b'Zahtevek za pla\xc4\x8dilo {0} je bil ustvarjen'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72',b'Open Orders',b'Odprta naro\xc4\x8dila'
+b'apps/erpnext/erpnext/healthcare/setup.py +255',b'Low Sensitivity',b'Nizka ob\xc4\x8dutljivost'
+b'DocType: Notification Control',b'Notification Control',b'Nadzor obvestilo'
+b'apps/erpnext/erpnext/templates/emails/training_event.html +17',b'Please confirm once you have completed your training',"b'Potrdite, ko ste kon\xc4\x8dali usposabljanje'"
+b'DocType: Lead',b'Suggestions',b'Predlogi'
+b'DocType: Territory',b'Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.',b'Set Postavka prora\xc4\x8duni Skupina pametno na tem ozemlju. Lahko tudi sezonske z nastavitvijo Distribution.'
+b'DocType: Payment Term',b'Payment Term Name',b'Ime izraza za pla\xc4\x8dilo'
+b'DocType: Healthcare Settings',b'Create documents for sample collection',b'Ustvarite dokumente za zbiranje vzorcev'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276',b'Payment against {0} {1} cannot be greater than Outstanding Amount {2}',b'Pla\xc4\x8dilo pred {0} {1} ne sme biti ve\xc4\x8dja od neporavnanega zneska {2}'
+b'DocType: Shareholder',b'Address HTML',b'Naslov HTML'
+b'DocType: Lead',b'Mobile No.',b'Mobilni No.'
+b'DocType: Maintenance Schedule',b'Generate Schedule',b'Ustvarjajo Urnik'
+b'DocType: Purchase Invoice Item',b'Expense Head',b'Expense Head'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +138',b'Please select Charge Type first',"b'Prosimo, izberite Charge Vrsta najprej'"
+b'DocType: Crop',"b'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.. '","b'Dolo\xc4\x8dite lahko vse naloge, ki jih je treba izvesti za ta pridelek tukaj. Dansko polje se uporablja za navedbo dneva, ko je naloga treba opraviti, 1 je 1. dan itd.'"
+b'DocType: Student Group Student',b'Student Group Student',b'\xc5\xa0tudentska skupina \xc5\xa0tudent'
+b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41',b'Latest',b'Zadnje'
+b'DocType: Asset Maintenance Task',b'2 Yearly',b'2 letno'
+b'DocType: Education Settings',b'Education Settings',b'Nastavitve izobra\xc5\xbeevanja'
+b'DocType: Vehicle Service',b'Inspection',b'in\xc5\xa1pekcija'
+b'DocType: Supplier Scorecard Scoring Standing',b'Max Grade',b'Max razred'
+b'DocType: Email Digest',b'New Quotations',b'Nove ponudbe'
+b'DocType: HR Settings',b'Emails salary slip to employee based on preferred email selected in Employee',"b'E-po\xc5\xa1ta pla\xc4\x8dilni list na zaposlenega, ki temelji na prednostni e-po\xc5\xa1ti izbrani na zaposlenega'"
+b'DocType: Employee',b'The first Leave Approver in the list will be set as the default Leave Approver',"b'Prvi Leave odobritelj na seznamu, bo nastavljen kot privzeti Leave odobritelja'"
+b'DocType: Tax Rule',b'Shipping County',b'Dostava County'
+b'apps/erpnext/erpnext/config/desktop.py +167',b'Learn',b'Nau\xc4\x8dite'
+b'DocType: Asset',b'Next Depreciation Date',b'Naslednja Amortizacija Datum'
+b'apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3',b'Activity Cost per Employee',b'Stro\xc5\xa1ki dejavnost na zaposlenega'
+b'DocType: Accounts Settings',b'Settings for Accounts',b'Nastavitve za ra\xc4\x8dune'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +673',b'Supplier Invoice No exists in Purchase Invoice {0}',b'Dobavitelj ra\xc4\x8duna ni v ra\xc4\x8dunu o nakupu obstaja {0}'
+b'apps/erpnext/erpnext/config/selling.py +118',b'Manage Sales Person Tree.',b'Upravljanje drevesa prodajalca.'
+b'DocType: Job Applicant',b'Cover Letter',b'Cover Letter'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37',b'Outstanding Cheques and Deposits to clear',b'Neporavnani \xc4\x8deki in depoziti \xc5\xbeelite po\xc4\x8distiti'
+b'DocType: Item',b'Synced With Hub',b'Sinhronizirano Z Hub'
+b'DocType: Driver',b'Fleet Manager',b'Fleet Manager'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542',b'Row #{0}: {1} can not be negative for item {2}',b'Vrstica # {0} {1} ne more biti negativna za element {2}'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59',b'Wrong Password',b'Napa\xc4\x8dno geslo'
+b'DocType: Item',b'Variant Of',b'Varianta'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +406',"b""Completed Qty can not be greater than 'Qty to Manufacture'""",b'Dopolnil Koli\xc4\x8dina ne sme biti ve\xc4\x8dja od &quot;Kol za Izdelava&quot;'
+b'DocType: Period Closing Voucher',b'Closing Account Head',b'Zapiranje ra\xc4\x8duna Head'
+b'DocType: Employee',b'External Work History',b'Zunanji Delo Zgodovina'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +111',b'Circular Reference Error',b'Kro\xc5\xbena Reference Error'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +206',b'Student Report Card',b'Student Report Card'
+b'DocType: Appointment Type',b'Is Inpatient',b'Je bolni\xc5\xa1ni\xc4\x8dna'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55',b'Guardian1 Name',b'Ime Guardian1'
+b'DocType: Delivery Note',b'In Words (Export) will be visible once you save the Delivery Note.',"b'Z besedami (izvoz) bo viden, ko boste shranite dobavnici.'"
+b'DocType: Cheque Print Template',b'Distance from left edge',b'Oddaljenost od levega roba'
+b'apps/erpnext/erpnext/utilities/bot.py +29',b'{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2})',b'{0} enot [{1}] (#Obrazec/Postavka/{1}) najden v [{2}] (#Obrazec/Skladi\xc5\xa1\xc4\x8de/{2})'
+b'DocType: Lead',b'Industry',b'Industrija'
+b'DocType: Employee',b'Job Profile',b'Job profila'
+b'DocType: BOM Item',b'Rate & Amount',b'Stopnja in znesek'
+b'apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6',b'This is based on transactions against this Company. See timeline below for details',b'To temelji na transakcijah zoper to dru\xc5\xbebo. Za podrobnosti si oglejte \xc4\x8dasovni na\xc4\x8drt spodaj'
+b'DocType: Stock Settings',b'Notify by Email on creation of automatic Material Request',b'Obvesti po e-po\xc5\xa1ti na ustvarjanje avtomati\xc4\x8dnega Material dogovoru'
+b'apps/erpnext/erpnext/healthcare/setup.py +259',b'Resistant',b'Odporen'
+b'apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77',b'Please set Hotel Room Rate on {}',"b'Prosimo, nastavite hotelsko sobo na {'"
+b'DocType: Journal Entry',b'Multi Currency',b'Multi Valuta'
+b'DocType: Opening Invoice Creation Tool',b'Invoice Type',b'Ra\xc4\x8dun Type'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +939',b'Delivery Note',b'Poro\xc4\x8dilo o dostavi'
+b'DocType: Consultation',b'Encounter Impression',b'Ujemanje prikaza'
+b'apps/erpnext/erpnext/config/learn.py +82',b'Setting up Taxes',b'Postavitev Davki'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134',b'Cost of Sold Asset',b'Stro\xc5\xa1ki Prodano sredstvi'
+b'DocType: Volunteer',b'Morning',b'Jutro'
+b'apps/erpnext/erpnext/accounts/utils.py +350',b'Payment Entry has been modified after you pulled it. Please pull it again.',"b'Za\xc4\x8detek Pla\xc4\x8dilo je bil spremenjen, ko je potegnil. Prosimo, \xc5\xa1e enkrat vle\xc4\x8di.'"
+b'DocType: Program Enrollment Tool',b'New Student Batch',b'Nova \xc5\xa1tudentska serija'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +479',b'{0} entered twice in Item Tax',b'{0} dvakrat vpisano v dav\xc4\x8dni postavki'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113',b'Summary for this week and pending activities',b'Povzetek za ta teden in ki potekajo dejavnosti'
+b'DocType: Student Applicant',b'Admitted',b'priznal'
+b'DocType: Workstation',b'Rent Cost',b'Najem Stro\xc5\xa1ki'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81',b'Amount After Depreciation',b'Znesek Po amortizacijo'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97',b'Upcoming Calendar Events',b'Prihajajo\xc4\x8di Koledar dogodkov'
+b'apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1',b'Variant Attributes',b'Atributi atributov'
+b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85',b'Please select month and year',"b'Prosimo, izberite mesec in leto'"
+b'DocType: Employee',b'Company Email',b'Dru\xc5\xbeba E-po\xc5\xa1ta'
+b'DocType: GL Entry',b'Debit Amount in Account Currency',b'Debetno Znesek v Valuta ra\xc4\x8duna'
+b'DocType: Supplier Scorecard',b'Scoring Standings',b'To\xc4\x8dkovno to\xc4\x8dkovanje'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21',b'Order Value',b'Vrednost naro\xc4\x8dila'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21',b'Order Value',b'Vrednost naro\xc4\x8dila'
+b'apps/erpnext/erpnext/config/accounts.py +27',b'Bank/Cash transactions against party or for internal transfer',b'Bank / denarni posli proti osebi ali za notranjo prerazporeditvijo'
+b'DocType: Shipping Rule',b'Valid for Countries',b'Velja za dr\xc5\xbeave'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +55',"b""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""","b'Ta postavka je Predloga in je ni mogo\xc4\x8de uporabiti v transakcijah. Atributi postavka bodo kopirali ve\xc4\x8d kot v razli\xc4\x8dicah, razen \xc4\x8de je nastavljeno &quot;Ne Kopiraj\xc2\xab'"
+b'DocType: Grant Application',b'Grant Application',b'Grant Application'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69',b'Total Order Considered',b'Skupaj naro\xc4\x8dite Upo\xc5\xa1tevani'
+b'apps/erpnext/erpnext/config/hr.py +243',"b'Employee designation (e.g. CEO, Director etc.).'","b'Oznaka zaposleni (npr CEO, direktor itd.)'"
+b'DocType: Sales Invoice',"b""Rate at which Customer Currency is converted to customer's base currency""","b'Stopnjo, po kateri je naro\xc4\x8dnik Valuta pretvori v osnovni valuti kupca'"
+b'DocType: Course Scheduling Tool',b'Course Scheduling Tool',b'Seveda razporejanje orodje'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +623',b'Row #{0}: Purchase Invoice cannot be made against an existing asset {1}',b'Row # {0}: Nakup ra\xc4\x8duna ni mogo\xc4\x8de sklepati na podlagi obstoje\xc4\x8dega sredstva {1}'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +257',b'[Urgent] Error while creating recurring %s for %s',b'[Nujno] Napaka med ustvarjanjem ponavljajo\xc4\x8dega  %s za %s'
+b'DocType: Land Unit',b'LInked Analysis',b'LInked analiza'
+b'DocType: Item Tax',b'Tax Rate',b'Dav\xc4\x8dna stopnja'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +73',b'Application period cannot be across two allocation records',b'Obdobje uporabe ne more biti v dveh evidencah dodelitve'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59',b'{0} already allocated for Employee {1} for period {2} to {3}',b'{0} \xc5\xbee dodeljeno za zaposlenega {1} za obdobje {2} do {3}'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +141',b'Purchase Invoice {0} is already submitted',b'Nakup Ra\xc4\x8dun {0} je \xc5\xbee predlo\xc5\xbeila'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +92',b'Row # {0}: Batch No must be same as {1} {2}',b'Vrstica # {0}: mora Serija Ne biti enaka kot {1} {2}'
+b'DocType: Material Request Plan Item',b'Material Request Plan Item',b'Postavka na\xc4\x8drta materialne zahteve'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52',b'Convert to non-Group',"b'Pretvarjanje, da non-Group'"
+b'DocType: Project Update',b'Good/Steady',b'Dobro / stabilno'
+b'DocType: C-Form Invoice Detail',b'Invoice Date',b'Datum ra\xc4\x8duna'
+b'DocType: GL Entry',b'Debit Amount',b'Debetni Znesek'
+b'apps/erpnext/erpnext/accounts/party.py +248',b'There can only be 1 Account per Company in {0} {1}',"b'Ne more biti samo 1 ra\xc4\x8dun na podjetje, v {0} {1}'"
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +426',b'Please see attachment',b'Glej prilogo'
+b'DocType: Purchase Order',b'% Received',b'% Prejeto'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3',b'Create Student Groups',b'Ustvarjanje skupin \xc5\xa1tudentov'
+b'DocType: Volunteer',b'Weekends',b'Vikendi'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +118',b'Credit Note Amount',b'Credit Opomba Znesek'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +187',b'{0} ({1}) cannot be greater than planned quanitity ({2}) in Work Order {3}',b'{0} ({1}) ne more biti ve\xc4\x8dji od na\xc4\x8drtovanega koli\xc4\x8dinskega \xc5\xa1tevila ({2}) v delovnem redu {3}'
+b'DocType: Setup Progress Action',b'Action Document',b'Akcijski dokument'
+b'DocType: Chapter Member',b'Website URL',b'Spletna stran URL'
+,b'Finished Goods',"b'Kon\xc4\x8dnih izdelkov,'"
+b'DocType: Delivery Note',b'Instructions',b'Navodila'
+b'DocType: Quality Inspection',b'Inspected By',b'Pregledajo'
+b'DocType: Asset Maintenance Log',b'Maintenance Type',b'Vzdr\xc5\xbeevanje Type'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45',b'{0} - {1} is not enrolled in the Course {2}',b'{0} - {1} ni vpisan v smer {2}'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +225',b'Student Name: ',b'\xc5\xa0tudentsko ime:'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59',b'Serial No {0} does not belong to Delivery Note {1}',b'Serijska \xc5\xa1t {0} ne pripada dobavnica {1}'
+b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +97',"b""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.""","b'Zdi se, da obstaja te\xc5\xbeava s stre\xc5\xbeni\xc5\xa1ko GoCardless konfiguracijo. V primeru neuspeha ne skrbite, znesek bo povrnjen na va\xc5\xa1 ra\xc4\x8dun.'"
+b'apps/erpnext/erpnext/templates/pages/demo.html +47',b'ERPNext Demo',b'ERPNext Demo'
+b'apps/erpnext/erpnext/public/js/utils/item_selector.js +20',b'Add Items',b'Dodaj artikel'
+b'DocType: Item Quality Inspection Parameter',b'Item Quality Inspection Parameter',b'Postavka In\xc5\xa1pekcijski parametrov kakovosti'
+b'DocType: Depreciation Schedule',b'Schedule Date',b'Urnik Datum'
+b'apps/erpnext/erpnext/config/hr.py +116',"b'Earnings, Deductions and other Salary components'","b'Pla\xc4\x8de, Odbitki in druge komponente pla\xc4\x8d'"
+b'DocType: Packed Item',b'Packed Item',b'Pakirani Postavka'
+b'DocType: Job Offer Term',b'Job Offer Term',b'Job Offer Term'
+b'apps/erpnext/erpnext/config/buying.py +65',b'Default settings for buying transactions.',b'Privzete nastavitve za nabavo'
+b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29',b'Activity Cost exists for Employee {0} against Activity Type - {1}',b'Obstaja Stro\xc5\xa1ki dejavnosti za Employee {0} proti vrsti dejavnosti - {1}'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15',b'Mandatory field - Get Students From',b'Obvezno polje - Get \xc5\xa1tudentov iz'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15',b'Mandatory field - Get Students From',b'Obvezno polje - Get \xc5\xa1tudentov iz'
+b'DocType: Program Enrollment',b'Enrolled courses',b'vpisani te\xc4\x8daji'
+b'DocType: Program Enrollment',b'Enrolled courses',b'vpisani te\xc4\x8daji'
+b'DocType: Currency Exchange',b'Currency Exchange',b'Menjalnica'
+b'DocType: Opening Invoice Creation Tool Item',b'Item Name',b'Ime izdelka'
+b'DocType: Authorization Rule',b'Approving User  (above authorized value)',b'Odobritvi uporabnik (zgoraj poobla\xc5\xa1\xc4\x8deni vrednosti)'
+b'DocType: Email Digest',b'Credit Balance',b'Credit Balance'
+b'DocType: Employee',b'Widowed',b'Ovdovela'
+b'DocType: Request for Quotation',b'Request for Quotation',b'Zahteva za ponudbo'
+b'DocType: Healthcare Settings',b'Require Lab Test Approval',b'Zahtevajte odobritev testa za laboratorij'
+b'DocType: Salary Slip Timesheet',b'Working Hours',b'Delovni \xc4\x8das'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +59',b'Total Outstanding',b'Skupaj izjemen'
+b'DocType: Naming Series',b'Change the starting / current sequence number of an existing series.',b'Spremenite izhodi\xc5\xa1\xc4\x8dno / trenutno zaporedno \xc5\xa1tevilko obstoje\xc4\x8dega zaporedja.'
+b'DocType: Dosage Strength',b'Strength',b'Mo\xc4\x8d'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1534',b'Create a new Customer',b'Ustvari novo stranko'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59',"b'If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.'","b'\xc4\x8ce je ve\xc4\x8d Rules Cenik \xc5\xa1e naprej prevladovala, so pozvane, da nastavite Priority ro\xc4\x8dno za re\xc5\xa1evanje morebitnih sporov.'"
+b'apps/erpnext/erpnext/utilities/activation.py +90',b'Create Purchase Orders',b'Ustvari naro\xc4\x8dilnice'
+,b'Purchase Register',b'Nakup Register'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +116',b'Patient not found',b'Bolnik ni najden'
+b'DocType: Scheduling Tool',b'Rechedule',b'Rechedule'
+b'DocType: Landed Cost Item',b'Applicable Charges',b'Veljavnih cenah'
+b'DocType: Workstation',b'Consumable Cost',b'Potro\xc5\xa1ni stro\xc5\xa1ki'
+b'DocType: Purchase Receipt',b'Vehicle Date',b'Datum vozilo'
+b'DocType: Student Log',b'Medical',b'Medical'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175',b'Reason for losing',b'Razlog za izgubo'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +52',b'Update Account Number',b'Posodobi \xc5\xa1tevilko ra\xc4\x8duna'
+b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +44',b'Lead Owner cannot be same as the Lead',b'Svinec Lastnik ne more biti isto kot vodilni'
+b'apps/erpnext/erpnext/accounts/utils.py +356',b'Allocated amount can not greater than unadjusted amount',b'Dodeljen znesek ne more ve\xc4\x8dja od neprilagojene zneska'
+b'DocType: Announcement',b'Receiver',b'sprejemnik'
+b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83',b'Workstation is closed on the following dates as per Holiday List: {0}',b'Workstation je zaprt na naslednje datume kot na Holiday Seznam: {0}'
+b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32',b'Opportunities',b'Prilo\xc5\xbenosti'
+b'DocType: Lab Test Template',b'Single',b'Samski'
+b'DocType: Salary Slip',b'Total Loan Repayment',b'Skupaj posojila Povra\xc4\x8dilo'
+b'DocType: Account',b'Cost of Goods Sold',b'Nabavna vrednost prodanega blaga'
+b'DocType: Subscription',b'Yearly',b'Letni'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230',b'Please enter Cost Center',b'Vnesite stro\xc5\xa1kovni center'
+b'DocType: Drug Prescription',b'Dosage',b'Odmerjanje'
+b'DocType: Journal Entry Account',b'Sales Order',b'Naro\xc4\x8dilo'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69',b'Avg. Selling Rate',b'Avg. Prodajni te\xc4\x8daj'
+b'DocType: Assessment Plan',b'Examiner Name',b'Ime Examiner'
+b'DocType: Lab Test Template',b'No Result',b'Ne Rezultat'
+b'DocType: Purchase Invoice Item',b'Quantity and Rate',b'Koli\xc4\x8dina in stopnja'
+b'DocType: Delivery Note',b'% Installed',b'% name\xc5\xa1\xc4\x8deno'
+b'apps/erpnext/erpnext/utilities/user_progress.py +230',b'Classrooms/ Laboratories etc where lectures can be scheduled.',"b'U\xc4\x8dilnice / Laboratories itd, kjer se lahko na\xc4\x8drtovana predavanja.'"
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46',b'Please enter company name first',"b'Prosimo, da najprej vpi\xc5\xa1ete ime podjetja'"
+b'DocType: Purchase Invoice',b'Supplier Name',b'Dobavitelj Name'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25',b'Read the ERPNext Manual',b'Preberite priro\xc4\x8dnik ERPNext'
+b'DocType: Purchase Invoice',b'01-Sales Return',b'01-Prodaja Vrnitev'
+b'DocType: Account',b'Is Group',b'Is Group'
+b'DocType: Email Digest',b'Pending Purchase Orders',b'Dokler naro\xc4\x8dilnice'
+b'DocType: Stock Settings',b'Automatically Set Serial Nos based on FIFO',b'Samodejno nastavi Serijska \xc5\xa1t temelji na FIFO'
+b'DocType: Accounts Settings',b'Check Supplier Invoice Number Uniqueness',b'Preverite Dobavitelj \xc5\xa0tevilka ra\xc4\x8duna Edinstvenost'
+b'apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34',b'Primary Address Details',b'Osnovni podatki o naslovu'
+b'DocType: Vehicle Service',b'Oil Change',b'Menjava olja'
+b'DocType: Asset Maintenance Log',b'Asset Maintenance Log',b'Dnevnik o vzdr\xc5\xbeevanju sredstev'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57',"b""'To Case No.' cannot be less than 'From Case No.'""","b""'Do \xc5\xa1t. primera' ne more biti ni\xc5\xbeja od 'Od \xc5\xa1t. primera'"""
+b'DocType: Chapter',b'Non Profit',b'Non Profit'
+b'DocType: Production Plan',b'Not Started',b'Ni za\xc4\x8delo'
+b'DocType: Lead',b'Channel Partner',b'Channel Partner'
+b'DocType: Account',b'Old Parent',b'Stara Parent'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19',b'Mandatory field - Academic Year',b'Obvezno polje - \xc5\xa1tudijsko leto'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19',b'Mandatory field - Academic Year',b'Obvezno polje - \xc5\xa1tudijsko leto'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +220',b'{0} {1} is not associated with {2} {3}',b'{0} {1} ni povezan z {2} {3}'
+b'DocType: Notification Control',b'Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.',"b'Prilagodite uvodno besedilo, ki gre kot del te e-po\xc5\xa1te. Vsaka transakcija ima lo\xc4\x8deno uvodno besedilo.'"
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +176',b'Please set default payable account for the company {0}',"b'Prosimo, nastavite privzeto se pla\xc4\x8da ra\xc4\x8dun za podjetje {0}'"
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +511',b'Transaction not allowed against stopped Work Order {0}',b'Transakcija ni dovoljena prekinjena Delovni nalog {0}'
+b'DocType: Setup Progress Action',b'Min Doc Count',b'Min Doc Count'
+b'apps/erpnext/erpnext/config/manufacturing.py +84',b'Global settings for all manufacturing processes.',b'Globalne nastavitve za vseh proizvodnih procesov.'
+b'DocType: Accounts Settings',b'Accounts Frozen Upto',b'Ra\xc4\x8duni Zamrznjena Stanuje'
+b'DocType: SMS Log',b'Sent On',b'Po\xc5\xa1lje On'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +700',b'Attribute {0} selected multiple times in Attributes Table',b'Lastnost {0} izbrana ve\xc4\x8dkrat v atributih tabeli'
+b'DocType: HR Settings',b'Employee record is created using selected field. ',b'Evidenco o zaposlenih delavcih je ustvarjena s pomo\xc4\x8djo izbrano polje.'
+b'DocType: Sales Order',b'Not Applicable',b'Se ne uporablja'
+b'apps/erpnext/erpnext/config/hr.py +70',b'Holiday master.',b'Upravnik praznikov'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +85',b'Opening Invoice Item',b'Odpiranje ra\xc4\x8duna'
+b'DocType: Request for Quotation Item',b'Required Date',b'Zahtevani Datum'
+b'DocType: Delivery Note',b'Billing Address',b'Naslov za po\xc5\xa1iljanje ra\xc4\x8duna'
+b'DocType: BOM',b'Costing',b'Stanejo'
+b'DocType: Tax Rule',b'Billing County',b'County obra\xc4\x8dun'
+b'DocType: Purchase Taxes and Charges',"b'If checked, the tax amount will be considered as already included in the Print Rate / Print Amount'","b'\xc4\x8ce je omogo\xc4\x8deno, se bo \xc5\xa1tela za znesek davka, kot je \xc5\xbee vklju\xc4\x8dena v Print Oceni / Print Znesek'"
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46',b'PieceRef',b'PieceRef'
+b'DocType: Request for Quotation',b'Message for Supplier',b'Sporo\xc4\x8dilo za dobavitelja'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +40',b'Work Order',b'Delovni nalog'
+b'DocType: Driver',b'DRIVER-.#####',b'DRIVER -. #####'
+b'DocType: Sales Invoice',b'Total Qty',b'Skupaj Kol'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62',b'Guardian2 Email ID',b'Skrbnika2 E-ID'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62',b'Guardian2 Email ID',b'Skrbnika2 E-ID'
+b'DocType: Item',b'Show in Website (Variant)',b'Prika\xc5\xbei na spletni strani (Variant)'
+b'DocType: Employee',b'Health Concerns',b'Zdravje'
+b'DocType: Payroll Entry',b'Select Payroll Period',b'Izberite izpla\xc4\x8dane Obdobje'
+b'DocType: Purchase Invoice',b'Unpaid',b'Nepla\xc4\x8dan'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49',b'Reserved for sale',b'Rezervirano za prodajo'
+b'DocType: Packing Slip',b'From Package No.',b'Od paketa No.'
+b'DocType: Item Attribute',b'To Range',b'Da Domet'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29',b'Securities and Deposits',b'Vrednostne papirje in depozite'
+b'apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46',"b""Can't change valuation method, as there are transactions against some items which does not have it's own valuation method""","b'ne more spremeniti metode vrednotenja, kot so transakcije pred nekaj elementov, ki ga ne imeti svojo lastno metodo vrednotenja'"
+b'DocType: Student Report Generation Tool',b'Attended by Parents',b'Obiskujejo star\xc5\xa1i'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82',b'Total leaves allocated is mandatory',b'Skupaj listi dodeljena je obvezna'
+b'DocType: Patient',b'AB Positive',b'AB pozitivno'
+b'DocType: Job Opening',b'Description of a Job Opening',b'Opis slu\xc5\xbebo Otvoritev'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110',b'Pending activities for today',b'V \xc4\x8dakanju na aktivnosti za danes'
+b'apps/erpnext/erpnext/config/hr.py +24',b'Attendance record.',b'\xc5\xa0ivih.'
+b'DocType: Salary Structure',b'Salary Component for timesheet based payroll.',"b'Pla\xc4\x8da Komponenta za Timesheet na izpla\xc4\x8dane pla\xc4\x8de, ki temelji.'"
+b'DocType: Sales Order Item',b'Used for Production Plan',b'Uporablja se za proizvodnjo na\xc4\x8drta'
+b'DocType: Employee Loan',b'Total Payment',b'Skupaj pla\xc4\x8dila'
+b'DocType: Manufacturing Settings',b'Time Between Operations (in mins)',b'\xc4\x8cas med dejavnostmi (v minutah)'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +132',b'{0} {1} is cancelled so the action cannot be completed',"b'{0} {1} je preklican, dejanje ne more biti dokon\xc4\x8dano'"
+b'DocType: Customer',b'Buyer of Goods and Services.',b'Kupec blaga in storitev.'
+b'DocType: Journal Entry',b'Accounts Payable',b'Ra\xc4\x8duni se pla\xc4\x8duje'
+b'DocType: Patient',b'Allergies',b'Alergije'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +33',b'The selected BOMs are not for the same item',b'Izbrani BOMs niso na isti to\xc4\x8dki'
+b'DocType: Supplier Scorecard Standing',b'Notify Other',b'Obvesti drugo'
+b'DocType: Vital Signs',b'Blood Pressure (systolic)',b'Krvni tlak (sistoli\xc4\x8dni)'
+b'DocType: Pricing Rule',b'Valid Upto',b'Valid Stanuje'
+b'DocType: Training Event',b'Workshop',b'Delavnica'
+b'DocType: Supplier Scorecard Scoring Standing',b'Warn Purchase Orders',b'Opozori na naro\xc4\x8dila za nakup'
+b'apps/erpnext/erpnext/utilities/user_progress.py +67',b'List a few of your customers. They could be organizations or individuals.',b'Na\xc5\xa1tejte nekaj va\xc5\xa1ih strank. Ti bi se lahko organizacije ali posamezniki.'
+b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +23',b'Enough Parts to Build',b'Dovolj deli za izgradnjo'
+b'DocType: POS Profile User',b'POS Profile User',b'POS profil uporabnika'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128',b'Direct Income',b'Neposredne dohodkovne'
+b'DocType: Patient Appointment',b'Date TIme',b'Datum \xc4\x8das'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +45',"b'Can not filter based on Account, if grouped by Account'","b'Filter ne more temeljiti na ra\xc4\x8dun, \xc4\x8de je zdru\xc5\xbeena s ra\xc4\x8dun'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130',b'Administrative Officer',b'Upravni uradnik'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39',b'Setting up company and taxes',b'Ustanovitev podjetja in davkov'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22',b'Please select Course',b'Izberite te\xc4\x8daj'
+b'DocType: Codification Table',b'Codification Table',b'Tabela kodifikacije'
+b'DocType: Timesheet Detail',b'Hrs',b'Ur'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +349',b'Please select Company',"b'Prosimo, izberite Company'"
+b'DocType: Stock Entry Detail',b'Difference Account',b'Razlika ra\xc4\x8dun'
+b'DocType: Purchase Invoice',b'Supplier GSTIN',b'Dobavitelj GSTIN'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +47',b'Cannot close task as its dependant task {0} is not closed.',"b'Ne more blizu naloga, saj je njena odvisna Naloga {0} ni zaprt.'"
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +435',b'Please enter Warehouse for which Material Request will be raised',"b'Vnesite skladi\xc5\xa1\xc4\x8de, za katere se bo dvignjeno Material Zahteva'"
+b'DocType: Work Order',b'Additional Operating Cost',b'Dodatne operacijski stro\xc5\xa1kov'
+b'DocType: Lab Test Template',b'Lab Routine',b'Lab Routine'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20',b'Cosmetics',b'Kozmetika'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18',b'Please select Completion Date for Completed Asset Maintenance Log',"b'Prosimo, izberite Datum zaklju\xc4\x8dka za zaklju\xc4\x8den dnevnik vzdr\xc5\xbeevanja sredstev'"
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +552',"b'To merge, following properties must be same for both items'","b'Za pripojitev, mora naslednje lastnosti biti enaka za oba predmetov'"
+b'DocType: Shipping Rule',b'Net Weight',b'Neto te\xc5\xbea'
+b'DocType: Employee',b'Emergency Phone',b'Zasilna Telefon'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82',b'{0} {1} does not exist.',b'{0} {1} ne obstaja.'
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29',b'Buy',b'Nakup'
+,b'Serial No Warranty Expiry',b'Zaporedna \xc5\xa1tevilka Garancija preteka'
+b'DocType: Sales Invoice',b'Offline POS Name',b'Offline POS Ime'
+b'apps/erpnext/erpnext/utilities/user_progress.py +180',b'Student Application',b'\xc5\xa0tudijska aplikacija'
+b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20',b'Please define grade for Threshold 0%',"b'Prosimo, dolo\xc4\x8dite stopnjo za praga 0%'"
+b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20',b'Please define grade for Threshold 0%',"b'Prosimo, dolo\xc4\x8dite stopnjo za praga 0%'"
+b'DocType: Sales Order',b'To Deliver',b'Dostaviti'
+b'DocType: Purchase Invoice Item',b'Item',b'Postavka'
+b'apps/erpnext/erpnext/healthcare/setup.py +256',b'High Sensitivity',b'Visoka ob\xc4\x8dutljivost'
+b'apps/erpnext/erpnext/config/non_profit.py +48',b'Volunteer Type information.',b'Informacije o prostovoljcih.'
+b'DocType: Cash Flow Mapping Template',b'Cash Flow Mapping Template',b'Predloga za preslikavo denarnega toka'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2555',b'Serial no item cannot be a fraction',b'Serijska \xc5\xa1t postavka ne more biti del'
+b'DocType: Journal Entry',b'Difference (Dr - Cr)',b'Razlika (Dr - Cr)'
+b'DocType: Account',b'Profit and Loss',b'Dobi\xc4\x8dek in izguba'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +104',"b'Not permitted, configure Lab Test Template as required'","b'Ni dovoljeno, \xc4\x8de je potrebno, konfigurirate preskusno razli\xc4\x8dico Lab Labels'"
+b'DocType: Patient',b'Risk Factors',b'Dejavniki tveganja'
+b'DocType: Patient',b'Occupational Hazards and Environmental Factors',b'Poklicne nevarnosti in dejavniki okolja'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +239',b'Stock Entries already created for Work Order ',"b'Zaloge, ki so \xc5\xbee bile ustvarjene za delovno nalogo'"
+b'DocType: Vital Signs',b'Respiratory rate',b'Stopnja dihanja'
+b'apps/erpnext/erpnext/config/stock.py +334',b'Managing Subcontracting',b'Upravljanje Podizvajalci'
+b'DocType: Vital Signs',b'Body Temperature',b'Temperatura telesa'
+b'DocType: Project',b'Project will be accessible on the website to these users',b'Projekt bo na voljo na spletni strani teh uporabnikov'
+b'DocType: Detected Disease',b'Disease',b'Bolezen'
+b'apps/erpnext/erpnext/config/projects.py +29',b'Define Project type.',b'Dolo\xc4\x8dite vrsto projekta.'
+b'DocType: Supplier Scorecard',b'Weighting Function',b'Tehtalna funkcija'
+b'DocType: Physician',b'OP Consulting Charge',b'OP Consulting Charge'
+b'apps/erpnext/erpnext/utilities/user_progress.py +28',b'Setup your ',b'Nastavite svoje'
+b'DocType: Student Report Generation Tool',b'Show Marks',b'Poka\xc5\xbei oznake'
+b'DocType: Quotation',"b""Rate at which Price list currency is converted to company's base currency""","b'Obrestna mera, po kateri Cenik valuti, se pretvori v osnovni valuti dru\xc5\xbebe'"
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +70',b'Account {0} does not belong to company: {1}',b'Ra\xc4\x8dun {0} ne pripada podjetju: {1}'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +52',b'Abbreviation already used for another company',b'Kratica \xc5\xbee uporabljena za druge dru\xc5\xbebe'
+b'DocType: Selling Settings',b'Default Customer Group',b'Privzeta skupina kupcev'
+b'DocType: Asset Repair',b'ARLOG-',b'ARLOG-'
+b'DocType: Global Defaults',"b""If disable, 'Rounded Total' field will not be visible in any transaction""","b'\xc4\x8ce onemogo\xc4\x8diti, polje &quot;zaokro\xc5\xbeena Skupaj &#39;ne bo viden v vsakem poslu'"
+b'DocType: BOM',b'Operating Cost',b'Obratovalni stro\xc5\xa1ki'
+b'DocType: Crop',b'Produced Items',b'Proizvedeni elementi'
+b'DocType: Sales Order Item',b'Gross Profit',b'Bruto dobi\xc4\x8dek'
+b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49',b'Increment cannot be 0',b'Prirastek ne more biti 0'
+b'DocType: Company',b'Delete Company Transactions',b'Izbri\xc5\xa1i transakcije dru\xc5\xbebe'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364',b'Reference No and Reference Date is mandatory for Bank transaction',b'Referen\xc4\x8dna \xc5\xa1tevilka in referen\xc4\x8dni datum je obvezna za banke transakcijo'
+b'DocType: Purchase Receipt',b'Add / Edit Taxes and Charges',b'Dodaj / Uredi davkov in dajatev'
+b'DocType: Payment Entry Reference',b'Supplier Invoice No',b'Dobavitelj Ra\xc4\x8dun Ne'
+b'DocType: Territory',b'For reference',b'Za sklic'
+b'DocType: Healthcare Settings',b'Appointment Confirmation',b'Potrditev imenovanja'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158',"b'Cannot delete Serial No {0}, as it is used in stock transactions'","b'Ne morem izbrisati Serijska \xc5\xa1t {0}, saj je uporabljen v transakcijah zalogi'"
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +256',b'Closing (Cr)',b'Zapiranje (Cr)'
+b'apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1',b'Hello',b'Pozdravljeni'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118',b'Move Item',b'Move Item'
+b'DocType: Serial No',b'Warranty Period (Days)',b'Garancijski rok (dni)'
+b'DocType: Installation Note Item',b'Installation Note Item',b'Namestitev Opomba Postavka'
+b'DocType: Production Plan Item',b'Pending Qty',b'Pending Kol'
+b'DocType: Budget',b'Ignore',b'Ignoriraj'
+b'apps/erpnext/erpnext/accounts/party.py +396',b'{0} {1} is not active',b'{0} {1} ni aktiven'
+b'apps/erpnext/erpnext/config/accounts.py +272',b'Setup cheque dimensions for printing',b'Preverite nastavitve za dimenzije za tiskanje'
+b'DocType: Salary Slip',b'Salary Slip Timesheet',b'Pla\xc4\x8da Slip Timesheet'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +160',b'Supplier Warehouse mandatory for sub-contracted Purchase Receipt',b'Dobavitelj Skladi\xc5\xa1\xc4\x8de obvezno za podizvajalcev Potrdilo o nakupu'
+b'DocType: Pricing Rule',b'Valid From',b'Velja od'
+b'DocType: Sales Invoice',b'Total Commission',b'Skupaj Komisija'
+b'DocType: Pricing Rule',b'Sales Partner',b'Prodaja Partner'
+b'apps/erpnext/erpnext/config/buying.py +150',b'All Supplier scorecards.',b'Vse ocenjevalne table dobaviteljev.'
+b'DocType: Buying Settings',b'Purchase Receipt Required',b'Potrdilo o nakupu Obvezno'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +188',b'Target warehouse in row {0} must be same as Work Order',b'Ciljno skladi\xc5\xa1\xc4\x8de v vrstici {0} mora biti enako kot delovni nalog'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +155',b'Valuation Rate is mandatory if Opening Stock entered',"b'Oceni Vrednotenje je obvezna, \xc4\x8de je za\xc4\x8del Odpiranje Stock'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +143',b'No records found in the Invoice table',b'Ni najdenih v tabeli ra\xc4\x8duna zapisov'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +34',b'Please select Company and Party Type first',b'Izberite podjetja in Zabava Vrsta najprej'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31',"b'Already set default in pos profile {0} for user {1}, kindly disabled default'","b'\xc5\xbde nastavljeno privzeto v profilu pos {0} za uporabnika {1}, prijazno onemogo\xc4\x8deno privzeto'"
+b'apps/erpnext/erpnext/config/accounts.py +293',b'Financial / accounting year.',b'Finan\xc4\x8dni / ra\xc4\x8dunovodstvo leto.'
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9',b'Accumulated Values',b'nakopi\xc4\x8dene Vrednosti'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162',"b'Sorry, Serial Nos cannot be merged'","b'Oprostite, Serijska \xc5\xa1t ni mogo\xc4\x8de zdru\xc5\xbeiti'"
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72',b'Territory is Required in POS Profile',b'Ozemlje je obvezno v profilu POS'
+b'DocType: Supplier',b'Prevent RFQs',b'Prepre\xc4\x8dite RFQ-je'
+b'apps/erpnext/erpnext/utilities/activation.py +83',b'Make Sales Order',b'Naredite Sales Order'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168',b'Salary Slip submitted for period from {0} to {1}',b'Pla\xc4\x8dilo za pla\xc4\x8dilo je oddano za obdobje od {0} do {1}'
+b'DocType: Project Task',b'Project Task',b'Project Task'
+,b'Lead Id',b'ID Ponudbe'
+b'DocType: C-Form Invoice Detail',b'Grand Total',b'Skupna vsota'
+b'DocType: Assessment Plan',b'Course',b'Te\xc4\x8daj'
+b'DocType: Timesheet',b'Payslip',b'Payslip'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +4',b'Item Cart',b'To\xc4\x8dka ko\xc5\xa1arico'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38',b'Fiscal Year Start Date should not be greater than Fiscal Year End Date',b'Fiskalna Leto Datum za\xc4\x8detka ne sme biti ve\xc4\x8dja od poslovnega leta End Datum'
+b'DocType: Issue',b'Resolution',b'Lo\xc4\x8dljivost'
+b'DocType: C-Form',b'IV',b'IV'
+b'apps/erpnext/erpnext/templates/pages/order.html +76',b'Delivered: {0}',b'Dobava: {0}'
+b'DocType: Expense Claim',b'Payable Account',b'Pla\xc4\x8dljivo ra\xc4\x8dun'
+b'DocType: Payment Entry',b'Type of Payment',b'Vrsta pla\xc4\x8dila'
+b'DocType: Sales Order',b'Billing and Delivery Status',b'Zara\xc4\x8dunavanje in Delivery Status'
+b'DocType: Job Applicant',b'Resume Attachment',b'Nadaljuj Attachment'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58',b'Repeat Customers',b'Ponovite Stranke'
+b'DocType: Leave Control Panel',b'Allocate',b'Dodeli'
+b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108',b'Create Variant',b'Ustvari varianto'
+b'DocType: Sales Invoice',b'Shipping Bill Date',b'Datum po\xc5\xa1iljanja'
+b'DocType: Production Plan',b'Production Plan',b'Na\xc4\x8drt proizvodnje'
+b'DocType: Opening Invoice Creation Tool',b'Opening Invoice Creation Tool',b'Odpiranje orodja za ustvarjanje ra\xc4\x8dunov'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +853',b'Sales Return',b'Prodaja Return'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96',"b""Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period""",b'Opomba: Skupna dodeljena listi {0} ne sme biti manj\xc5\xa1i od \xc5\xbee odobrene listov {1} za obdobje'
+,b'Total Stock Summary',b'Skupaj Stock Povzetek'
+b'DocType: Announcement',b'Posted By',b'Avtor'
+b'DocType: Item',b'Delivered by Supplier (Drop Ship)',b'Dostavi dobavitelja (Drop Ship)'
+b'DocType: Healthcare Settings',b'Confirmation Message',b'Potrditveno sporo\xc4\x8dilo'
+b'apps/erpnext/erpnext/config/crm.py +12',b'Database of potential customers.',b'Podatkovna baza potencialnih strank.'
+b'DocType: Authorization Rule',b'Customer or Item',b'Stranka ali Artikel'
+b'apps/erpnext/erpnext/config/selling.py +28',b'Customer database.',b'Baza podatkov o strankah.'
+b'DocType: Quotation',b'Quotation To',b'Ponudba za'
+b'DocType: Lead',b'Middle Income',b'Bli\xc5\xbenji Prihodki'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +228',b'Opening (Cr)',b'Odprtino (Cr)'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +872',b'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.',"b'Privzeto mersko enoto za postavko {0} ni mogo\xc4\x8de neposredno spremeniti, ker ste \xc5\xbee naredili nekaj transakcije (-e) z drugo UOM. Boste morali ustvariti nov element, da uporabi druga\xc4\x8dno Privzeti UOM.'"
+b'apps/erpnext/erpnext/accounts/utils.py +354',b'Allocated amount can not be negative',b'Dodeljen znesek ne more biti negativna'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11',b'Please set the Company',b'Nastavite Company'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11',b'Please set the Company',b'Nastavite Company'
+b'DocType: Share Balance',b'Share Balance',b'Deljeno stanje'
+b'DocType: Purchase Order Item',b'Billed Amt',b'Bremenjenega Amt'
+b'DocType: Training Result Employee',b'Training Result Employee',b'Usposabljanje Rezultat zaposlenih'
+b'DocType: Warehouse',b'A logical Warehouse against which stock entries are made.',"b'Logi\xc4\x8dno Warehouse, zoper katerega so narejeni vnosov zalog.'"
+b'DocType: Repayment Schedule',b'Principal Amount',b'glavni Znesek'
+b'DocType: Employee Loan Application',b'Total Payable Interest',b'Skupaj pla\xc4\x8dljivo Obresti'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +57',b'Total Outstanding: {0}',b'Skupno izjemno: {0}'
+b'DocType: Sales Invoice Timesheet',b'Sales Invoice Timesheet',b'Prodaja Ra\xc4\x8dun Timesheet'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118',b'Reference No & Reference Date is required for {0}',b'Referen\xc4\x8dna \xc5\xa1t &amp; Referen\xc4\x8dni datum je potrebna za {0}'
+b'DocType: Payroll Entry',b'Select Payment Account to make Bank Entry',"b'Izberite Pla\xc4\x8dilo ra\xc4\x8duna, da bo Bank Entry'"
+b'DocType: Hotel Settings',b'Default Invoice Naming Series',b'Privzeto imenovanje ra\xc4\x8dunov'
+b'apps/erpnext/erpnext/utilities/activation.py +136',"b'Create Employee records to manage leaves, expense claims and payroll'","b'Ustvarjanje zapisov zaposlencev za upravljanje listje, odhodkov terjatev in na izpla\xc4\x8dane pla\xc4\x8de'"
+b'DocType: Restaurant Reservation',b'Restaurant Reservation',b'Rezervacija restavracij'
+b'DocType: Land Unit',b'Land Unit Name',b'Ime enote zemlji\xc5\xa1\xc4\x8da'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190',b'Proposal Writing',b'Predlog Pisanje'
+b'DocType: Payment Entry Deduction',b'Payment Entry Deduction',b'Pla\xc4\x8dilo Za\xc4\x8detek od\xc5\xa1tevanja'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14',b'Wrapping up',b'Zavijanje'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35',b'Notify Customers via Email',b'Obvesti stranke po e-po\xc5\xa1ti'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35',b'Another Sales Person {0} exists with the same Employee id',b'Obstaja \xc5\xa1e ena Sales Oseba {0} z enako id zaposlenih'
+b'DocType: Employee Advance',b'Claimed Amount',b'Zahtevani znesek'
+b'apps/erpnext/erpnext/config/education.py +180',b'Masters',b'Masters'
+b'DocType: Assessment Plan',b'Maximum Assessment Score',b'Najvi\xc5\xa1ja ocena Ocena'
+b'apps/erpnext/erpnext/config/accounts.py +138',b'Update Bank Transaction Dates',b'Update banka transakcijske Termini'
+b'apps/erpnext/erpnext/config/projects.py +41',b'Time Tracking',b'sledenje \xc4\x8das'
+b'DocType: Purchase Invoice',b'DUPLICATE FOR TRANSPORTER',b'DVOJNIK ZA TRANSPORTER'
+b'apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49',b'Row {0}# Paid Amount cannot be greater than requested advance amount',b'Vrstica {0} # Pla\xc4\x8dan znesek ne sme biti ve\xc4\x8dji od zahtevanega zneska predpla\xc4\x8dila'
+b'DocType: Fiscal Year Company',b'Fiscal Year Company',b'Fiskalna Leto Company'
+b'DocType: Packing Slip Item',b'DN Detail',b'DN Detail'
+b'DocType: Training Event',b'Conference',b'Konferenca'
+b'DocType: Timesheet',b'Billed',b'Zara\xc4\x8dunavajo'
+b'DocType: Batch',b'Batch Description',b'Serija Opis'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12',b'Creating student groups',b'Ustvarjanje \xc5\xa1tudentskih skupin'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12',b'Creating student groups',b'Ustvarjanje \xc5\xa1tudentskih skupin'
+b'apps/erpnext/erpnext/accounts/utils.py +727',"b'Payment Gateway Account not created, please create one manually.'","b'Pla\xc4\x8dilo Gateway ra\xc4\x8duna ni ustvaril, si ustvariti ro\xc4\x8dno.'"
+b'DocType: Supplier Scorecard',b'Per Year',b'Letno'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51',b'Not eligible for the admission in this program as per DOB',b'Ni upravi\xc4\x8den do sprejema v tem programu kot na DOB'
+b'DocType: Sales Invoice',b'Sales Taxes and Charges',b'Prodajne Davki in dajatve'
+b'DocType: Employee',b'Organization Profile',b'Organizacija Profil'
+b'DocType: Vital Signs',b'Height (In Meter)',b'Vi\xc5\xa1ina (v metrih)'
+b'DocType: Student',b'Sibling Details',b'sorodstvena Podrobnosti'
+b'DocType: Vehicle Service',b'Vehicle Service',b'servis vozila'
+b'apps/erpnext/erpnext/config/setup.py +101',b'Automatically triggers the feedback request based on conditions.',"b'Samodejno spro\xc5\xbei zahteva povratne informacije, ki temeljijo na pogojih.'"
+b'DocType: Employee',b'Reason for Resignation',b'Razlog za odstop'
+b'apps/erpnext/erpnext/config/hr.py +152',b'Template for performance appraisals.',b'Predloga za izvajanje cenitve.'
+b'DocType: Sales Invoice',b'Credit Note Issued',b'Credit Note Izdano'
+b'DocType: Project Task',b'Weight',b'Te\xc5\xbea'
+b'DocType: Payment Reconciliation',b'Invoice/Journal Entry Details',b'Ra\xc4\x8dun / Journal Entry Podrobnosti'
+b'apps/erpnext/erpnext/accounts/utils.py +83',"b""{0} '{1}' not in Fiscal Year {2}""",b'{0} {1} &quot;ni v prora\xc4\x8dunskem letu {2}'
+b'DocType: Buying Settings',b'Settings for Buying Module',b'Nastavitve za modul nabava'
+b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21',b'Asset {0} does not belong to company {1}',b'Sredstvo {0} ne pripada dru\xc5\xbebi {1}'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70',b'Please enter Purchase Receipt first',"b'Prosimo, da najprej vnesete Potrdilo o nakupu'"
+b'DocType: Buying Settings',b'Supplier Naming By',b'Dobavitelj Imenovanje Z'
+b'DocType: Activity Type',b'Default Costing Rate',b'Privzeto Costing Rate'
+b'DocType: Maintenance Schedule',b'Maintenance Schedule',b'Vzdr\xc5\xbeevanje Urnik'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36',"b'Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.'","b'Potem Ozna\xc4\x8devanje cen Pravila se filtrirajo temeljijo na stranke, skupine kupcev, ozemlje, dobavitelja, dobavitelj Type, kampanje, prodajnemu partnerju itd'"
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +29',b'Net Change in Inventory',b'Neto sprememba v popisu'
+b'apps/erpnext/erpnext/config/hr.py +162',b'Employee Loan Management',b'Posojilo Employee Management'
+b'DocType: Employee',b'Passport Number',b'\xc5\xa0tevilka potnega lista'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60',b'Relation with Guardian2',b'Povezava z skrbnika2'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124',b'Manager',b'Manager'
+b'DocType: Payment Entry',b'Payment From / To',b'Pla\xc4\x8dilo Od / Do'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +170',b'New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0}',b'Nova kreditna meja je ni\xc5\xbeja od trenutne neporavnani znesek za stranko. Kreditno linijo mora biti atleast {0}'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +428',b'Please set account in Warehouse {0}',b'Nastavite ra\xc4\x8dun v Galeriji {0}'
+b'apps/erpnext/erpnext/controllers/trends.py +39',"b""'Based On' and 'Group By' can not be same""","b'""Na podlagi"" in ""Zdru\xc5\xbei po"" ne more biti enaka'"
+b'DocType: Sales Person',b'Sales Person Targets',b'Prodaja Osebni cilji'
+b'DocType: Installation Note',b'IN-',b'TEKMOVANJU'
+b'DocType: Work Order Operation',b'In minutes',b'V minutah'
+b'DocType: Issue',b'Resolution Date',b'Resolucija Datum'
+b'DocType: Lab Test Template',b'Compound',b'Spojina'
+b'DocType: Student Batch Name',b'Batch Name',b'serija Ime'
+b'DocType: Fee Validity',b'Max number of visit',b'Najve\xc4\x8dje \xc5\xa1tevilo obiska'
+,b'Hotel Room Occupancy',b'Hotelske sobe'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +358',b'Timesheet created:',b'Timesheet ustvaril:'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +931',b'Please set default Cash or Bank account in Mode of Payment {0}',"b'Prosim, nastavite privzeto gotovinski ali ban\xc4\x8dni ra\xc4\x8dun v na\xc4\x8dinu pla\xc4\x8devanja {0}'"
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24',b'Enroll',b'v\xc4\x8dlanite se'
+b'DocType: GST Settings',b'GST Settings',b'GST Nastavitve'
+b'DocType: Selling Settings',b'Customer Naming By',b'Stranka Imenovanje Z'
+b'DocType: Student Leave Application',b'Will show the student as Present in Student Monthly Attendance Report',"b'Bo pokazal \xc5\xa1tudenta, kot so v \xc5\xa0tudentski Mese\xc4\x8dno poro\xc4\x8dilo navzo\xc4\x8dih'"
+b'DocType: Depreciation Schedule',b'Depreciation Amount',b'Amortizacija Znesek'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56',b'Convert to Group',b'Pretvarjanje skupini'
+b'DocType: Delivery Trip',b'TOUR-.#####',b'TOUR -. #####'
+b'DocType: Activity Cost',b'Activity Type',b'Vrsta dejavnosti'
+b'DocType: Request for Quotation',b'For individual supplier',b'Za posameznega dobavitelja'
+b'DocType: BOM Operation',b'Base Hour Rate(Company Currency)',b'Osnovna urni te\xc4\x8daj (dru\xc5\xbeba Valuta)'
+b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47',b'Delivered Amount',b'Delivered Znesek'
+b'DocType: Quotation Item',b'Item Balance',b'Bilan\xc4\x8dne postavke'
+b'DocType: Sales Invoice',b'Packing List',b'Seznam pakiranja'
+b'apps/erpnext/erpnext/config/buying.py +28',b'Purchase Orders given to Suppliers.',b'Naro\xc4\x8dila dati dobaviteljev.'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43',b'Publishing',b'Zalo\xc5\xbeni\xc5\xa1tvo'
+b'DocType: Accounts Settings',b'Report Settings',b'Poro\xc4\x8danje nastavitev'
+b'DocType: Activity Cost',b'Projects User',b'Projekti Uporabnik'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40',b'Consumed',b'Porabljeno'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158',b'{0}: {1} not found in Invoice Details table',b'{0}: {1} ni mogo\xc4\x8de najti v tabeli podrobnosti ra\xc4\x8dunov'
+b'DocType: Asset',b'Asset Owner Company',b'Dru\xc5\xbeba z lastniki sredstev'
+b'DocType: Company',b'Round Off Cost Center',b'Zaokro\xc5\xbeen stro\xc5\xa1kovni center'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242',b'Maintenance Visit {0} must be cancelled before cancelling this Sales Order',b'Vzdr\xc5\xbeevanje obisk {0} je treba odpovedati pred preklicem te Sales Order'
+b'DocType: Asset Maintenance Log',b'AML-',b'AML-'
+b'DocType: Item',b'Material Transfer',b'Prenos materialov'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24',b'Could not find path for ',b'Pot ni mogla najti'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +221',b'Opening (Dr)',b'Odprtje (Dr)'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39',b'Posting timestamp must be after {0}',b'Napotitev \xc5\xbeig mora biti po {0}'
+b'apps/erpnext/erpnext/config/accounts.py +39',b'To make recurring documents',b'Za ponavljajo\xc4\x8de se dokumente'
+,b'GST Itemised Purchase Register',b'DDV Raz\xc4\x8dlenjeni Nakup Registracija'
+b'DocType: Course Scheduling Tool',b'Reschedule',b'Ponovni premik'
+b'DocType: Employee Loan',b'Total Interest Payable',b'Skupaj Obresti pla\xc4\x8dljivo'
+b'DocType: Landed Cost Taxes and Charges',b'Landed Cost Taxes and Charges',b'Iztovorjeni stro\xc5\xa1kov Davki in prispevki'
+b'DocType: Work Order Operation',b'Actual Start Time',b'Actual Start Time'
+b'DocType: BOM Operation',b'Operation Time',b'Operacija \xc4\x8das'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +316',b'Finish',b'Finish'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412',b'Base',b'Osnovna'
+b'DocType: Timesheet',b'Total Billed Hours',b'Skupaj Obra\xc4\x8dunane ure'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1530',b'Write Off Amount',b'Napi\xc5\xa1ite enkratnem znesku'
+b'DocType: Leave Block List Allow',b'Allow User',b'Dovoli Uporabnik'
+b'DocType: Journal Entry',b'Bill No',b'Bill Ne'
+b'DocType: Company',b'Gain/Loss Account on Asset Disposal',b'Dobi\xc4\x8dek / izguba ra\xc4\x8dun o odlaganju sredstev'
+b'DocType: Vehicle Log',b'Service Details',b'storitev Podrobnosti'
+b'DocType: Vehicle Log',b'Service Details',b'storitev Podrobnosti'
+b'DocType: Subscription',b'Quarterly',b'\xc4\x8cetrtletno'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +47',b'EcritureLib',b'EcritureLib'
+b'DocType: Lab Test Template',b'Grouped',b'Zdru\xc5\xbeeno'
+b'DocType: Selling Settings',b'Delivery Note Required',b'Dostava Opomba Obvezno'
+b'DocType: Bank Guarantee',b'Bank Guarantee Number',b'Ban\xc4\x8dna garancija \xc5\xa0tevilo'
+b'DocType: Bank Guarantee',b'Bank Guarantee Number',b'Ban\xc4\x8dna garancija \xc5\xa0tevilo'
+b'DocType: Assessment Criteria',b'Assessment Criteria',b'Merila ocenjevanja'
+b'DocType: BOM Item',b'Basic Rate (Company Currency)',b'Basic Rate (dru\xc5\xbeba Valuta)'
+b'DocType: Student Attendance',b'Student Attendance',b'\xc5\xa1tudent Udele\xc5\xbeba'
+b'DocType: Sales Invoice Timesheet',b'Time Sheet',b'\xc4\x8das Sheet'
+b'DocType: Manufacturing Settings',b'Backflush Raw Materials Based On',"b'Backflush Surovine, ki temelji na'"
+b'DocType: Sales Invoice',b'Port Code',b'Pristani\xc5\xa1ka koda'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +957',b'Reserve Warehouse',b'Rezervno skladi\xc5\xa1\xc4\x8de'
+b'DocType: Lead',b'Lead is an Organization',b'Svinec je organizacija'
+b'DocType: Guardian Interest',b'Interest',b'Obresti'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10',b'Pre Sales',b'pre Sales'
+b'DocType: Instructor Log',b'Other Details',b'Drugi podatki'
+b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18',b'Suplier',b'suplier'
+b'DocType: Lab Test',b'Test Template',b'Preskusna predloga'
+b'DocType: Restaurant Order Entry Item',b'Served',b'Servirano'
+b'apps/erpnext/erpnext/config/non_profit.py +13',b'Chapter information.',b'Podatki o poglavju.'
+b'DocType: Account',b'Accounts',b'Ra\xc4\x8duni'
+b'DocType: Vehicle',b'Odometer Value (Last)',b'Vrednost \xc5\xa1tevca (Zadnja)'
+b'apps/erpnext/erpnext/config/buying.py +160',b'Templates of supplier scorecard criteria.',b'Predloge meril uspe\xc5\xa1nosti dobaviteljev.'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109',b'Marketing',b'Tr\xc5\xbeenje'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +303',b'Payment Entry is already created',b'Za\xc4\x8detek Pla\xc4\x8dilo je \xc5\xbee ustvarjena'
+b'DocType: Request for Quotation',b'Get Suppliers',b'Pridobite dobavitelje'
+b'DocType: Purchase Receipt Item Supplied',b'Current Stock',b'Trenutna zaloga'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +610',b'Row #{0}: Asset {1} does not linked to Item {2}',b'Row # {0}: Asset {1} ni povezana s postavko {2}'
+b'apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15',b'Please setup Instructor Naming System in Education &gt; Education Settings',"b'Prosimo, nastavite sistem imenovanja in\xc5\xa1truktorja v izobra\xc5\xbeevanju&gt; Nastavitve izobra\xc5\xbeevanja'"
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394',b'Preview Salary Slip',b'Predogled Pla\xc4\x8da listek'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54',b'Account {0} has been entered multiple times',b'Ra\xc4\x8dun {0} je bil vpisan ve\xc4\x8dkrat'
+b'DocType: Account',b'Expenses Included In Valuation',b'Stro\xc5\xa1ki Vklju\xc4\x8deno v vrednotenju'
+b'apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +37',b'You can only renew if your membership expires within 30 days',"b'Obnovite lahko le, \xc4\x8de va\xc5\xa1e \xc4\x8dlanstvo pote\xc4\x8de v 30 dneh'"
+b'DocType: Land Unit',b'Longitude',b'Dol\xc5\xbeina'
+,b'Absent Student Report',b'Odsoten Student Report'
+b'DocType: Crop',b'Crop Spacing UOM',b'UOM razmika rastlin'
+b'DocType: Accounts Settings',b'Only select if you have setup Cash Flow Mapper documents',"b'Izberite samo, \xc4\x8de imate nastavljene dokumente o denarnem toku Mapper'"
+b'DocType: Email Digest',b'Next email will be sent on:',b'Naslednje sporo\xc4\x8dilo bo poslano na:'
+b'DocType: Supplier Scorecard',b'Per Week',b'Tedensko'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +666',b'Item has variants.',b'Element ima variante.'
+b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154',b'Total Student',b'Skupaj \xc5\xa1tudent'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65',b'Item {0} not found',b'Postavka {0} ni bilo mogo\xc4\x8de najti'
+b'DocType: Bin',b'Stock Value',b'Stock Value'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +239',b'Company {0} does not exist',b'Podjetje {0} ne obstaja'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40',b'{0} has fee validity till {1}',b'{0} ima veljavnost pristojbine {1}'
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +54',b'Tree Type',b'Tree Type'
+b'DocType: BOM Explosion Item',b'Qty Consumed Per Unit',b'Koli\xc4\x8dina porabljene na enoto'
+b'DocType: GST Account',b'IGST Account',b'Ra\xc4\x8dun IGST'
+b'DocType: Serial No',b'Warranty Expiry Date',b'Garancija Datum preteka'
+b'DocType: Material Request Item',b'Quantity and Warehouse',b'Koli\xc4\x8dina in skladi\xc5\xa1\xc4\x8da'
+b'DocType: Hub Settings',b'Unregister',b'Odjavite se'
+b'DocType: Sales Invoice',b'Commission Rate (%)',b'Komisija Stopnja (%)'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24',b'Please select Program',b'Izberite program'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24',b'Please select Program',b'Izberite program'
+b'DocType: Project',b'Estimated Cost',b'Ocenjeni stro\xc5\xa1ek'
+b'DocType: Purchase Order',b'Link to material requests',b'Povezava na materialne zahteve'
+b'DocType: Hub Settings',b'Publish',b'Objavi'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7',b'Aerospace',b'Aerospace'
+,b'Fichier des Ecritures Comptables [FEC]',b'Fichier des Ecritures Comptables [FEC]'
+b'DocType: Journal Entry',b'Credit Card Entry',b'Za\xc4\x8detek Credit Card'
+b'apps/erpnext/erpnext/config/accounts.py +57',b'Company and Accounts',b'Podjetje in ra\xc4\x8duni'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70',b'In Value',b'v vrednosti'
+b'DocType: Asset Settings',b'Depreciation Options',b'Mo\xc5\xbenosti amortizacije'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +35',b'Invalid Posting Time',b'Neveljaven \xc4\x8das po\xc5\xa1iljanja'
+b'DocType: Lead',b'Campaign Name',b'Ime kampanje'
+b'DocType: Hotel Room',b'Capacity',b'Zmogljivost'
+b'DocType: Selling Settings',b'Close Opportunity After Days',b'Zapri Prilo\xc5\xbenost Po dnevih'
+,b'Reserved',b'Rezervirano'
+b'DocType: Driver',b'License Details',b'Podrobnosti o licenci'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +85',b'The field From Shareholder cannot be blank',b'Polje Od delni\xc4\x8darja ne more biti prazno'
+b'DocType: Purchase Order',b'Supply Raw Materials',b'Oskrba z Surovine'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10',b'Current Assets',b'Kratkoro\xc4\x8dna sredstva'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +121',b'{0} is not a stock Item',b'{0} ni zaloge artikla'
+b'apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6',"b""Please share your feedback to the training by clicking on 'Training Feedback' and then 'New'""","b'Po\xc5\xa1ljite povratne informacije o usposabljanju, tako da kliknete \xc2\xbbPovratne informacije o usposabljanju\xc2\xab in nato \xc2\xbbNovo\xc2\xab,'"
+b'DocType: Mode of Payment Account',b'Default Account',b'Privzeti ra\xc4\x8dun'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +273',b'Please select Sample Retention Warehouse in Stock Settings first',b'Najprej izberite skladi\xc5\xa1\xc4\x8de za shranjevanje vzorcev v nastavitvah zalog'
+b'DocType: Payment Entry',b'Received Amount (Company Currency)',b'Prejela znesek (dru\xc5\xbeba Valuta)'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192',b'Lead must be set if Opportunity is made from Lead',"b'Svinec je treba dolo\xc4\x8diti, \xc4\x8de je prilo\xc5\xbenost narejen iz svinca'"
+b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +136',b'Payment Cancelled. Please check your GoCardless Account for more details',b'Pla\xc4\x8dilo preklicano. Preverite svoj GoCardless ra\xc4\x8dun za ve\xc4\x8d podrobnosti'
+b'apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29',b'Please select weekly off day',"b'Prosimo, izberite tedensko off dan'"
+b'DocType: Patient',b'O Negative',b'O Negativno'
+b'DocType: Work Order Operation',b'Planned End Time',b'Na\xc4\x8drtovano Kon\xc4\x8dni \xc4\x8das'
+,b'Sales Person Target Variance Item Group-Wise',b'Prodaja Oseba Target Varianca Postavka Group-Wise'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +93',b'Account with existing transaction cannot be converted to ledger',b'Ra\xc4\x8dun z obstoje\xc4\x8dim poslom ni mogo\xc4\x8de pretvoriti v knjigo terjatev'
+b'apps/erpnext/erpnext/config/non_profit.py +33',b'Memebership Type Details',b'Podatki o tipu memebership'
+b'DocType: Delivery Note',"b""Customer's Purchase Order No""",b'Stranke Naro\xc4\x8dilo Ne'
+b'DocType: Budget',b'Budget Against',b'prora\xc4\x8dun proti'
+b'DocType: Employee',b'Cell Number',b'\xc5\xa0tevilo celic'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +450',"b""There's no employee for the given criteria. Check that Salary Slips have not already been created.""","b'Za dolo\xc4\x8dena merila ni nobenega zaposlenega. Preverite, da pla\xc4\x8dilne liste \xc5\xa1e niso bile ustvarjene.'"
+b'apps/erpnext/erpnext/stock/reorder_item.py +194',b'Auto Material Requests Generated',b'Auto Material Zahteve Izdelano'
+b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7',b'Lost',b'Lost'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152',"b""You can not enter current voucher in 'Against Journal Entry' column""","b'Ne, ne more vstopiti trenutno bon v &quot;Proti listu vstopa&quot; stolpcu'"
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50',b'Reserved for manufacturing',b'Rezervirano za proizvodnjo'
+b'DocType: Soil Texture',b'Sand',b'Pesek'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25',b'Energy',b'Energy'
+b'DocType: Opportunity',b'Opportunity From',b'Prilo\xc5\xbenost Od'
+b'apps/erpnext/erpnext/config/hr.py +98',b'Monthly salary statement.',b'Mese\xc4\x8dno poro\xc4\x8dilo o izpla\xc4\x8danih pla\xc4\x8dah.'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +887',b'Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.',"b'Vrstica {0}: {1} Serijske \xc5\xa1tevilke, potrebne za postavko {2}. Dali ste {3}.'"
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79',b'Please select a table',b'Izberite tabelo'
+b'DocType: BOM',b'Website Specifications',b'Spletna Specifikacije'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78',"b""{0} is an invalid email address in 'Recipients'""",b'{0} je neveljaven e-po\xc5\xa1tni naslov med \xc2\xbbPrejemniki\xc2\xab'
+b'DocType: Special Test Items',b'Particulars',b'Podrobnosti'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24',b'{0}: From {0} of type {1}',b'{0}: Od {0} tipa {1}'
+b'DocType: Warranty Claim',b'CI-',b'Ci'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +300',b'Row {0}: Conversion Factor is mandatory',b'Vrstica {0}: Factor Pretvorba je obvezna'
+b'DocType: Student',b'A+',b'A +'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +344',"b'Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}'","b'Ve\xc4\x8d Cena Pravila obstaja z enakimi merili, se re\xc5\xa1ujejo spore z dodelitvijo prednost. Cena Pravila: {0}'"
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +519',b'Cannot deactivate or cancel BOM as it is linked with other BOMs',b'Ne more izklju\xc4\x8diti ali preklicati BOM saj je povezan z drugimi BOMs'
+b'DocType: Asset',b'Maintenance',b'Vzdr\xc5\xbeevanje'
+b'DocType: Item Attribute Value',b'Item Attribute Value',b'Postavka Lastnost Vrednost'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +406',b'Please Update your Project Status',b'Posodobite svoj status projekta'
+b'DocType: Item',b'Maximum sample quantity that can be retained',"b'Najve\xc4\x8dja koli\xc4\x8dina vzorca, ki jo je mogo\xc4\x8de obdr\xc5\xbeati'"
+b'DocType: Project Update',b'How is the Project Progressing Right Now?',b'Kako se projekt napreduje prav zdaj?'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +418',b'Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3}',b'Vrstice {0} # Element {1} ni mogo\xc4\x8de prenesti ve\xc4\x8d kot {2} proti naro\xc4\x8dilnici {3}'
+b'apps/erpnext/erpnext/config/selling.py +158',b'Sales campaigns.',b'Prodajne akcije.'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +117',b'Make Timesheet',b'Ustvari evidenco prisotnosti'
+b'DocType: Sales Taxes and Charges Template',"b'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.\n\n#### Note\n\nThe 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.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **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.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. 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).\n9. 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.'","b'Standardna dav\xc4\x8dna predlogo, ki se lahko uporablja za vse prodajne transakcije. To predlogo lahko vsebuje seznam dav\xc4\x8dnih glavami in tudi druge glave stro\xc5\xa1ek / dohodki, kot so &quot;Shipping&quot;, &quot;zavarovanje&quot;, &quot;Ravnanje&quot; itd #### Opomba dav\xc4\x8dno stopnjo, ki jo dolo\xc4\x8dite tu bo standard dav\xc4\x8dna stopnja za vse ** Postavke **. \xc4\x8ce obstajajo ** Items **, ki imajo razli\xc4\x8dne stopnje, ki jih je treba dodati v ** Element davku ** miza v ** Element ** mojstra. #### Opis Stolpci 1. Vrsta Izra\xc4\x8dun: - To je lahko na ** Net Total ** (to je vsota osnovnega zneska). - ** Na prej\xc5\xa1nje vrstice Total / Znesek ** (za kumulativnih davkov ali dajatev). \xc4\x8ce izberete to mo\xc5\xbenost, bo davek treba uporabiti kot odstotek prej\xc5\xa1nje vrstice (dav\xc4\x8dne tabele) znesek ali skupaj. - ** Dejanska ** (kot je omenjeno). 2. Ra\xc4\x8dun Head: The knjiga ra\xc4\x8dun, pod katerimi se bodo rezervirana ta davek 3. stro\xc5\xa1kovni center: \xc4\x8ce davek / pristojbina je prihodek (kot ladijski promet) ali odhodek je treba rezervirana proti centru stro\xc5\xa1kov. 4. Opis: Opis davka (bo, da se natisne v faktur / narekovajev). 5. stopnja: Dav\xc4\x8dna stopnja. 6. Znesek: Dav\xc4\x8dna znesek. 7. Skupaj: Kumulativno do te to\xc4\x8dke. 8. Vnesite Row: \xc4\x8ce je na osnovi &quot;Prej\xc5\xa1nji Row Total&quot; lahko izberete \xc5\xa1tevilko vrstice, ki bo sprejet kot osnova za ta izra\xc4\x8dun (privzeta je prej\xc5\xa1nja vrstica). 9. Ali je to DDV vklju\xc4\x8den v osnovni stopnji ?: \xc4\x8ce preverite to, to pomeni, da ta davek ne bo prikazan pod tabelo postavk, vendar bodo vklju\xc4\x8deni v osnovne stopnje v svoji glavni element tabele. To je uporabno, kadar \xc5\xbeelite dati ravno ceno (vklju\xc4\x8dno z vsemi davki) ceno za kupce.'"
+b'DocType: Employee',b'Bank A/C No.',b'Bank A / C No.'
+b'DocType: Bank Guarantee',b'Project',b'Projekt'
+b'DocType: Quality Inspection Reading',b'Reading 7',b'Branje 7'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9',b'Partially Ordered',b'delno \xc5\xbd'
+b'DocType: Lab Test',b'Lab Test',b'Lab Test'
+b'DocType: Student Report Generation Tool',b'Student Report Generation Tool',b'Orodje za generiranje \xc5\xa1tudentskega poro\xc4\x8dila'
+b'DocType: Expense Claim Detail',b'Expense Claim Type',b'Expense Zahtevek Type'
+b'DocType: Shopping Cart Settings',b'Default settings for Shopping Cart',b'Privzete nastavitve za Ko\xc5\xa1arica'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +27',b'Add Timeslots',b'Dodaj Timeslots'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138',b'Asset scrapped via Journal Entry {0}',b'Sredstvo izlo\xc4\x8deni preko Journal Entry {0}'
+b'DocType: Employee Loan',b'Interest Income Account',b'Prihodki od obresti ra\xc4\x8dun'
+b'apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58',b'Review Invitation Sent',b'Povabljeni vabilo'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13',b'Biotechnology',b'Biotehnologija'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109',b'Office Maintenance Expenses',b'Pisarni\xc5\xa1ka Vzdr\xc5\xbeevanje Stro\xc5\xa1ki'
+b'apps/erpnext/erpnext/utilities/user_progress.py +54',b'Go to ',b'Pojdi do'
+b'apps/erpnext/erpnext/config/learn.py +47',b'Setting up Email Account',b'Nastavitev e-po\xc5\xa1tnega ra\xc4\x8duna'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21',b'Please enter Item first',"b'Prosimo, da najprej vnesete artikel'"
+b'DocType: Asset Repair',b'Downtime',b'Odmore'
+b'DocType: Account',b'Liability',b'Odgovornost'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +220',b'Sanctioned Amount cannot be greater than Claim Amount in Row {0}.',b'Sankcionirano Znesek ne sme biti ve\xc4\x8dja od \xc5\xa1kodnega Znesek v vrstici {0}.'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11',b'Academic Term: ',b'Akademski izraz:'
+b'DocType: Salary Detail',b'Do not include in total',b'Ne vklju\xc4\x8dite v celoti'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +206',b'Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series',"b'Prosimo, nastavite imena serije za {0} prek Setup&gt; Settings&gt; Series Naming'"
+b'DocType: Company',b'Default Cost of Goods Sold Account',b'Privzeto Nabavna vrednost prodanega blaga ra\xc4\x8dun'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1019',b'Sample quantity {0} cannot be more than received quantity {1}',b'Koli\xc4\x8dina vzorca {0} ne sme biti ve\xc4\x8dja od prejete koli\xc4\x8dine {1}'
+b'apps/erpnext/erpnext/stock/get_item_details.py +369',b'Price List not selected',b'Cenik ni izbrana'
+b'DocType: Employee',b'Family Background',b'Dru\xc5\xbeina Ozadje'
+b'DocType: Request for Quotation Supplier',b'Send Email',b'Po\xc5\xa1lji e-po\xc5\xa1to'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +228',b'Warning: Invalid Attachment {0}',b'Opozorilo: Invalid Attachment {0}'
+b'DocType: Item',b'Max Sample Quantity',b'Max vzor\xc4\x8dna koli\xc4\x8dina'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +766',b'No Permission',b'Ne Dovoljenje'
+b'DocType: Vital Signs',b'Heart Rate / Pulse',b'Sr\xc4\x8dni utrip / pulz'
+b'DocType: Company',b'Default Bank Account',b'Privzeti ban\xc4\x8dni ra\xc4\x8dun'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +59',"b'To filter based on Party, select Party Type first'","b'Za filtriranje, ki temelji na stranke, da izberete Party Vnesite prvi'"
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48',"b""'Update Stock' can not be checked because items are not delivered via {0}""","b""'Posodobi zalogo' ne more biti izbrano, saj artikli niso dostavljeni prek {0}"""
+b'DocType: Vehicle',b'Acquisition Date',b'pridobitev Datum'
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Nos',b'Nos'
+b'DocType: Item',b'Items with higher weightage will be shown higher',b'Postavke z vi\xc5\xa1jo weightage bo prikazan vi\xc5\xa1je'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14',b'Lab Tests and Vital Signs',b'Laboratorijski testi in vitalni znaki'
+b'DocType: Bank Reconciliation Detail',b'Bank Reconciliation Detail',b'Banka Sprava Detail'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +614',b'Row #{0}: Asset {1} must be submitted',b'Row # {0}: Asset {1} je treba predlo\xc5\xbeiti'
+b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40',b'No employee found',b'Najdenih ni delavec'
+b'DocType: Subscription',b'Stopped',b'Ustavljen'
+b'DocType: Item',b'If subcontracted to a vendor',b'\xc4\x8ce podizvajanje prodajalca'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111',b'Student Group is already updated.',b'\xc5\xa0tudent Skupina je \xc5\xbee posodobljen.'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111',b'Student Group is already updated.',b'\xc5\xa0tudent Skupina je \xc5\xbee posodobljen.'
+b'apps/erpnext/erpnext/config/projects.py +18',b'Project Update.',b'Posodobitev projekta.'
+b'DocType: SMS Center',b'All Customer Contact',b'Vse Customer Contact'
+b'DocType: Land Unit',b'Tree Details',b'drevo Podrobnosti'
+b'DocType: Training Event',b'Event Status',b'Status dogodek'
+b'DocType: Volunteer',b'Availability Timeslot',b'Razpolo\xc5\xbeljivost Timeslot'
+,b'Support Analytics',b'Podpora Analytics'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +365',"b'If you have any questions, please get back to us.'","b'\xc4\x8ce imate kakr\xc5\xa1nakoli vpra\xc5\xa1anja, vas prosimo, da nazaj k nam.'"
+b'DocType: Cash Flow Mapper',b'Cash Flow Mapper',b'Mapper za denarni tok'
+b'DocType: Item',b'Website Warehouse',b'Spletna stran Skladi\xc5\xa1\xc4\x8de'
+b'DocType: Payment Reconciliation',b'Minimum Invoice Amount',b'Minimalna Znesek ra\xc4\x8duna'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111',b'{0} {1}: Cost Center {2} does not belong to Company {3}',b'{0} {1}: Stro\xc5\xa1kovno mesto {2} ne pripada dru\xc5\xbebi {3}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +92',b'Upload your letter head (Keep it web friendly as 900px by 100px)',b'Nalo\xc5\xbeite glavo glave (ohranite spletno prijazen kot 900 slikovnih pik za 100 pik)'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88',b'{0} {1}: Account {2} cannot be a Group',b'{0} {1}: ra\xc4\x8dun {2} ne more biti skupina'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63',"b""Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table""",b'To\xc4\x8dka Row {idx} {DOCTYPE} {DOCNAME} ne obstaja v zgoraj &#39;{DOCTYPE} &quot;tabela'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +295',b'Timesheet {0} is already completed or cancelled',"b'Timesheet {0}, je \xc5\xbee kon\xc4\x8dana ali preklicana'"
+b'apps/erpnext/erpnext/templates/pages/projects.html +42',b'No tasks',b'ni opravil'
+b'DocType: Item Variant Settings',b'Copy Fields to Variant',b'Kopiraj polja v Variant'
+b'DocType: Asset',b'Opening Accumulated Depreciation',b'Odpiranje nabrano amortizacijo'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49',b'Score must be less than or equal to 5',b'Rezultat mora biti manj\xc5\xa1a od ali enaka 5'
+b'DocType: Program Enrollment Tool',b'Program Enrollment Tool',b'Program Vpis orodje'
+b'apps/erpnext/erpnext/config/accounts.py +335',b'C-Form records',b'Zapisi C-Form'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +73',b'The shares already exist',b'Delnice \xc5\xbee obstajajo'
+b'apps/erpnext/erpnext/config/selling.py +316',b'Customer and Supplier',b'Kupec in dobavitelj'
+b'DocType: Email Digest',b'Email Digest Settings',b'E-po\xc5\xa1ta Digest Nastavitve'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +367',b'Thank you for your business!',b'Hvala za va\xc5\xa1 posel!'
+b'apps/erpnext/erpnext/config/support.py +12',b'Support queries from customers.',b'Podpora poizvedbe strank.'
+b'DocType: Setup Progress Action',b'Action Doctype',b'Dejanje Doctype'
+b'DocType: HR Settings',b'Retirement Age',b'upokojitvena starost'
+b'DocType: Bin',b'Moving Average Rate',b'Moving Average Rate'
+b'DocType: Production Plan',b'Select Items',b'Izberite Items'
+b'DocType: Share Transfer',b'To Shareholder',b'Za delni\xc4\x8darja'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372',b'{0} against Bill {1} dated {2}',b'{0} za Ra\xc4\x8dun {1} z dne {2}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +27',b'Setup Institution',b'Namestitvena ustanova'
+b'DocType: Program Enrollment',b'Vehicle/Bus Number',b'Vozila / Bus \xc5\xa1tevilka'
+b'apps/erpnext/erpnext/education/doctype/course/course.js +17',b'Course Schedule',b'Razpored za golf'
+b'DocType: Request for Quotation Supplier',b'Quote Status',b'Citiraj stanje'
+b'DocType: GoCardless Settings',b'Webhooks Secret',b'Webhooks Secret'
+b'DocType: Maintenance Visit',b'Completion Status',b'Zaklju\xc4\x8dek Status'
+b'DocType: Daily Work Summary Group',b'Select Users',b'Izberite Uporabniki'
+b'DocType: Hotel Room Pricing Item',b'Hotel Room Pricing Item',b'Postavka hotelske sobe'
+b'DocType: HR Settings',b'Enter retirement age in years',b'Vnesite upokojitveno starost v letih'
+b'DocType: Crop',b'Target Warehouse',b'Ciljna Skladi\xc5\xa1\xc4\x8de'
+b'DocType: Payroll Employee Detail',b'Payroll Employee Detail',b'Detajl zaposlenih zaposlenih'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128',b'Please select a warehouse',b'Izberite skladi\xc5\xa1\xc4\x8de'
+b'DocType: Cheque Print Template',b'Starting location from left edge',b'Izhajajo\xc4\x8d lokacijo od levega roba'
+b'DocType: Item',b'Allow over delivery or receipt upto this percent',b'Dovoli nad dostavo ali prejem upto tem odstotkov'
+b'DocType: Stock Entry',b'STE-',b'STE-'
+b'DocType: Upload Attendance',b'Import Attendance',b'Uvoz Udele\xc5\xbeba'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +124',b'All Item Groups',b'Vse Postavka Skupine'
+b'apps/erpnext/erpnext/config/setup.py +89',b'Automatically compose message on submission of transactions.',b'Samodejno sestavite sporo\xc4\x8dilo o predlo\xc5\xbeitvi transakcij.'
+b'DocType: Work Order',b'Item To Manufacture',b'Postavka za izdelavo'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44',b'CompteLib',b'CompteLib'
+b'apps/erpnext/erpnext/buying/utils.py +80',b'{0} {1} status is {2}',b'{0} {1} status {2}'
+b'DocType: Water Analysis',b'Collection Temperature ',b'Zbirna temperatura'
+b'DocType: Employee',b'Provide Email Address registered in company',b'Navedite e-po\xc5\xa1tni naslov je registriran v podjetju'
+b'DocType: Shopping Cart Settings',b'Enable Checkout',b'Omogo\xc4\x8di Checkout'
+b'apps/erpnext/erpnext/config/learn.py +202',b'Purchase Order to Payment',b'Nakup naro\xc4\x8dila do pla\xc4\x8dila'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48',b'Projected Qty',b'Predvidoma Kol'
+b'DocType: Sales Invoice',b'Payment Due Date',b'Datum zapadlosti'
+b'DocType: Drug Prescription',b'Interval UOM',b'Interval UOM'
+b'DocType: Customer',"b'Reselect, if the chosen address is edited after save'","b'Ponovno izberite, \xc4\x8de je izbrani naslov urejen po shranjevanju'"
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +522',b'Item Variant {0} already exists with same attributes',b'Postavka Variant {0} \xc5\xbee obstaja z enakimi atributi'
+b'DocType: Item',b'Hub Publishing Details',b'Podrobnosti o objavi vozli\xc5\xa1\xc4\x8da'
+b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +117',"b""'Opening'""",b'&quot;Odpiranje&quot;'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130',b'Open To Do',b'Odpri storiti'
+b'DocType: Notification Control',b'Delivery Note Message',b'Dostava Opomba Sporo\xc4\x8dilo'
+b'DocType: Lab Test Template',b'Result Format',b'Format zapisa'
+b'DocType: Expense Claim',b'Expenses',b'Stro\xc5\xa1ki'
+b'DocType: Item Variant Attribute',b'Item Variant Attribute',b'Postavka Variant Lastnost'
+,b'Purchase Receipt Trends',b'Nakup Prejem Trendi'
+b'DocType: Payroll Entry',b'Bimonthly',b'vsaka dva meseca'
+b'DocType: Vehicle Service',b'Brake Pad',b'Brake Pad'
+b'DocType: Fertilizer',b'Fertilizer Contents',b'Vsebina gnojil'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119',b'Research & Development',b'Raziskave in razvoj'
+b'apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20',b'Amount to Bill',b'Znesek za Bill'
+b'DocType: Company',b'Registration Details',b'Podrobnosti registracije'
+b'DocType: Timesheet',b'Total Billed Amount',b'Skupaj zara\xc4\x8dunano Znesek'
+b'DocType: Item Reorder',b'Re-Order Qty',b'Ponovno naro\xc4\x8dila Kol'
+b'DocType: Leave Block List Date',b'Leave Block List Date',b'Pustite Block List Datum'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +94',b'BOM #{0}: Raw material cannot be same as main Item',b'BOM # {0}: Surovina ne more biti enaka kot glavna postavka'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +92',b'Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges',b'Skupaj veljavnih cenah na Potrdilo o nakupu postavke tabele mora biti enaka kot Skupaj davkov in dajatev'
+b'DocType: Sales Team',b'Incentives',b'Spodbude'
+b'DocType: SMS Log',b'Requested Numbers',b'Zahtevane \xc5\xa1tevilke'
+b'DocType: Volunteer',b'Evening',b'Ve\xc4\x8der'
+b'DocType: Customer',b'Bypass credit limit check at Sales Order',b'Obvezno preverjanje kreditne omejitve pri prodajni nalogi'
+b'apps/erpnext/erpnext/config/hr.py +147',b'Performance appraisal.',b'Cenitev uspe\xc5\xa1nosti.'
+b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +100',"b""Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart""","b'Omogo\xc4\x8danje &quot;uporabiti za ko\xc5\xa1arico&quot;, kot je omogo\xc4\x8deno Ko\xc5\xa1arica in da mora biti vsaj ena Dav\xc4\x8dna pravilo za Ko\xc5\xa1arica'"
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +412',"b'Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.'","b'Pla\xc4\x8dilo Za\xc4\x8detek {0} je povezan proti odredbi {1}, preverite, \xc4\x8de je treba izvle\xc4\x8di, kot prej v tem ra\xc4\x8dunu.'"
+b'DocType: Sales Invoice Item',b'Stock Details',b'Stock Podrobnosti'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29',b'Project Value',b'Project Value'
+b'apps/erpnext/erpnext/config/selling.py +326',b'Point-of-Sale',b'Prodajno mesto'
+b'DocType: Fee Schedule',b'Fee Creation Status',b'Status ustvarjanja provizije'
+b'DocType: Vehicle Log',b'Odometer Reading',b'Stanje kilometrov'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +116',"b""Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'""","b'Stanje na ra\xc4\x8dunu je \xc5\xbee v ""kredit"", ni dovoljeno nastaviti ""Stanje mora biti"" kot ""bremenitev""'"
+b'DocType: Account',b'Balance must be',b'Ravnote\xc5\xbeju mora biti'
+b'DocType: Hub Settings',b'Publish Pricing',b'Objavite Pricing'
+b'DocType: Notification Control',b'Expense Claim Rejected Message',b'Expense zahtevek zavrnjen Sporo\xc4\x8dilo'
+,b'Available Qty',b'Na voljo Koli\xc4\x8dina'
+b'DocType: Purchase Taxes and Charges',b'On Previous Row Total',b'Na prej\xc5\xa1nje vrstice Skupaj'
+b'DocType: Purchase Invoice Item',b'Rejected Qty',b'zavrnjen Kol'
+b'DocType: Setup Progress Action',b'Action Field',b'Polje delovanja'
+b'DocType: Healthcare Settings',b'Manage Customer',b'Upravljajte stranko'
+b'DocType: Delivery Trip',b'Delivery Stops',b'Dobavni izklopi'
+b'DocType: Salary Slip',b'Working Days',b'Delovni dnevi'
+b'DocType: Serial No',b'Incoming Rate',b'Dohodni Rate'
+b'DocType: Packing Slip',b'Gross Weight',b'Bruto Te\xc5\xbea'
+,b'Final Assessment Grades',b'Kon\xc4\x8dne ocene'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47',b'Enable Hub',b'Omogo\xc4\x8di Hub'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +110',b'The name of your company for which you are setting up this system.',"b'Ime va\xc5\xa1ega podjetja, za katero ste vzpostavitvijo tega sistema.'"
+b'DocType: HR Settings',b'Include holidays in Total no. of Working Days',b'Vklju\xc4\x8di po\xc4\x8ditnice v Total no. delovnih dni'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108',b'Setup your Institute in ERPNext',b'Nastavite svoj in\xc5\xa1titut v ERPNext'
+b'DocType: Agriculture Analysis Criteria',b'Plant Analysis',b'Analiza rastlin'
+b'DocType: Job Applicant',b'Hold',b'Dr\xc5\xbei'
+b'DocType: Project Update',b'Progress Details',b'Podrobnosti o napredku'
+b'DocType: Employee',b'Date of Joining',b'Datum pridru\xc5\xbeitve'
+b'DocType: Naming Series',b'Update Series',b'Posodobi zaporedje'
+b'DocType: Supplier Quotation',b'Is Subcontracted',b'Je v podizvajanje'
+b'DocType: Restaurant Table',b'Minimum Seating',b'Najmanj\xc5\xa1e \xc5\xa1tevilo sede\xc5\xbeev'
+b'DocType: Item Attribute',b'Item Attribute Values',b'Postavka Lastnost Vrednote'
+b'DocType: Examination Result',b'Examination Result',b'Preizkus Rezultat'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +845',b'Purchase Receipt',b'Potrdilo o nakupu'
+,b'Received Items To Be Billed',b'Prejete Postavke placevali'
+b'apps/erpnext/erpnext/config/accounts.py +303',b'Currency exchange rate master.',b'Menjalnega te\xc4\x8daja valute gospodar.'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209',b'Reference Doctype must be one of {0}',b'Referen\xc4\x8dna DOCTYPE mora biti eden od {0}'
+b'apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js +46',b'Filter Total Zero Qty',b'Filter Total Zero Qty'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +341',b'Unable to find Time Slot in the next {0} days for Operation {1}',b'Ni mogo\xc4\x8de najti terminu v naslednjih {0} dni za delovanje {1}'
+b'DocType: Work Order',b'Plan material for sub-assemblies',b'Plan material za sklope'
+b'apps/erpnext/erpnext/config/selling.py +97',b'Sales Partners and Territory',b'Prodajni partnerji in ozemelj'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +600',b'BOM {0} must be active',b'BOM {0} mora biti aktiven'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +414',b'No Items available for transfer',b'Ni razpolo\xc5\xbeljivih elementov za prenos'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +218',b'Closing (Opening + Total)',b'Zapiranje (odpiranje + skupno)'
+b'DocType: Journal Entry',b'Depreciation Entry',b'Amortizacija Za\xc4\x8detek'
+b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32',b'Please select the document type first',"b'Prosimo, najprej izberite vrsto dokumenta'"
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65',b'Cancel Material Visits {0} before cancelling this Maintenance Visit',b'Preklic Material Obiski {0} pred preklicem to vzdr\xc5\xbeevanje obisk'
+b'DocType: Crop Cycle',b'ISO 8016 standard',b'ISO 8016 standard'
+b'DocType: Pricing Rule',b'Rate or Discount',b'Stopnja ali popust'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213',b'Serial No {0} does not belong to Item {1}',b'Serijska \xc5\xa1t {0} ne pripada postavki {1}'
+b'DocType: Purchase Receipt Item Supplied',b'Required Qty',b'Zahtevani Kol'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +126',b'Warehouses with existing transaction can not be converted to ledger.',b'Skladi\xc5\xa1\xc4\x8da z obstoje\xc4\x8dim poslom ni mogo\xc4\x8de pretvoriti v knjigi.'
+b'DocType: Bank Reconciliation',b'Total Amount',b'Skupni znesek'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32',b'Internet Publishing',b'Internet Zalo\xc5\xbeni\xc5\xa1tvo'
+b'DocType: Prescription Duration',b'Number',b'\xc5\xa0tevilka'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25',b'Creating {0} Invoice',b'Ustvarjanje ra\xc4\x8duna {0}'
+b'DocType: Medical Code',b'Medical Code Standard',b'Standard medicinske oznake'
+b'DocType: Soil Texture',b'Clay Composition (%)',b'Glina Sestava (%)'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81',b'Please save before assigning task.',"b'Prosimo, shranite, preden dodelite nalogo.'"
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +74',b'Balance Value',b'Balance Vrednost'
+b'DocType: Lab Test',b'Lab Technician',b'Laboratorijski tehnik'
+b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38',b'Sales Price List',b'Prodaja Cenik'
+b'DocType: Healthcare Settings',"b'If checked, a customer will be created, mapped to Patient.\nPatient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.'","b'\xc4\x8ce je ozna\xc4\x8deno, bo stranka ustvarjena, mapirana na Patient. Pacientovi ra\xc4\x8duni bodo ustvarjeni proti tej Stranki. Med ustvarjanjem bolnika lahko izberete tudi obstoje\xc4\x8do stranko.'"
+b'DocType: Bank Reconciliation',b'Account Currency',b'Valuta ra\xc4\x8duna'
+b'DocType: Lab Test',b'Sample ID',b'Vzorec ID'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +167',b'Please mention Round Off Account in Company',b'Navedite zaokro\xc5\xbeijo ra\xc4\x8dun v dru\xc5\xbebi'
+b'DocType: Purchase Receipt',b'Range',b'Razpon'
+b'DocType: Supplier',b'Default Payable Accounts',b'Privzete pla\xc4\x8duje ra\xc4\x8dunov'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49',b'Employee {0} is not active or does not exist',b'Employee {0} ni aktiven ali pa ne obstaja'
+b'DocType: Fee Structure',b'Components',b'komponente'
+b'DocType: Item Barcode',b'Item Barcode',b'Postavka Barcode'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +329',b'Please enter Asset Category in Item {0}',b'Vnesite Asset Kategorija to\xc4\x8dke {0}'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +661',b'Item Variants {0} updated',b'Postavka Variante {0} posodobljen'
+b'DocType: Quality Inspection Reading',b'Reading 6',b'Branje 6'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9',"b'to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field\nof this'","b'ki se generirajo. \xc4\x8ce je odlo\xc5\xbeeno, boste morali ro\xc4\x8dno spremeniti polje \xc2\xbbPonovi na dan v mesecu\xc2\xab tega'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +961',b'Cannot {0} {1} {2} without any negative outstanding invoice',"b'Ne more {0} {1} {2}, brez kakr\xc5\xa1ne koli negativne izjemno ra\xc4\x8dun'"
+b'DocType: Share Transfer',b'From Folio No',b'Iz Folio No'
+b'DocType: Purchase Invoice Advance',b'Purchase Invoice Advance',b'Nakup ra\xc4\x8duna Advance'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199',b'Row {0}: Credit entry can not be linked with a {1}',b'Vrstica {0}: Credit vnos ni mogo\xc4\x8de povezati z {1}'
+b'apps/erpnext/erpnext/config/accounts.py +246',b'Define budget for a financial year.',b'Dolo\xc4\x8dite prora\xc4\x8duna za prora\xc4\x8dunsko leto.'
+b'DocType: Lead',b'LEAD-',b'PONUDBA-'
+b'DocType: Employee',b'Permanent Address Is',b'Stalni naslov je'
+b'DocType: Work Order Operation',b'Operation completed for how many finished goods?',"b'Operacija zaklju\xc4\x8dena, za koliko kon\xc4\x8dnih izdelkov?'"
+b'DocType: Payment Terms Template',b'Payment Terms Template',b'Predloga za pla\xc4\x8dilni pogoji'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +51',b'The Brand',b'Brand'
+b'DocType: Employee',b'Exit Interview Details',b'Exit Intervju Podrobnosti'
+b'DocType: Item',b'Is Purchase Item',b'Je Nakup Postavka'
+b'DocType: Journal Entry Account',b'Purchase Invoice',b'Nakup Ra\xc4\x8dun'
+b'DocType: Stock Ledger Entry',b'Voucher Detail No',b'Bon Detail Ne'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +789',b'New Sales Invoice',b'Nov ra\xc4\x8dun'
+b'DocType: Stock Entry',b'Total Outgoing Value',b'Skupaj Odhodni Vrednost'
+b'DocType: Physician',b'Appointments',b'Imenovanja'
+b'apps/erpnext/erpnext/public/js/account_tree_grid.js +223',b'Opening Date and Closing Date should be within same Fiscal Year',b'Pri\xc4\x8detek in rok bi moral biti v istem prora\xc4\x8dunskem letu'
+b'DocType: Lead',b'Request for Information',b'Zahteva za informacije'
+,b'LeaderBoard',b'leaderboard'
+b'DocType: Sales Invoice Item',b'Rate With Margin (Company Currency)',b'Stopnja z mar\xc5\xbeo (valuta podjetja)'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +802',b'Sync Offline Invoices',b'Sinhronizacija Offline Ra\xc4\x8duni'
+b'DocType: Payment Request',b'Paid',b'Pla\xc4\x8dan'
+b'DocType: Program Fee',b'Program Fee',b'Cena programa'
+b'DocType: BOM Update Tool',"b'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.\nIt also updates latest price in all the BOMs.'","b'Zamenjajte dolo\xc4\x8deno BOM v vseh drugih BOM, kjer se uporablja. Zamenjal bo staro povezavo BOM, posodobiti stro\xc5\xa1ke in obnovil tabelo &quot;BOM eksplozijsko blago&quot; v skladu z novim BOM. Prav tako posodablja najnovej\xc5\xa1o ceno v vseh BOM.'"
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +447',b'The following Work Orders were created:',b'Ustvarjene so bile naslednje delovne naloge:'
+b'DocType: Salary Slip',b'Total in words',b'Skupaj z besedami'
+b'DocType: Material Request Item',b'Lead Time Date',b'Lead Time Datum'
+,b'Employee Advance Summary',b'Povzetek zaposlenih'
+b'DocType: Asset',b'Available-for-use Date',"b'Datum, ki je na voljo za uporabo'"
+b'DocType: Guardian',b'Guardian Name',b'Ime Guardian'
+b'DocType: Cheque Print Template',b'Has Print Format',b'Ima format tiskanja'
+b'DocType: Employee Loan',b'Sanctioned',b'sankcionirano'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +75',b' is mandatory. Maybe Currency Exchange record is not created for ',b'je obvezna. Mogo\xc4\x8de Menjalni zapis ni ustvarjen za'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +139',b'Row #{0}: Please specify Serial No for Item {1}',b'Vrstica # {0}: Navedite Zaporedna \xc5\xa1tevilka za postavko {1}'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54',b'Supplier &gt; Supplier Type',b'Dobavitelj&gt; Dobavitelj tip'
+b'DocType: Crop Cycle',b'Crop Cycle',b'Crop Crop'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +633',"b""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.""","b'Za &quot;izdelek Bundle &#39;predmetov, skladi\xc5\xa1\xc4\x8de, serijska \xc5\xa1tevilka in serijska se ne \xc5\xa1teje od&quot; seznam vsebine &quot;mizo. \xc4\x8ce so skladi\xc5\xa1\xc4\x8da in serija ni enaka za vso embala\xc5\xbeo postavke za kakr\xc5\xa1no koli &quot;izdelek Bundle &#39;postavko, lahko te vrednosti je treba vnesti v glavnem Element tabele, bodo vrednosti, ki se kopira na&quot; seznam vsebine &quot;mizo.'"
+b'DocType: Student Admission',b'Publish on website',b'Objavi na spletni strani'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651',b'Supplier Invoice Date cannot be greater than Posting Date',b'Datum dobavitelj na ra\xc4\x8dunu ne sme biti ve\xc4\x8dja od Napotitev Datum'
+b'DocType: Purchase Invoice Item',b'Purchase Order Item',b'Naro\xc4\x8dilnica item'
+b'DocType: Agriculture Task',b'Agriculture Task',b'Kmetijska naloga'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132',b'Indirect Income',b'Posredna Prihodki'
+b'DocType: Student Attendance Tool',b'Student Attendance Tool',b'\xc5\xa0tudent Udele\xc5\xbeba orodje'
+b'DocType: Restaurant Menu',b'Price List (Auto created)',b'Cenik (samodejno ustvarjen)'
+b'DocType: Cheque Print Template',b'Date Settings',b'Datum Nastavitve'
+b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48',b'Variance',b'Variance'
+,b'Company Name',b'ime podjetja'
+b'DocType: SMS Center',b'Total Message(s)',b'Skupaj sporo\xc4\x8dil (-i)'
+b'DocType: Share Balance',b'Purchased',b'Nakup'
+b'DocType: Item Variant Settings',b'Rename Attribute Value in Item Attribute.',b'Preimenuj atribut vrednosti atributa elementa.'
+b'DocType: Purchase Invoice',b'Additional Discount Percentage',b'Dodatni popust Odstotek'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24',b'View a list of all the help videos',b'Oglejte si seznam vseh videoposnetkov pomo\xc4\x8djo'
+b'DocType: Agriculture Analysis Criteria',b'Soil Texture',b'Tekstura za tla'
+b'DocType: Bank Reconciliation',b'Select account head of the bank where cheque was deposited.',"b'Izberite ra\xc4\x8dun vodja banke, kjer je bila deponirana pregled.'"
+b'DocType: Selling Settings',b'Allow user to edit Price List Rate in transactions',"b'Dovoli uporabniku, da uredite Cenik Ocenite v transakcijah'"
+b'DocType: Pricing Rule',b'Max Qty',b'Max Kol'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js +25',b'Print Report Card',b'Kartica za tiskanje poro\xc4\x8dila'
+b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30',"b'Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \\\n\t\t\t\t\t\tPlease enter a valid Invoice'","b'Vrstica {0}: Ra\xc4\x8dun {1} ni veljavna, se lahko prekli\xc4\x8de / ne obstaja. \\ Vnesite veljaven ra\xc4\x8dun'"
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +132',b'Row {0}: Payment against Sales/Purchase Order should always be marked as advance',b'Vrstica {0}: morala Pla\xc4\x8dilo proti prodaja / narocilo vedno ozna\xc4\x8den kot vnaprej'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16',b'Chemical',b'Chemical'
+b'DocType: Salary Component Account',b'Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.',"b'Privzeti Bank / Cash ra\xc4\x8dun bo samodejno posodobljen pla\xc4\x8d Journal Entry, ko je izbrana ta na\xc4\x8din.'"
+b'DocType: BOM',b'Raw Material Cost(Company Currency)',b'Stro\xc5\xa1kov surovin (dru\xc5\xbeba Valuta)'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +88',b'Row # {0}: Rate cannot be greater than the rate used in {1} {2}',"b'Vrstica # {0}: stopnja ne more biti ve\xc4\x8dji od stopnje, ki se uporablja pri {1} {2}'"
+b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Meter',b'meter'
+b'DocType: Workstation',b'Electricity Cost',b'Stro\xc5\xa1ki elektri\xc4\x8dne energije'
+b'apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +23',b'Lab testing datetime cannot be before collection datetime',b'Testiranje datote\xc4\x8dnega laboratorija ne more biti pred zbiranjem datetime'
+b'DocType: HR Settings',"b""Don't send Employee Birthday Reminders""",b'Ne po\xc5\xa1iljajte zaposlenih rojstnodnevnih opomnikov'
+b'DocType: Expense Claim',b'Total Advance Amount',b'Skupni znesek vnaprej'
+b'DocType: Delivery Stop',b'Estimated Arrival',b'Ocenjeni prihod'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34',b'Save Settings',b'Shrani nastavitve'
+b'DocType: Delivery Stop',b'Notified by Email',b'Obvestilo po e-po\xc5\xa1ti'
+b'DocType: Item',b'Inspection Criteria',b'Merila In\xc5\xa1pekcijske'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14',b'Transfered',b'Prenese'
+b'DocType: BOM Website Item',b'BOM Website Item',b'BOM Spletna stran Element'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +52',b'Upload your letter head and logo. (you can edit them later).',b'Nalo\xc5\xbeite svoje pismo glavo in logotip. (lahko jih uredite kasneje).'
+b'DocType: Timesheet Detail',b'Bill',b'Bill'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +88',b'Next Depreciation Date is entered as past date',b'Naslednja Amortizacija Datum je vpisana kot preteklem dnevu'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208',b'White',b'Bela'
+b'DocType: SMS Center',b'All Lead (Open)',b'Vse ponudbe (Odprte)'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +270',b'Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3})',b'Vrstica {0}: Kol ni na voljo za {4} v skladi\xc5\xa1\xc4\x8du {1} na objavo \xc4\x8das za\xc4\x8detka ({2} {3})'
+b'apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18',b'You can only select a maximum of one option from the list of check boxes.',b'Iz seznama potrditvenih polj lahko izberete najve\xc4\x8d eno mo\xc5\xbenost.'
+b'DocType: Purchase Invoice',b'Get Advances Paid',b'Get pla\xc4\x8danih predpla\xc4\x8dil'
+b'DocType: Item',b'Automatically Create New Batch',b'Samodejno Ustvari novo serijo'
+b'DocType: Item',b'Automatically Create New Batch',b'Samodejno Ustvari novo serijo'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +635',b'Assigning {0} to {1} (row {2})',b'Dodeljevanje {0} do {1} (vrstica {2})'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810',b'Make ',b'Poskrbite'
+b'DocType: Student Admission',b'Admission Start Date',b'Vstop Datum za\xc4\x8detka'
+b'DocType: Journal Entry',b'Total Amount in Words',b'Skupni znesek z besedo'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29',b'New Employee',b'Novi zaposleni'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7',"b""There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.""","b'Pri\xc5\xa1lo je do napake. Eden verjeten razlog je lahko, da niste shranili obrazec. Obrnite support@erpnext.com \xc4\x8de je te\xc5\xbeava odpravljena.'"
+b'apps/erpnext/erpnext/templates/pages/cart.html +5',b'My Cart',b'Ko\xc5\xa1arica'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +130',b'Order Type must be one of {0}',b'Sklep Tip mora biti eden od {0}'
+b'DocType: Lead',b'Next Contact Date',b'Naslednja Stik Datum'
+b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36',b'Opening Qty',b'Odpiranje Koli\xc4\x8dina'
+b'DocType: Healthcare Settings',b'Appointment Reminder',b'Opomnik o imenovanju'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +478',b'Please enter Account for Change Amount',b'Prosim vnesite ra\xc4\x8dun za znesek spremembe'
+b'DocType: Program Enrollment Tool Student',b'Student Batch Name',b'Student Serija Ime'
+b'DocType: Consultation',b'Doctor',b'Doktor'
+b'DocType: Holiday List',b'Holiday List Name',b'Naziv seznama praznikov'
+b'DocType: Repayment Schedule',b'Balance Loan Amount',b'Bilanca Znesek posojila'
+b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14',b'Schedule Course',b'urnik predmeta'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236',b'Stock Options',b'Delni\xc5\xa1kih opcij'
+b'DocType: Buying Settings',b'Disable Fetching Last Purchase Details in Purchase Order',b'Onemogo\xc4\x8di pridobivanje zadnjih podrobnosti nakupa v naro\xc4\x8dilu'
+b'DocType: Journal Entry Account',b'Expense Claim',b'Expense zahtevek'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +267',b'Do you really want to restore this scrapped asset?',b'Ali res \xc5\xbeelite obnoviti ta izlo\xc4\x8deni sredstva?'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +381',b'Qty for {0}',b'Koli\xc4\x8dina za {0}'
+b'DocType: Leave Application',b'Leave Application',b'Zapusti Application'
+b'DocType: Patient',b'Patient Relation',b'Pacientovo razmerje'
+b'apps/erpnext/erpnext/config/hr.py +80',b'Leave Allocation Tool',b'Pustite Orodje razdelitve emisijskih'
+b'DocType: Item',b'Hub Category to Publish',b'Kategorija vozli\xc5\xa1\xc4\x8da za objavo'
+b'DocType: Leave Block List',b'Leave Block List Dates',b'Pustite Block List termini'
+b'DocType: Sales Invoice',b'Billing Address GSTIN',b'Naslov za izstavitev ra\xc4\x8duna GSTIN'
+b'DocType: Assessment Plan',b'Evaluate',b'Ocenite'
+b'DocType: Workstation',b'Net Hour Rate',b'Neto urna postavka'
+b'DocType: Landed Cost Purchase Receipt',b'Landed Cost Purchase Receipt',b'Pristali Stro\xc5\xa1ki Potrdilo o nakupu'
+b'DocType: Company',b'Default Terms',b'Privzeti pogoji'
+b'DocType: Supplier Scorecard Period',b'Criteria',b'Merila'
+b'DocType: Packing Slip Item',b'Packing Slip Item',b'Pakiranje Slip Postavka'
+b'DocType: Purchase Invoice',b'Cash/Bank Account',b'Gotovina / ban\xc4\x8dni ra\xc4\x8dun'
+b'apps/erpnext/erpnext/public/js/queries.js +96',b'Please specify a {0}',b'Navedite {0}'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +73',b'Removed items with no change in quantity or value.',b'Odstranjeni deli brez spremembe koli\xc4\x8dine ali vrednosti.'
+b'DocType: Delivery Note',b'Delivery To',b'Dostava'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +415',b'Variant creation has been queued.',b'Ustvarjanje variant je bilo v \xc4\x8dakalni vrsti.'
+b'apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +100',b'Work Summary for {0}',b'Povzetek dela za {0}'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +696',b'Attribute table is mandatory',b'Lastnost miza je obvezna'
+b'DocType: Production Plan',b'Get Sales Orders',b'Pridobite prodajnih nalogov'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +68',b'{0} can not be negative',b'{0} ne more biti negativna'
+b'DocType: Training Event',b'Self-Study',b'Samo-\xc5\xa1tudija'
+b'apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +27',b'Soil compositions do not add up to 100',b'Sestavine tal ne ustvarjajo do 100'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +558',b'Discount',b'Popust'
+b'DocType: Membership',b'Membership',b'\xc4\x8clanstvo'
+b'DocType: Asset',b'Total Number of Depreciations',b'Skupno \xc5\xa1tevilo amortizacije'
+b'DocType: Sales Invoice Item',b'Rate With Margin',b'Oceni z mejo'
+b'DocType: Sales Invoice Item',b'Rate With Margin',b'Oceni z mejo'
+b'DocType: Workstation',b'Wages',b'Pla\xc4\x8de'
+b'DocType: Asset Maintenance',b'Maintenance Manager Name',b'Ime upravitelja vzdr\xc5\xbeevanja'
+b'DocType: Agriculture Task',b'Urgent',b'Nujna'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174',b'Please specify a valid Row ID for row {0} in table {1}',b'Navedite veljavno Row ID za vrstico {0} v tabeli {1}'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84',b'Unable to find variable: ',b'Ni mogo\xc4\x8de najti spremenljivke:'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +794',b'Please select a field to edit from numpad',b'Izberite polje za urejanje iz numpad'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +264',b'Cannot be a fixed asset item as Stock Ledger is created.',"b'Ne more biti postavka osnovnega sredstva, kot je ustvarjena knjiga zalog.'"
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23',b'Go to the Desktop and start using ERPNext',b'Pojdite na namizje in za\xc4\x8deti uporabljati ERPNext'
+b'DocType: Item',b'Manufacturer',b'Proizvajalec'
+b'DocType: Landed Cost Item',b'Purchase Receipt Item',b'Potrdilo o nakupu Postavka'
+b'DocType: Purchase Receipt',b'PREC-RET-',b'Prec-RET-'
+b'DocType: POS Profile',b'Sales Invoice Payment',b'Pla\xc4\x8dilo prodaja Ra\xc4\x8dun'
+b'DocType: Quality Inspection Template',b'Quality Inspection Template Name',b'Kakovostna in\xc5\xa1pekcijska preglednica Ime'
+b'DocType: Project',b'First Email',b'Prva e-po\xc5\xa1ta'
+b'DocType: Production Plan Item',b'Reserved Warehouse in Sales Order / Finished Goods Warehouse',b'Rezervirano Warehouse v Sales Order / dokon\xc4\x8danih proizvodov Warehouse'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71',b'Selling Amount',b'Prodajni Znesek'
+b'DocType: Repayment Schedule',b'Interest Amount',b'Obresti Znesek'
+b'DocType: Serial No',b'Creation Document No',b'Za ustvarjanje dokumentov ni'
+b'DocType: Share Transfer',b'Issue',b'Te\xc5\xbeava'
+b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11',b'Records',b'Zapisi'
+b'DocType: Asset',b'Scrapped',b'izlo\xc4\x8deni'
+b'DocType: Purchase Invoice',b'Returns',b'Vra\xc4\x8dila'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +42',b'WIP Warehouse',b'WIP Skladi\xc5\xa1\xc4\x8de'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195',b'Serial No {0} is under maintenance contract upto {1}',b'Serijska \xc5\xa1t {0} je pod vzdr\xc5\xbeevalne pogodbe stanuje {1}'
+b'apps/erpnext/erpnext/config/hr.py +35',b'Recruitment',b'zaposlovanje'
+b'DocType: Lead',b'Organization Name',b'Organization Name'
+b'DocType: Tax Rule',b'Shipping State',b'Dostava dr\xc5\xbeava'
+,b'Projected Quantity as Source',b'Predvidena koli\xc4\x8dina kot vir'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61',"b""Item must be added using 'Get Items from Purchase Receipts' button""",b'Postavka je treba dodati uporabo &quot;dobili predmetov iz nakupu prejemki&quot; gumb'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +858',b'Delivery Trip',b'Dostava potovanje'
+b'DocType: Student',b'A-',b'A-'
+b'DocType: Share Transfer',b'Transfer Type',b'Vrsta prenosa'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117',b'Sales Expenses',b'Prodajna Stro\xc5\xa1ki'
+b'DocType: Consultation',b'Diagnosis',b'Diagnoza'
+b'apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18',b'Standard Buying',b'Standardna nabavna'
+b'DocType: GL Entry',b'Against',b'Proti'
+b'DocType: Item',b'Default Selling Cost Center',b'Privzet stro\xc5\xa1kovni center prodaje'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +85',b'Disc',b'Disc'
+b'DocType: Sales Partner',b'Implementation Partner',b'Izvajanje Partner'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1624',b'ZIP Code',b'Po\xc5\xa1tna \xc5\xa1tevilka'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +252',b'Sales Order {0} is {1}',b'Naro\xc4\x8dilo {0} je {1}'
+b'DocType: Opportunity',b'Contact Info',b'Kontaktni podatki'
+b'apps/erpnext/erpnext/config/stock.py +319',b'Making Stock Entries',b'Izdelava Zaloga Entries'
+b'DocType: Packing Slip',b'Net Weight UOM',b'Neto te\xc5\xbea UOM'
+b'DocType: Item',b'Default Supplier',b'Privzeto Dobavitelj'
+b'DocType: Manufacturing Settings',b'Over Production Allowance Percentage',b'Nad proizvodnjo dodatku Odstotek'
+b'DocType: Employee Loan',b'Repayment Schedule',b'Povra\xc4\x8dilo Urnik'
+b'DocType: Shipping Rule Condition',b'Shipping Rule Condition',b'Pogoj dostavnega pravila'
+b'DocType: Holiday List',b'Get Weekly Off Dates',b'Get Tedenski datumov'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33',b'End Date can not be less than Start Date',b'Kon\xc4\x8dni datum ne sme biti manj\xc5\xa1i kot za\xc4\x8detni datum'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +337',"b""Invoice can't be made for zero billing hour""",b'Ra\xc4\x8dun ni mogo\xc4\x8de naro\xc4\x8diti za ni\xc4\x8delno uro zara\xc4\x8dunavanja'
+b'DocType: Sales Person',b'Select company name first.',b'Izberite ime podjetja prvi\xc4\x8d.'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +189',b'Email sent to {0}',b'E-po\xc5\xa1ta je poslana na {0}'
+b'apps/erpnext/erpnext/config/buying.py +23',b'Quotations received from Suppliers.',b'Prejete ponudbe'
+b'apps/erpnext/erpnext/config/manufacturing.py +74',b'Replace BOM and update latest price in all BOMs',b'Zamenjajte BOM in posodobite najnovej\xc5\xa1o ceno v vseh BOM'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +27',b'To {0} | {1} {2}',b'Za {0} | {1} {2}'
+b'DocType: Delivery Trip',b'Driver Name',b'Ime voznika'
+b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40',b'Average Age',b'Povpre\xc4\x8dna starost'
+b'DocType: Education Settings',b'Attendance Freeze Date',b'Udele\xc5\xbeba Freeze Datum'
+b'DocType: Education Settings',b'Attendance Freeze Date',b'Udele\xc5\xbeba Freeze Datum'
+b'apps/erpnext/erpnext/utilities/user_progress.py +110',b'List a few of your suppliers. They could be organizations or individuals.',b'Na\xc5\xa1tejte nekaj va\xc5\xa1ih dobaviteljev. Ti bi se lahko organizacije ali posamezniki.'
+b'apps/erpnext/erpnext/templates/pages/home.html +31',b'View All Products',b'Oglejte si vse izdelke'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20',b'Minimum Lead Age (Days)',b'Minimalna Svinec Starost (dnevi)'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +60',b'All BOMs',b'Vse BOMs'
+b'apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35',b'Hotel Rooms of type {0} are unavailable on {1}',b'Sobe Hotela tipa {0} niso na voljo na {1}'
+b'DocType: Patient',b'Default Currency',b'Privzeta valuta'
+b'DocType: Expense Claim',b'From Employee',b'Od zaposlenega'
+b'DocType: Driver',b'Cellphone Number',b'\xc5\xa1tevilka mobilnega telefona'
+b'DocType: Project',b'Monitor Progress',b'Spremljajte napredek'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +472',b'Warning: System will not check overbilling since amount for Item {0} in {1} is zero',b'Opozorilo: Sistem ne bo preveril previsokih saj znesek za postavko {0} v {1} je ni\xc4\x8d'
+b'DocType: Journal Entry',b'Make Difference Entry',b'Naredite Razlika Entry'
+b'DocType: Upload Attendance',b'Attendance From Date',b'Udele\xc5\xbeba Od datuma'
+b'DocType: Appraisal Template Goal',b'Key Performance Area',b'Key Uspe\xc5\xa1nost Area'
+b'DocType: Program Enrollment',b'Transportation',b'Prevoz'
+b'apps/erpnext/erpnext/controllers/item_variant.py +94',b'Invalid Attribute',b'Neveljavna Lastnost'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +240',b'{0} {1} must be submitted',b'{0} {1} je potrebno vlo\xc5\xbeiti'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159',b'Quantity must be less than or equal to {0}',b'Koli\xc4\x8dina mora biti manj\xc5\xa1a ali enaka {0}'
+b'DocType: SMS Center',b'Total Characters',b'Skupaj Znaki'
+b'DocType: Employee Advance',b'Claimed',b'Zahtevana'
+b'DocType: Crop',b'Row Spacing',b'Razmik vrstic'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +164',b'Please select BOM in BOM field for Item {0}',"b'Prosimo, izberite BOM BOM v polju za postavko {0}'"
+b'DocType: C-Form Invoice Detail',b'C-Form Invoice Detail',b'C-Form Ra\xc4\x8dun Detail'
+b'DocType: Payment Reconciliation Invoice',b'Payment Reconciliation Invoice',b'Pla\xc4\x8dilo Sprava Ra\xc4\x8dun'
+b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +38',b'Contribution %',b'Prispevek%'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215',"b""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}""","b'Kot je na Nastavitve Nakup \xc4\x8de narocilo Obvezno == &quot;DA&quot;, nato pa za ustvarjanje ra\xc4\x8dunu o nakupu, uporabniki potrebujejo za ustvarjanje naro\xc4\x8dilnice najprej za postavko {0}'"
+b'DocType: Company',b'Company registration numbers for your reference. Tax numbers etc.',b'Registracijska \xc5\xa1t. podjetja za lastno evidenco. Dav\xc4\x8dna \xc5\xa1tevilka itn.'
+b'DocType: Sales Partner',b'Distributor',b'Distributer'
+b'DocType: Shopping Cart Shipping Rule',b'Shopping Cart Shipping Rule',b'Pravilo za dostavo za ko\xc5\xa1aro'
+b'apps/erpnext/erpnext/public/js/controllers/transaction.js +71',"b""Please set 'Apply Additional Discount On'""",b'Prosim nastavite &quot;Uporabi dodatni popust na &#39;'
+,b'Ordered Items To Be Billed',b'Naro\xc4\x8deno Postavke placevali'
+b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46',b'From Range has to be less than To Range',b'Od mora biti manj Razpon kot gibala'
+b'DocType: Global Defaults',b'Global Defaults',b'Globalni Privzeto'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +230',b'Project Collaboration Invitation',b'Projekt Sodelovanje Vabilo'
+b'DocType: Salary Slip',b'Deductions',b'Odbitki'
+b'DocType: Leave Allocation',b'LAL/',b'LAL /'
+b'DocType: Setup Progress Action',b'Action Name',b'Ime dejanja'
+b'apps/erpnext/erpnext/public/js/financial_statements.js +75',b'Start Year',b'Za\xc4\x8detek Leto'
+b'apps/erpnext/erpnext/regional/india/utils.py +25',b'First 2 digits of GSTIN should match with State number {0}',b'Prvi 2 \xc5\xa1tevilki GSTIN se mora ujemati z dr\xc5\xbeavno \xc5\xa1tevilko {0}'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +68',b'PDC/LC',b'PDC / LC'
+b'DocType: Purchase Invoice',"b""Start date of current invoice's period""",b'Datum za\xc4\x8detka obdobja sedanje faktura je'
+b'DocType: Salary Slip',b'Leave Without Pay',b'Leave brez pla\xc4\x8dila'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +385',b'Capacity Planning Error',b'Kapaciteta Napaka Na\xc4\x8drtovanje'
+,b'Trial Balance for Party',b'Trial Balance za stranke'
+b'DocType: Lead',b'Consultant',b'Svetovalec'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +356',b'Parents Teacher Meeting Attendance',b'Udele\xc5\xbeba u\xc4\x8diteljev na sre\xc4\x8danju star\xc5\xa1ev'
+b'DocType: Salary Slip',b'Earnings',b'Zaslu\xc5\xbeek'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +441',b'Finished Item {0} must be entered for Manufacture type entry',b'Kon\xc4\x8dano Postavka {0} je treba vpisati za vpis tipa Proizvodnja'
+b'apps/erpnext/erpnext/config/learn.py +87',b'Opening Accounting Balance',b'Za\xc4\x8detna bilanca'
+,b'GST Sales Register',b'DDV prodaje Registracija'
+b'DocType: Sales Invoice Advance',b'Sales Invoice Advance',b'Predpla\xc4\x8dila'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +552',b'Nothing to request',b'Ni\xc4\x8d zahtevati'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +18',b'Select your Domains',b'Izberite svoje domene'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34',"b""Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3}""",b'Druga prora\xc4\x8dunska zapis &#39;{0}&#39; \xc5\xbee obstaja proti {1} &quot;{2}&quot; za poslovno leto {3}'
+b'DocType: Item Variant Settings',b'Fields will be copied over only at time of creation.',b'Polja bodo kopirana samo v \xc4\x8dasu ustvarjanja.'
+b'DocType: Setup Progress Action',b'Domains',b'Domene'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +41',"b""'Actual Start Date' can not be greater than 'Actual End Date'""","b'""Dejanski datum za\xc4\x8detka"" ne more biti novej\xc5\xa1i od ""dejanskega kon\xc4\x8dnega datuma""'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117',b'Management',b'Vodstvo'
+b'DocType: Cheque Print Template',b'Payer Settings',b'Nastavitve pla\xc4\x8dnik'
+b'DocType: Item Attribute Value',"b'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""'","b'To bo dodan To\xc4\x8dka Kodeksa variante. Na primer, \xc4\x8de je va\xc5\xa1a kratica je &quot;SM&quot;, in oznaka postavka je &quot;T-shirt&quot;, postavka koda varianto bo &quot;T-SHIRT-SM&quot;'"
+b'DocType: Salary Slip',b'Net Pay (in words) will be visible once you save the Salary Slip.',"b'Neto Pay (z besedami), bo viden, ko boste shranite pla\xc4\x8dilnega lista.'"
+b'DocType: Purchase Invoice',b'Is Return',b'Je Return'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92',b'Caution',b'Previdno'
+b'apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +17',"b""Start day is greater than end day in task '{0}'""",b'Za\xc4\x8detni dan je ve\xc4\x8dji od kon\xc4\x8dnega dne pri nalogi &#39;{0}&#39;'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +815',b'Return / Debit Note',b'Nazaj / opominu'
+b'DocType: Price List Country',b'Price List Country',b'Cenik Dr\xc5\xbeava'
+b'DocType: Item',b'UOMs',b'UOMs'
+b'apps/erpnext/erpnext/stock/utils.py +212',b'{0} valid serial nos for Item {1}',b'{0} veljavna serijska \xc5\xa1tevilka za postavko {1}'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57',b'Item Code cannot be changed for Serial No.',b'Oznaka se ne more spremeniti za Serial No.'
+b'DocType: Purchase Invoice Item',b'UOM Conversion Factor',b'UOM Conversion Factor'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40',b'Please enter Item Code to get Batch Number',b'Vnesite Koda priti Serija \xc5\xa0tevilo'
+b'DocType: Stock Settings',b'Default Item Group',b'Privzeto Element Group'
+b'DocType: Employee Loan',b'Partially Disbursed',b'delno \xc4\x8drpanju'
+b'apps/erpnext/erpnext/config/non_profit.py +73',b'Grant information.',b'Informacije o donaciji.'
+b'apps/erpnext/erpnext/config/buying.py +38',b'Supplier database.',b'Dobavitelj baze podatkov.'
+b'DocType: Account',b'Balance Sheet',b'Bilanca stanja'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +750',"b""Cost Center For Item with Item Code '""",b'Stalo Center za postavko s to\xc4\x8dko zakonika &quot;'
+b'DocType: Fee Validity',b'Valid Till',b'Veljavno do'
+b'DocType: Student Report Generation Tool',b'Total Parents Teacher Meeting',b'Skupaj u\xc4\x8diteljski sestanek star\xc5\xa1ev'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2516',"b'Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.'","b'Na\xc4\x8din pla\xc4\x8dila ni nastavljen. Prosimo, preverite, ali je bil ra\xc4\x8dun nastavljen na na\xc4\x8dinu pla\xc4\x8dila ali na POS profil.'"
+b'apps/erpnext/erpnext/buying/utils.py +74',b'Same item cannot be entered multiple times.',b'Isti element ni mogo\xc4\x8de vnesti ve\xc4\x8dkrat.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30',"b'Further accounts can be made under Groups, but entries can be made against non-Groups'","b'Nadaljnje ra\xc4\x8duni se lahko izvede v skupinah, vendar vnosi lahko zoper niso skupin'"
+b'DocType: Lead',b'Lead',b'Ponudba'
+b'DocType: Email Digest',b'Payables',b'Obveznosti'
+b'DocType: Course',b'Course Intro',b'Seveda Intro'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +105',b'Stock Entry {0} created',b'Stock Za\xc4\x8detek {0} ustvaril'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +306',b'Row #{0}: Rejected Qty can not be entered in Purchase Return',b'Vrstica # {0}: Zavrnjena Kol ne more biti vpisana v Nabava Nazaj'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +182',b'Changing Customer Group for the selected Customer is not allowed.',b'Spreminjanje skupine strank za izbrano stranko ni dovoljeno.'
+,b'Purchase Order Items To Be Billed',b'Naro\xc4\x8dilnica Postavke placevali'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +63',b'Updating estimated arrival times.',b'Posodabljanje predvidenih \xc4\x8dasov prihoda.'
+b'DocType: Program Enrollment Tool',b'Enrollment Details',b'Podrobnosti o vpisu'
+b'DocType: Purchase Invoice Item',b'Net Rate',b'Net Rate'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +152',b'Please select a customer',b'Izberite kupca'
+b'DocType: Purchase Invoice Item',b'Purchase Invoice Item',b'Nakup ra\xc4\x8duna item'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58',b'Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts',b'Zaloga Glavna knjiga Prijave in GL Vnosi se ogla\xc5\xa1a za izbrane Nakup Prejemki'
+b'DocType: Student Report Generation Tool',b'Assessment Terms',b'Pogoji ocenjevanja'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8',b'Item 1',b'Postavka 1'
+b'DocType: Holiday',b'Holiday',b'Prazniki'
+b'DocType: Support Settings',b'Close Issue After Days',b'Zapri Te\xc5\xbeava Po dnevih'
+b'DocType: Leave Control Panel',b'Leave blank if considered for all branches',"b'Pustite prazno, \xc4\x8de velja za vse veje'"
+b'DocType: Bank Guarantee',b'Validity in Days',b'Veljavnost v dnevih'
+b'DocType: Bank Guarantee',b'Validity in Days',b'Veljavnost v dnevih'
+b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21',b'C-form is not applicable for Invoice: {0}',b'C-oblika ne velja za ra\xc4\x8duna: {0}'
+b'DocType: Payment Reconciliation',b'Unreconciled Payment Details',b'Unreconciled Pla\xc4\x8dilni Podrobnosti'
+b'apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6',b'Member Activity',b'\xc4\x8clanska dejavnost'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20',b'Order Count',b'Da bi \xc5\xa0tetje'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20',b'Order Count',b'Da bi \xc5\xa0tetje'
+b'DocType: Global Defaults',b'Current Fiscal Year',b'Teko\xc4\x8dem prora\xc4\x8dunskem letu'
+b'DocType: Purchase Order',b'Group same items',b'Skupina Iste vsebine'
+b'DocType: Purchase Invoice',b'Disable Rounded Total',b'Onemogo\xc4\x8di zaokro\xc5\xbeevanje'
+b'DocType: Employee Loan Application',b'Repayment Info',b'Povra\xc4\x8dilo Info'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448',"b""'Entries' cannot be empty""","b'""Vnos"" ne more biti prazen'"
+b'DocType: Maintenance Team Member',b'Maintenance Role',b'Vzdr\xc5\xbeevalna vloga'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +92',b'Duplicate row {0} with same {1}',b'Dvojnik vrstica {0} z enako {1}'
+,b'Trial Balance',b'Trial Balance'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +443',b'Fiscal Year {0} not found',b'Poslovno leto {0} ni bilo mogo\xc4\x8de najti'
+b'apps/erpnext/erpnext/config/hr.py +309',b'Setting up Employees',b'Postavitev Zaposleni'
+b'DocType: Sales Order',b'SO-',b'SO-'
+b'DocType: Hotel Room Reservation',b'Hotel Reservation User',b'Uporabnik rezervacije hotela'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +158',b'Please select prefix first',"b'Prosimo, izberite predpono najprej'"
+b'DocType: Student',b'O-',b'O-'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189',b'Research',b'Raziskave'
+b'DocType: Maintenance Visit Purpose',b'Work Done',b'Delo kon\xc4\x8dano'
+b'apps/erpnext/erpnext/controllers/item_variant.py +35',b'Please specify at least one attribute in the Attributes table',b'Prosimo navedite vsaj en atribut v tabeli Atributi'
+b'DocType: Announcement',b'All Students',b'Vse \xc5\xa0tudenti'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +45',b'Item {0} must be a non-stock item',"b'To\xc4\x8dka {0} mora biti postavka, non-stock'"
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +18',b'View Ledger',b'Ogled Ledger'
+b'DocType: Grading Scale',b'Intervals',b'intervali'
+b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41',b'Earliest',b'Najzgodnej\xc5\xa1a'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +526',"b'An Item Group exists with same name, please change the item name or rename the item group'","b'Element, skupina obstaja z istim imenom, vas prosimo, spremenite ime elementa ali preimenovati skupino element'"
+b'DocType: Crop Cycle',b'Less than a year',b'Manj kot eno leto'
+b'apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52',b'Student Mobile No.',b'\xc5\xa0tudent Mobile No.'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105',b'Rest Of The World',b'Ostali svet'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81',b'The Item {0} cannot have Batch',b'Postavki {0} ne more imeti Batch'
+b'DocType: Crop',b'Yield UOM',b'Donosnost UOM'
+,b'Budget Variance Report',b'Prora\xc4\x8dun Varianca Poro\xc4\x8dilo'
+b'DocType: Salary Slip',b'Gross Pay',b'Bruto Pay'
+b'DocType: Item',b'Is Item from Hub',b'Je predmet iz vozli\xc5\xa1\xc4\x8da'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118',b'Row {0}: Activity Type is mandatory.',b'Vrstica {0}: Vrsta dejavnosti je obvezna.'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166',b'Dividends Paid',b'Pla\xc4\x8dane dividende'
+b'apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36',b'Accounting Ledger',b'Ra\xc4\x8dunovodstvo Ledger'
+b'DocType: Stock Reconciliation',b'Difference Amount',b'Razlika Znesek'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107',b'Dr {0} on Leave on {1}',b'Dr {0} na pusti {1}'
+b'DocType: Purchase Invoice',b'Reverse Charge',b'Povratna obremenitev'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172',b'Retained Earnings',b'Preneseni \xc4\x8disti poslovni izid'
+b'DocType: Purchase Invoice',b'05-Change in POS',b'05-Sprememba v POS'
+b'DocType: Vehicle Log',b'Service Detail',b'Service Podrobnosti'
+b'DocType: BOM',b'Item Description',b'Postavka Opis'
+b'DocType: Student Sibling',b'Student Sibling',b'\xc5\xa1tudent Sorodstvena'
+b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +18',b'Payment Mode',b'Na\xc4\x8din Pla\xc4\x8dilo'
+b'DocType: Purchase Invoice',b'Supplied Items',b'Prilo\xc5\xbeena Items'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85',b'Please set an active menu for Restaurant {0}',"b'Prosimo, nastavite aktivni meni za restavracijo {0}'"
+b'DocType: Student',b'STUD.',b'STUD.'
+b'DocType: Work Order',b'Qty To Manufacture',b'Koli\xc4\x8dina za izdelavo'
+b'DocType: Email Digest',b'New Income',b'Novi prihodki'
+b'DocType: Buying Settings',b'Maintain same rate throughout purchase cycle',b'Ohraniti enako stopnjo celotni nabavni cikel'
+b'DocType: Opportunity Item',b'Opportunity Item',b'Prilo\xc5\xbenost Postavka'
+,b'Student and Guardian Contact Details',b'\xc5\xa0tudent in Guardian Kontaktni podatki'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +53',b'Row {0}: For supplier {0} Email Address is required to send email',b'Vrstica {0}: Za dobavitelja je potrebno {0} e-po\xc5\xa1tni naslov za po\xc5\xa1iljanje e-po\xc5\xa1te'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72',b'Temporary Opening',b'Za\xc4\x8dasna Otvoritev'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +10',b'View Hub',b'Oglejte si vozli\xc5\xa1\xc4\x8de'
+,b'Employee Leave Balance',b'Zaposleni Leave Balance'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147',b'Balance for Account {0} must always be {1}',"b'Saldo ra\xc4\x8dun {0}, morajo biti vedno {1}'"
+b'DocType: Patient Appointment',b'More Info',b'Ve\xc4\x8d informacij'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +180',b'Valuation Rate required for Item in row {0}',b'Oceni Vrednotenje potreben za postavko v vrstici {0}'
+b'DocType: Supplier Scorecard',b'Scorecard Actions',b'Akcije kazalnikov'
+b'apps/erpnext/erpnext/utilities/user_progress.py +169',b'Example: Masters in Computer Science',b'Primer: Masters v ra\xc4\x8dunalni\xc5\xa1tvu'
+b'DocType: Purchase Invoice',b'Rejected Warehouse',b'Zavrnjeno Skladi\xc5\xa1\xc4\x8de'
+b'DocType: GL Entry',b'Against Voucher',b'Proti Voucher'
+b'DocType: Item',b'Default Buying Cost Center',b'Privzet stro\xc5\xa1kovni center za nabavo'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6',"b'To get the best out of ERPNext, we recommend that you take some time and watch these help videos.'","b'Da bi dobili najbolj\xc5\xa1e iz ERPNext, vam priporo\xc4\x8damo, da si vzamete nekaj \xc4\x8dasa in gledam te posnetke pomo\xc4\x8d.'"
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +76',b' to ',b'do'
+b'DocType: Supplier Quotation Item',b'Lead Time in days',b'Lead time v dnevih'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +70',b'Accounts Payable Summary',b'Ra\xc4\x8duni pla\xc4\x8dljivo Povzetek'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +326',b'Payment of salary from {0} to {1}',b'Izpla\xc4\x8dilo pla\xc4\x8de iz {0} na {1}'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213',b'Not authorized to edit frozen Account {0}',b'Ne smejo urejati zamrznjeni ra\xc4\x8dun {0}'
+b'DocType: Journal Entry',b'Get Outstanding Invoices',b'Pridobite nepla\xc4\x8danih ra\xc4\x8dunov'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +84',b'Sales Order {0} is not valid',b'Naro\xc4\x8dilo {0} ni veljavno'
+b'DocType: Supplier Scorecard',b'Warn for new Request for Quotations',b'Opozori na novo zahtevo za citate'
+b'apps/erpnext/erpnext/utilities/activation.py +91',b'Purchase orders help you plan and follow up on your purchases',b'Naro\xc4\x8dilnice vam pomaga na\xc4\x8drtovati in spremljati svoje nakupe'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151',b'Lab Test Prescriptions',b'Testi laboratorijskih testov'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +166',b'The total Issue / Transfer quantity {0} in Material Request {1}  \\\n\t\t\t\t\t\t\tcannot be greater than requested quantity {2} for Item {3}',b'Skupna koli\xc4\x8dina Vpra\xc5\xa1anje / Transfer {0} v dogovoru Material {1} \\ ne sme biti ve\xc4\x8dja od zahtevane koli\xc4\x8dine {2} za postavko {3}'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197',b'Small',b'Majhno'
+b'DocType: Opening Invoice Creation Tool Item',b'Opening Invoice Creation Tool Item',b'Element orodja za ustvarjanje odprtega ra\xc4\x8duna'
+b'DocType: Education Settings',b'Employee Number',b'\xc5\xa0tevilo zaposlenih'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67',b'Case No(s) already in use. Try from Case No {0}',b'Zadeva \xc5\xa1t (y) \xc5\xbee v uporabi. Poskusite z zadevo \xc5\xa1t {0}'
+b'DocType: Project',b'% Completed',b'% kon\xc4\x8dano'
+,b'Invoiced Amount (Exculsive Tax)',b'Obra\xc4\x8dunani znesek (Exculsive Tax)'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14',b'Item 2',b'Postavka 2'
+b'DocType: Supplier',b'SUPP-',b'SUPP-'
+b'DocType: Training Event',b'Training Event',b'Dogodek usposabljanje'
+b'DocType: Item',b'Auto re-order',b'Auto re-order'
+b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59',b'Total Achieved',b'Skupaj Dose\xc5\xbeeni'
+b'DocType: Employee',b'Place of Issue',b'Kraj izdaje'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101',b'Contract',b'Pogodba'
+b'DocType: Plant Analysis',b'Laboratory Testing Datetime',b'Laboratorijsko testiranje Datetime'
+b'DocType: Email Digest',b'Add Quote',b'Dodaj Citiraj'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +987',b'UOM coversion factor required for UOM: {0} in Item: {1}',"b'UOM coversion dejavnik, potreben za UOM: {0} v postavki: {1}'"
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92',b'Indirect Expenses',b'Posredni stro\xc5\xa1ki'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +98',b'Row {0}: Qty is mandatory',b'Vrstica {0}: Kol je obvezna'
+b'DocType: Agriculture Analysis Criteria',b'Agriculture',b'Kmetijstvo'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +794',b'Sync Master Data',b'Sync Master Data'
+b'DocType: Asset Repair',b'Repair Cost',b'Stro\xc5\xa1ki popravila'
+b'apps/erpnext/erpnext/utilities/user_progress.py +138',b'Your Products or Services',b'Svoje izdelke ali storitve'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15',b'Failed to login',b'Prijava ni uspel'
+b'DocType: Special Test Items',b'Special Test Items',b'Posebni testni elementi'
+b'DocType: Mode of Payment',b'Mode of Payment',b'Na\xc4\x8din pla\xc4\x8dila'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +202',b'Website Image should be a public file or website URL',b'Spletna stran Slika bi morala biti javna datoteka ali spletna stran URL'
+b'DocType: Student Applicant',b'AP',b'AP'
+b'DocType: Purchase Invoice Item',b'BOM',b'BOM'
+b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37',b'This is a root item group and cannot be edited.',"b'To je skupina, root element in ga ni mogo\xc4\x8de urejati.'"
+b'DocType: Journal Entry Account',b'Purchase Order',b'Naro\xc4\x8dilnica'
+b'DocType: Vehicle',b'Fuel UOM',b'gorivo UOM'
+b'DocType: Warehouse',b'Warehouse Contact Info',b'Skladi\xc5\xa1\xc4\x8de Kontakt Info'
+b'DocType: Payment Entry',b'Write Off Difference Amount',b'Napi\xc5\xa1ite Off Razlika Znesek'
+b'DocType: Volunteer',b'Volunteer Name',b'Ime prostovoljca'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +434',"b'{0}: Employee email not found, hence email not sent'","b'{0}: email zaposlenega ni mogo\xc4\x8de najti, zato e-po\xc5\xa1tno sporo\xc4\x8dilo ni bilo poslano'"
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85',b'Shipping rule not applicable for country {0}',b'Pravilo o po\xc5\xa1iljanju ni veljavno za dr\xc5\xbeavo {0}'
+b'DocType: Item',b'Foreign Trade Details',b'Zunanjo trgovino Podrobnosti'
+,b'Assessment Plan Status',b'Status na\xc4\x8drta ocenjevanja'
+b'DocType: Email Digest',b'Annual Income',b'Letni dohodek'
+b'DocType: Serial No',b'Serial No Details',b'Serijska \xc5\xa1t Podrobnosti'
+b'DocType: Purchase Invoice Item',b'Item Tax Rate',b'Postavka Dav\xc4\x8dna stopnja'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +89',b'Please select Physician and Date',"b'Prosimo, izberite zdravnika in datum'"
+b'DocType: Student Group Student',b'Group Roll Number',b'Skupina Roll \xc5\xa0tevilo'
+b'DocType: Student Group Student',b'Group Roll Number',b'Skupina Roll \xc5\xa0tevilo'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145',"b'For {0}, only credit accounts can be linked against another debit entry'","b'Za {0}, lahko le kreditne ra\xc4\x8dune povezati proti drugemu vstop trajnika'"
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +84',b'Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly',"b'Vsota vseh ute\xc5\xbei nalog bi moral biti 1. Prosimo, da ustrezno prilagodi ute\xc5\xbei za vse naloge v projektu'"
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +588',b'Delivery Note {0} is not submitted',b'Dobavnica {0} ni predlo\xc5\xbeila'
+b'apps/erpnext/erpnext/stock/get_item_details.py +148',b'Item {0} must be a Sub-contracted Item',b'Postavka {0} mora biti podizvajalcev item'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43',b'Capital Equipments',b'Kapitalski Oprema'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33',"b""Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.""","b'Cen Pravilo je najprej treba izbrati glede na &quot;Uporabi On &#39;polju, ki je lahko to\xc4\x8dka, to\xc4\x8dka Group ali Brand.'"
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +246',b'Please set the Item Code first',b'Najprej nastavite kodo izdelka'
+b'DocType: Item',b'ITEM-',b'ITEM-'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +123',b'Total allocated percentage for sales team should be 100',b'Skupna dodeljena odstotek za prodajne ekipe mora biti 100'
+b'DocType: Sales Invoice Item',b'Edit Description',b'Uredi Opis'
+b'DocType: Antibiotic',b'Antibiotic',b'Antibiotik'
+,b'Team Updates',b'ekipa Posodobitve'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +912',b'For Supplier',b'Za dobavitelja'
+b'DocType: Account',b'Setting Account Type helps in selecting this Account in transactions.',b'Nastavitev vrste ra\xc4\x8duna pomaga pri izbiri ra\xc4\x8duna v transakcijah.'
+b'DocType: Purchase Invoice',b'Grand Total (Company Currency)',b'Grand Total (dru\xc5\xbeba Valuta)'
+b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9',b'Create Print Format',b'Ustvari Print Format'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5',b'Fee Created',b'Ustvarjena provizija'
+b'apps/erpnext/erpnext/utilities/bot.py +39',b'Did not find any item called {0}',b'Ni na\xc5\xa1la nobenega elementa z imenom {0}'
+b'DocType: Supplier Scorecard Criteria',b'Criteria Formula',b'Kriterijska formula'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41',b'Total Outgoing',b'Skupaj Odhodni'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39',"b'There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""'",b'Obstaja lahko samo en prevoz pravilo Pogoj z 0 ali prazno vrednost za &quot;ceniti&quot;'
+b'DocType: Authorization Rule',b'Transaction',b'Posel'
+b'DocType: Patient Appointment',b'Duration',b'Trajanje'
+b'apps/erpnext/erpnext/controllers/status_updater.py +160',"b'For an item {0}, quantity must be positive number'",b'Za element {0} mora biti koli\xc4\x8dina pozitivna'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27',b'Note: This Cost Center is a Group. Cannot make accounting entries against groups.',b'Opomba: Ta Stro\xc5\xa1ki Center je skupina. Ne more vknji\xc5\xbebe proti skupinam.'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +53',b'Child warehouse exists for this warehouse. You can not delete this warehouse.',"b'Otrok skladi\xc5\xa1\xc4\x8de obstaja za to skladi\xc5\xa1\xc4\x8de. Ne, ne more\xc5\xa1 izbrisati to skladi\xc5\xa1\xc4\x8de.'"
+b'DocType: Item',b'Website Item Groups',b'Spletna stran Element Skupine'
+b'DocType: Purchase Invoice',b'Total (Company Currency)',b'Skupaj (dru\xc5\xbeba Valuta)'
+b'DocType: Daily Work Summary Group',b'Reminder',b'Opomnik'
+b'apps/erpnext/erpnext/stock/utils.py +207',b'Serial number {0} entered more than once',b'Serijska \xc5\xa1tevilka {0} je za\xc4\x8dela ve\xc4\x8d kot enkrat'
+b'DocType: Journal Entry',b'Journal Entry',b'Vnos v dnevnik'
+b'DocType: Expense Claim Advance',b'Unclaimed amount',b'Nezahteven znesek'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +148',b'{0} items in progress',b'{0} postavke v teku'
+b'DocType: Workstation',b'Workstation Name',b'Workstation Name'
+b'DocType: Grading Scale Interval',b'Grade Code',b'razred Code'
+b'DocType: POS Item Group',b'POS Item Group',b'POS Element Group'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17',b'Email Digest:',b'Email Digest:'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +613',b'BOM {0} does not belong to Item {1}',b'BOM {0} ne pripada postavki {1}'
+b'DocType: Sales Partner',b'Target Distribution',b'Target Distribution'
+b'DocType: Purchase Invoice',b'06-Finalization of Provisional assessment',b'06-Dokon\xc4\x8danje za\xc4\x8dasne ocene'
+b'DocType: Salary Slip',b'Bank Account No.',b'\xc5\xa0t. ban\xc4\x8dnega ra\xc4\x8duna'
+b'DocType: Naming Series',b'This is the number of the last created transaction with this prefix',b'To je \xc5\xa1tevilka zadnjega ustvarjene transakcijo s tem predpono'
+b'DocType: Supplier Scorecard',"b'Scorecard variables can be used, as well as:\n{total_score} (the total score from that period),\n{period_number} (the number of periods to present day)\n'","b'Uporabljate lahko spremenljivke Scorecard, kot tudi: {total_score} (skupna ocena iz tega obdobja), {period_number} (\xc5\xa1tevilo obdobij do dana\xc5\xa1njega dne)'"
+b'DocType: Quality Inspection Reading',b'Reading 8',b'Branje 8'
+b'DocType: Sales Partner',b'Agent',b'Agent'
+b'DocType: Purchase Invoice',b'Taxes and Charges Calculation',b'Davki in dajatve Izra\xc4\x8dun'
+b'DocType: Accounts Settings',b'Book Asset Depreciation Entry Automatically',b'Knjiga sredstev Amortizacija Za\xc4\x8detek samodejno'
+b'DocType: Accounts Settings',b'Book Asset Depreciation Entry Automatically',b'Knjiga sredstev Amortizacija Za\xc4\x8detek samodejno'
+b'DocType: BOM Operation',b'Workstation',b'Workstation'
+b'DocType: Request for Quotation Supplier',b'Request for Quotation Supplier',b'Zahteva za ponudbo dobavitelja'
+b'DocType: Healthcare Settings',b'Registration Message',b'Registracija sporo\xc4\x8dilo'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154',b'Hardware',b'Strojna oprema'
+b'DocType: Prescription Dosage',b'Prescription Dosage',b'Odmerjanje na recept'
+b'DocType: Attendance',b'HR Manager',b'Upravljanje \xc4\x8dlove\xc5\xa1kih virov'
+b'apps/erpnext/erpnext/accounts/party.py +175',b'Please select a Company',b'Prosimo izberite Company'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92',b'Privilege Leave',b'Privilege Zapusti'
+b'DocType: Purchase Invoice',b'Supplier Invoice Date',b'Dobavitelj Datum ra\xc4\x8duna'
+b'DocType: Asset Settings',b'This value is used for pro-rata temporis calculation',b'Ta vrednost se uporablja za izracun pro rata temporis'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90',b'You need to enable Shopping Cart',b'Morate omogo\xc4\x8diti Ko\xc5\xa1arica'
+b'DocType: Payment Entry',b'Writeoff',b'Odpisati'
+b'DocType: Stock Settings',b'Naming Series Prefix',b'Namig serijske oznake'
+b'DocType: Appraisal Template Goal',b'Appraisal Template Goal',b'Cenitev Predloga cilj'
+b'DocType: Salary Component',b'Earning',b'Slu\xc5\xbeenje'
+b'DocType: Supplier Scorecard',b'Scoring Criteria',b'Kriteriji to\xc4\x8dkovanja'
+b'DocType: Purchase Invoice',b'Party Account Currency',b'Party Valuta ra\xc4\x8duna'
+,b'BOM Browser',b'BOM Browser'
+b'apps/erpnext/erpnext/templates/emails/training_event.html +13',b'Please update your status for this training event',"b'Prosimo, posodobite svoj status za ta trening dogodek'"
+b'DocType: Item Barcode',b'EAN',b'EAN'
+b'DocType: Purchase Taxes and Charges',b'Add or Deduct',b'Dodajte ali od\xc5\xa1tejemo'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148',b'Overlapping conditions found between:',b'Prekrivajo\xc4\x8da pogoji najdemo med:'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187',b'Against Journal Entry {0} is already adjusted against some other voucher',b'Proti listu Za\xc4\x8detek {0} je \xc5\xbee prilagojena proti neki drugi kupon'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68',b'Total Order Value',b'Skupna vrednost naro\xc4\x8dila'
+b'apps/erpnext/erpnext/demo/setup/setup_data.py +328',b'Food',b'Hrana'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +57',b'Ageing Range 3',b'Staranje Obmo\xc4\x8dje 3'
+b'DocType: Maintenance Schedule Item',b'No of Visits',b'\xc5\xa0tevilo obiskov'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165',b'Maintenance Schedule {0} exists against {1}',b'obstaja Vzdr\xc5\xbeevanje Razpored {0} proti {1}'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36',b'Enrolling student',b'Vpisovanje \xc5\xa1tudentov'
+b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33',b'Currency of the Closing Account must be {0}',b'Valuta zaklju\xc4\x8dni ra\xc4\x8dun mora biti {0}'
+b'apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21',b'Sum of points for all goals should be 100. It is {0}',b'Se\xc5\xa1tevek to\xc4\x8dk za vseh ciljev bi morala biti 100. To je {0}'
+b'DocType: Project',b'Start and End Dates',b'Za\xc4\x8detni in kon\xc4\x8dni datum'
+,b'Delivered Items To Be Billed',b'Dobavljeni artikli placevali'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16',b'Open BOM {0}',b'Odprti BOM {0}'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60',b'Warehouse cannot be changed for Serial No.',b'Skladi\xc5\xa1\xc4\x8de ni mogo\xc4\x8de spremeniti za Serial No.'
+b'DocType: Authorization Rule',b'Average Discount',b'Povpre\xc4\x8den Popust'
+b'DocType: Project Update',b'Great/Quickly',b'Odli\xc4\x8dno / hitro'
+b'DocType: Purchase Invoice Item',b'UOM',b'UOM'
+b'DocType: Rename Tool',b'Utilities',b'Utilities'
+b'DocType: POS Profile',b'Accounting',b'Ra\xc4\x8dunovodstvo'
+b'DocType: Employee',b'EMP/',b'EMP /'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133',b'Please select batches for batched item ',b'Izberite serij za zdru\xc5\xbeena postavko'
+b'DocType: Asset',b'Depreciation Schedules',b'Amortizacija Urniki'
+b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +192',b'Following accounts might be selected in GST Settings:',b'V nastavitvah GST se lahko izberejo naslednji ra\xc4\x8duni:'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +70',b'Application period cannot be outside leave allocation period',b'Prijavni rok ne more biti obdobje dodelitve izven dopusta'
+b'DocType: Activity Cost',b'Projects',b'Projekti'
+b'DocType: Payment Request',b'Transaction Currency',b'transakcija Valuta'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +30',b'From {0} | {1} {2}',b'Od {0} | {1} {2}'
+b'DocType: Work Order Operation',b'Operation Description',b'Operacija Opis'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34',b'Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.',"b'Ne more spremeniti poslovno leto za\xc4\x8detni datum in fiskalnem letu End Datum, ko je poslovno leto shranjen.'"
+b'DocType: Quotation',b'Shopping Cart',b'Nakupovalni vozi\xc4\x8dek'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41',b'Avg Daily Outgoing',b'Avg Daily Odhodni'
+b'DocType: POS Profile',b'Campaign',b'Kampanja'
+b'DocType: Supplier',b'Name and Type',b'Ime in Type'
+b'DocType: Physician',b'Contacts and Address',b'Stiki in naslov'
+b'DocType: Purchase Invoice',b'Contact Person',b'Kontaktna oseba'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +38',"b""'Expected Start Date' can not be greater than 'Expected End Date'""","b""'Pri\xc4\x8dakovani datum za\xc4\x8detka' ne more biti ve\xc4\x8dji od 'Pri\xc4\x8dakovan datum zaklju\xc4\x8dka'"""
+b'DocType: Course Scheduling Tool',b'Course End Date',b'Seveda Kon\xc4\x8dni datum'
+b'DocType: Holiday List',b'Holidays',b'Prazniki'
+b'DocType: Sales Order Item',b'Planned Quantity',b'Na\xc4\x8drtovana Koli\xc4\x8dina'
+b'DocType: Purchase Invoice Item',b'Item Tax Amount',b'Postavka Znesek davka'
+b'DocType: Water Analysis',b'Water Analysis Criteria',b'Kriteriji za analizo vode'
+b'DocType: Item',b'Maintain Stock',b'Ohraniti park'
+b'DocType: Employee',b'Prefered Email',b'Prednostna po\xc5\xa1ta'
+b'DocType: Student Admission',b'Eligibility and Details',b'Upravi\xc4\x8denost in podrobnosti'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +38',b'Net Change in Fixed Asset',b'Neto sprememba v osnovno sredstvo'
+b'DocType: Leave Control Panel',b'Leave blank if considered for all designations',"b'Pustite prazno, \xc4\x8de velja za vse ozna\xc4\x8db'"
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +806',"b""Charge of type 'Actual' in row {0} cannot be included in Item Rate""",b'Naboj tip &quot;Dejanski&quot; v vrstici {0} ni mogo\xc4\x8de vklju\xc4\x8diti v postavko Rate'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +382',b'Max: {0}',b'Max: {0}'
+b'apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24',b'From Datetime',b'Od datetime'
+b'DocType: Email Digest',b'For Company',b'Za podjetje'
+b'apps/erpnext/erpnext/config/support.py +17',b'Communication log.',b'Sporo\xc4\x8dilo dnevnik.'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +195',"b'Request for Quotation is disabled to access from portal, for more check portal settings.'",b'Zahteva za ponudbo je onemogo\xc4\x8den dostop iz portala za ve\xc4\x8d nastavitev za preverjanje portala.'
+b'DocType: Supplier Scorecard Scoring Variable',b'Supplier Scorecard Scoring Variable',b'Dobavitelj Scorecard Scoring Spremenljivka'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72',b'Buying Amount',b'Znesek nabave'
+b'DocType: Sales Invoice',b'Shipping Address Name',b'Naslov dostave'
+b'DocType: Material Request',b'Terms and Conditions Content',b'Pogoji in vsebina'
+b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18',b'There were errors creating Course Schedule',b'Pri\xc5\xa1lo je do napak pri urejanju te\xc4\x8daja te\xc4\x8daja'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +581',b'cannot be greater than 100',b'ne more biti ve\xc4\x8dja kot 100'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +752',b'Item {0} is not a stock Item',b'Postavka {0} ni zaloge Item'
+b'DocType: Maintenance Visit',b'Unscheduled',b'Nena\xc4\x8drtovana'
+b'DocType: Employee',b'Owned',b'Lasti'
+b'DocType: Salary Detail',b'Depends on Leave Without Pay',b'Odvisno od dopusta brez pla\xc4\x8dila'
+b'DocType: Pricing Rule',"b'Higher the number, higher the priority'","b'Vi\xc5\xa1ja kot je \xc5\xa1tevilka, vi\xc5\xa1ja je prioriteta'"
+,b'Purchase Invoice Trends',b'Ra\xc4\x8dun za nakup Trendi'
+b'DocType: Employee',b'Better Prospects',b'Bolj\xc5\xa1i obeti'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +217',"b'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'","b'Vrstica # {0}: Serija {1} ima le {2} kol. Izberite drugo serijo, ki ima {3} kol na voljo ali razdeli vrstico v ve\xc4\x8d vrstic, da poda / vpra\xc5\xa1anja iz razli\xc4\x8dnih serij'"
+b'DocType: Vehicle',b'License Plate',b'Registrska tablica'
+b'DocType: Appraisal',b'Goals',b'Cilji'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +353',b'Select POS Profile',b'Izberite POS profil'
+b'DocType: Warranty Claim',b'Warranty / AMC Status',b'Garancija / AMC Status'
+,b'Accounts Browser',b'Ra\xc4\x8duni Browser'
+b'DocType: Payment Entry Reference',b'Payment Entry Reference',b'Pla\xc4\x8dilo Za\xc4\x8detek Reference'
+b'DocType: GL Entry',b'GL Entry',b'GL Za\xc4\x8detek'
+b'DocType: HR Settings',b'Employee Settings',b'Nastavitve zaposlenih'
+,b'Batch-Wise Balance History',b'Serija-Wise Balance Zgodovina'
+b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73',b'Print settings updated in respective print format',b'nastavitve tiskanja posodabljajo v ustrezni obliki za tiskanje'
+b'DocType: Package Code',b'Package Code',b'paket koda'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105',b'Apprentice',b'Vajenec'
+b'DocType: Purchase Invoice',b'Company GSTIN',b'Podjetje GSTIN'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +105',b'Negative Quantity is not allowed',b'Negativno Koli\xc4\x8dina ni dovoljeno'
+b'DocType: Purchase Invoice Item',b'Tax detail table fetched from item master as a string and stored in this field.\nUsed for Taxes and Charges',b'Dav\xc4\x8dna podrobnosti tabela nerealne iz postavke mojstra kot vrvico in shranjena na tem podro\xc4\x8dju. Uporablja se za davki in dajatve'
+b'DocType: Supplier Scorecard Period',b'SSC-',b'SSC-'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +159',b'Employee cannot report to himself.',b'Delavec ne more poro\xc4\x8dati zase.'
+b'DocType: Account',"b'If the account is frozen, entries are allowed to restricted users.'","b'\xc4\x8ce ra\xc4\x8duna je zamrznjeno, so vpisi dovoljeni omejenih uporabnikov.'"
+b'DocType: Email Digest',b'Bank Balance',b'Banka Balance'
+b'apps/erpnext/erpnext/accounts/party.py +240',b'Accounting Entry for {0}: {1} can only be made in currency: {2}',"b'Ra\xc4\x8dunovodstvo Vstop za {0}: lahko {1}, se izvede le v valuti: {2}'"
+b'DocType: Job Opening',"b'Job profile, qualifications required etc.'","b'Profil delovnega mesta, potrebna usposobljenost itd'"
+b'DocType: Journal Entry Account',b'Account Balance',b'Stanje na ra\xc4\x8dunu'
+b'apps/erpnext/erpnext/config/accounts.py +183',b'Tax Rule for transactions.',b'Dav\xc4\x8dna pravilo za transakcije.'
+b'DocType: Rename Tool',b'Type of document to rename.',b'Vrsta dokumenta preimenovati.'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53',b'{0} {1}: Customer is required against Receivable account {2}',b'{0} {1}: zahtevan je Naro\xc4\x8dnik za ra\xc4\x8dun prejemkov {2}'
+b'DocType: Purchase Invoice',b'Total Taxes and Charges (Company Currency)',b'Skupaj davki in dajatve (Company valuti)'
+b'DocType: Weather',b'Weather Parameter',b'Vremenski parameter'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60',"b""Show unclosed fiscal year's P&L balances""",b'Prika\xc5\xbei nezaprt poslovno leto je P &amp; L bilanc'
+b'DocType: Lab Test Template',b'Collection Details',b'Podrobnosti o zbirki'
+b'DocType: POS Profile',b'Allow Print Before Pay',b'Dovoli tiskanje pred pla\xc4\x8dilom'
+b'DocType: Land Unit',b'Linked Soil Texture',b'Povezana tla teksture'
+b'DocType: Shipping Rule',b'Shipping Account',b'Dostava ra\xc4\x8dun'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92',b'{0} {1}: Account {2} is inactive',b'{0} {1}: ra\xc4\x8dun {2} je neaktiven'
+b'apps/erpnext/erpnext/utilities/activation.py +82',b'Make Sales Orders to help you plan your work and deliver on-time',"b'Naredite Prodajni nalogi, ki vam pomaga na\xc4\x8drtovati svoje delo in poda na \xc4\x8das'"
+b'DocType: Quality Inspection',b'Readings',b'Readings'
+b'DocType: Stock Entry',b'Total Additional Costs',b'Skupaj Dodatni stro\xc5\xa1ki'
+b'DocType: Course Schedule',b'SH',b'SH'
+b'DocType: BOM',b'Scrap Material Cost(Company Currency)',b'Odpadni material Stro\xc5\xa1ki (dru\xc5\xbeba Valuta)'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66',b'Sub Assemblies',b'Sklope'
+b'DocType: Asset',b'Asset Name',b'Ime sredstvo'
+b'DocType: Project',b'Task Weight',b'naloga Te\xc5\xbea'
+b'DocType: Shipping Rule Condition',b'To Value',b'Do vrednosti'
+b'DocType: Asset Movement',b'Stock Manager',b'Stock Manager'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +171',b'Source warehouse is mandatory for row {0}',b'Vir skladi\xc5\xa1\xc4\x8de je obvezna za vrstico {0}'
+b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38',b'The Payment Term at row {0} is possibly a duplicate.',b'Izraz pla\xc4\x8dila v vrstici {0} je morda dvojnik.'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +30',b'Agriculture (beta)',b'Kmetijstvo (beta)'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +863',b'Packing Slip',b'Pakiranje listek'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110',b'Office Rent',b'Urad za najem'
+b'apps/erpnext/erpnext/config/setup.py +111',b'Setup SMS gateway settings',b'Nastavitve Setup SMS gateway'
+b'DocType: Disease',b'Common Name',b'Pogosto ime'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61',b'Import Failed!',b'Uvoz uspelo!'
+b'apps/erpnext/erpnext/public/js/templates/address_list.html +20',b'No address added yet.',b'\xc5\xa0e ni naslov dodal.'
+b'DocType: Workstation Working Hour',b'Workstation Working Hour',b'Workstation delovno uro'
+b'DocType: Vital Signs',b'Blood Pressure',b'Krvni pritisk'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125',b'Analyst',b'Analitik'
+b'DocType: Item',b'Inventory',b'Popis'
+b'DocType: Item',b'Sales Details',b'Prodajna Podrobnosti'
+b'DocType: Quality Inspection',b'QI-',b'QI-'
+b'DocType: Opportunity',b'With Items',b'Z Items'
+b'DocType: Asset Maintenance',b'Maintenance Team',b'Vzdr\xc5\xbeevalna ekipa'
+b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'In Qty',b'V Kol'
+b'DocType: Education Settings',b'Validate Enrolled Course for Students in Student Group',b'Potrdite vpisanih te\xc4\x8daj za \xc5\xa1tudente v \xc5\xa1tudentskih skupine'
+b'DocType: Notification Control',b'Expense Claim Rejected',b'Expense zahtevek zavrnjen'
+b'DocType: Item',b'Item Attribute',b'Postavka Lastnost'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147',b'Government',b'Vlada'
+b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40',b'Expense Claim {0} already exists for the Vehicle Log',b'Expense Zahtevek {0} \xc5\xbee obstaja za Prijavi vozil'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +64',b'Institute Name',b'Ime Institute'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117',b'Please enter repayment Amount',b'Vnesite odpla\xc4\x8devanja Znesek'
+b'apps/erpnext/erpnext/config/stock.py +309',b'Item Variants',b'Artikel Variante'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +29',b'Services',b'Storitve'
+b'DocType: HR Settings',b'Email Salary Slip to Employee',b'Email Pla\xc4\x8da Slip na zaposlenega'
+b'DocType: Cost Center',b'Parent Cost Center',b'Parent Center Stro\xc5\xa1ki'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1041',b'Select Possible Supplier',b'Izberite Mo\xc5\xbeni Dobavitelj'
+b'DocType: Sales Invoice',b'Source',b'Vir'
+b'DocType: Customer',"b'Select, to make the customer searchable with these fields'","b'Izberite, da bo stranka s temi podro\xc4\x8dji omogo\xc4\x8dila iskanje'"
+b'apps/erpnext/erpnext/templates/pages/projects.html +31',b'Show closed',b'Prika\xc5\xbei zaprto'
+b'DocType: Leave Type',b'Is Leave Without Pay',b'Se Leave brez pla\xc4\x8dila'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +261',b'Asset Category is mandatory for Fixed Asset item',b'Sredstvo kategorije je obvezna za fiksno postavko sredstev'
+b'DocType: Fee Validity',b'Fee Validity',b'Veljavnost pristojbine'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +146',b'No records found in the Payment table',b'Ni najdenih v tabeli pla\xc4\x8dil zapisov'
+b'apps/erpnext/erpnext/education/utils.py +19',b'This {0} conflicts with {1} for {2} {3}',b'Ta {0} ni v nasprotju s {1} za {2} {3}'
+b'DocType: Student Attendance Tool',b'Students HTML',b'\xc5\xa1tudenti HTML'
+b'DocType: POS Profile',b'Apply Discount',b'Uporabi popust'
+b'DocType: GST HSN Code',b'GST HSN Code',b'DDV HSN koda'
+b'DocType: Employee External Work History',b'Total Experience',b'Skupaj Izku\xc5\xa1nje'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70',b'Open Projects',b'Odprti projekti'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +295',b'Packing Slip(s) cancelled',b'Dobavnico (e) odpovedan'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +36',b'Cash Flow from Investing',b'Denarni tokovi iz nalo\xc5\xbebenja'
+b'DocType: Program Course',b'Program Course',b'Te\xc4\x8daj programa'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99',b'Freight and Forwarding Charges',b'Tovorni in Forwarding Stro\xc5\xa1ki'
+b'DocType: Homepage',b'Company Tagline for website homepage',b'Podjetje Slogan za doma\xc4\x8do stran spletnega mesta'
+b'DocType: Item Group',b'Item Group Name',b'Item Name Group'
+b'apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27',b'Taken',b'Taken'
+b'DocType: Student',b'Date of Leaving',b'Datum Leaving'
+b'DocType: Pricing Rule',b'For Price List',b'Za cenik'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27',b'Executive Search',b'Executive Search'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55',b'Setting defaults',b'Nastavitev privzetih nastavitev'
+b'apps/erpnext/erpnext/utilities/activation.py +63',b'Create Leads',b'Ustvari Interesenti'
+b'DocType: Maintenance Schedule',b'Schedules',b'Urniki'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +468',b'POS Profile is required to use Point-of-Sale',b'Profil POS je potreben za uporabo Point-of-Sale'
+b'DocType: Purchase Invoice Item',b'Net Amount',b'Neto znesek'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +141',b'{0} {1} has not been submitted so the action cannot be completed',"b'{0} {1} ni bila vlo\xc5\xbeena, dejanje ne more biti dokon\xc4\x8dano'"
+b'DocType: Purchase Order Item Supplied',b'BOM Detail No',b'BOM Detail Ne'
+b'DocType: Landed Cost Voucher',b'Additional Charges',b'dodatni stro\xc5\xa1ki'
+b'DocType: Purchase Invoice',b'Additional Discount Amount (Company Currency)',b'Dodatni popust Znesek (Valuta Company)'
+b'DocType: Supplier Scorecard',b'Supplier Scorecard',b'Scorecard dobavitelja'
+b'DocType: Plant Analysis',b'Result Datetime',b'Result Datetime'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +21',b'Please create new account from Chart of Accounts.',"b'Prosimo, ustvarite nov ra\xc4\x8dun iz kontnega na\xc4\x8drta.'"
+,b'Support Hour Distribution',b'Podpora Distribution Hour'
+b'DocType: Maintenance Visit',b'Maintenance Visit',b'Vzdr\xc5\xbeevanje obisk'
+b'DocType: Student',b'Leaving Certificate Number',b'Leaving Certificate \xc5\xa0tevilo'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +58',"b'Appointment cancelled, Please review and cancel the invoice {0}'","b'Imenovanje je preklicano, preglejte in prekli\xc4\x8dite ra\xc4\x8dun {0}'"
+b'DocType: Sales Invoice Item',b'Available Batch Qty at Warehouse',b'Dostopno Serija Koli\xc4\x8dina na Warehouse'
+b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9',b'Update Print Format',b'Update Print Format'
+b'DocType: Landed Cost Voucher',b'Landed Cost Help',b'Pristali Stro\xc5\xa1ki Pomo\xc4\x8d'
+b'DocType: Purchase Invoice',b'Select Shipping Address',b'Izbira naslova za dostavo'
+b'apps/erpnext/erpnext/config/non_profit.py +28',b'Memebership Details',b'Podrobnosti o memorandumu'
+b'DocType: Leave Block List',b'Block Holidays on important days.',b'Blokiranje Po\xc4\x8ditnice na pomembnih dni.'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +220',b'Please input all required Result Value(s)',b'Vnesite vso zahtevano vrednost (-e)'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +106',b'Accounts Receivable Summary',b'Terjatve Povzetek'
+b'DocType: Employee Loan',b'Monthly Repayment Amount',b'Mese\xc4\x8dni Povra\xc4\x8dilo Znesek'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9',b'Opening Invoices',b'Odpiranje ra\xc4\x8dunov'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +195',b'Please set User ID field in an Employee record to set Employee Role',"b'Prosim, nastavite ID uporabnika polje v zapisu zaposlenih za dolo\xc4\x8den Vloga zaposlenih'"
+b'DocType: UOM',b'UOM Name',b'UOM Name'
+b'DocType: GST HSN Code',b'HSN Code',b'Tarifna \xc5\xa1tevilka'
+b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +39',b'Contribution Amount',b'Prispevek Znesek'
+b'DocType: Purchase Invoice',b'Shipping Address',b'naslov za po\xc5\xa1iljanje'
+b'DocType: Stock Reconciliation',b'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.',b'To orodje vam pomaga posodobiti ali popravite koli\xc4\x8dino in vrednotenje zalog v sistemu. To se ponavadi uporablja za sinhronizacijo sistemske vrednosti in kaj dejansko obstaja v va\xc5\xa1ih skladi\xc5\xa1\xc4\x8dih.'
+b'DocType: Delivery Note',b'In Words will be visible once you save the Delivery Note.',"b'V besedi bo viden, ko boste shranite dobavnici.'"
+b'DocType: Expense Claim',b'EXP',b'EXP'
+b'DocType: Water Analysis',b'Container',b'Zabojnik'
+b'apps/erpnext/erpnext/education/utils.py +50',b'Student {0} - {1} appears Multiple times in row {2} & {3}',b'\xc5\xa0tudent {0} - {1} pojavi ve\xc4\x8dkrat v vrsti {2} {3}'
+b'DocType: Project',b'Day to Send',b'Dan za po\xc5\xa1iljanje'
+b'DocType: Healthcare Settings',b'Manage Sample Collection',b'Upravljanje vzor\xc4\x8denja'
+b'DocType: Production Plan',b'Ignore Existing Ordered Quantity',b'Prezri obstoje\xc4\x8da naro\xc4\x8dena koli\xc4\x8dina'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +66',b'Please set the series to be used.',"b'Prosimo, nastavite serijo za uporabo.'"
+b'DocType: Patient',b'Tobacco Past Use',b'Pretekla uporaba tobaka'
+b'DocType: Sales Invoice Item',b'Brand Name',b'Blagovna znamka'
+b'DocType: Purchase Receipt',b'Transporter Details',b'Transporter Podrobnosti'
+b'apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +55',b'User {0} is already assigned to Physician {1}',b'Uporabnik {0} je \xc5\xbee dodeljen zdravniku {1}'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2700',b'Default warehouse is required for selected item',b'Privzeto skladi\xc5\xa1\xc4\x8de je potrebna za izbrano postavko'
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Box',b'\xc5\xa0katla'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1038',b'Possible Supplier',b'Mo\xc5\xbeni Dobavitelj'
+b'DocType: Budget',b'Monthly Distribution',b'Mese\xc4\x8dni Distribution'
+b'apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68',b'Receiver List is empty. Please create Receiver List',"b'Sprejemnik Seznam je prazen. Prosimo, da ustvarite sprejemnik seznam'"
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +31',b'Healthcare (beta)',b'Zdravstvo (beta)'
+b'DocType: Production Plan Sales Order',b'Production Plan Sales Order',b'Proizvodni na\xc4\x8drt Sales Order'
+b'DocType: Sales Partner',b'Sales Partner Target',b'Prodaja Partner Target'
+b'DocType: Loan Type',b'Maximum Loan Amount',b'Najve\xc4\x8dja Znesek posojila'
+b'DocType: Pricing Rule',b'Pricing Rule',b'Cen Pravilo'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58',b'Duplicate roll number for student {0}',b'Podvojena \xc5\xa1tevilka rola \xc5\xa1tudent {0}'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58',b'Duplicate roll number for student {0}',b'Podvojena \xc5\xa1tevilka rola \xc5\xa1tudent {0}'
+b'DocType: Budget',b'Action if Annual Budget Exceeded',"b'Ukrep, \xc4\x8de letni prora\xc4\x8dun Prekora\xc4\x8ditev'"
+b'apps/erpnext/erpnext/config/learn.py +197',b'Material Request to Purchase Order',b'Material Zahteva za narocilo'
+b'DocType: Shopping Cart Settings',b'Payment Success URL',b'Pla\xc4\x8dilo Uspeh URL'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +81',b'Row # {0}: Returned Item {1} does not exists in {2} {3}',b'Vrstica # {0}: Vrnjeno Postavka {1} ne obstaja v {2} {3}'
+b'DocType: Purchase Receipt',b'PREC-',b'PREC-'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16',b'Bank Accounts',b'Ban\xc4\x8dni ra\xc4\x8duni'
+,b'Bank Reconciliation Statement',b'Izjava Bank Sprava'
+b'DocType: Consultation',b'Medical Coding',b'Zdravni\xc5\xa1ko kodiranje'
+b'DocType: Healthcare Settings',b'Reminder Message',b'Opomnik'
+,b'Lead Name',b'Ime ponudbe'
+,b'POS',b'POS'
+b'DocType: C-Form',b'III',b'III'
+b'apps/erpnext/erpnext/config/stock.py +314',b'Opening Stock Balance',b'Odpiranje Stock Balance'
+b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58',b'{0} must appear only once',b'{0} se morajo pojaviti le enkrat'
+b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59',b'Leaves Allocated Successfully for {0}',b'Listi Dodeljena Uspe\xc5\xa1no za {0}'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42',b'No Items to pack',b'Ni prispevkov za pakiranje'
+b'DocType: Shipping Rule Condition',b'From Value',b'Od vrednosti'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +606',b'Manufacturing Quantity is mandatory',b'Proizvodnja Koli\xc4\x8dina je obvezna'
+b'DocType: Employee Loan',b'Repayment Method',b'Povra\xc4\x8dilo Metoda'
+b'DocType: Products Settings',"b'If checked, the Home page will be the default Item Group for the website'","b'\xc4\x8ce je omogo\xc4\x8deno, bo Naslovna stran je skupina privzeta to\xc4\x8dka za spletno stran'"
+b'DocType: Quality Inspection Reading',b'Reading 4',b'Branje 4'
+b'apps/erpnext/erpnext/config/hr.py +132',b'Claims for company expense.',b'Terjatve za ra\xc4\x8dun dru\xc5\xbebe.'
+b'apps/erpnext/erpnext/utilities/activation.py +118',"b'Students are at the heart of the system, add all your students'","b'\xc5\xa0tudenti so v sredi\xc5\xa1\xc4\x8du sistema, dodamo vse svoje u\xc4\x8dence'"
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97',b'Row #{0}: Clearance date {1} cannot be before Cheque Date {2}',b'Row # {0}: Datum Potrditev {1} ne more biti pred \xc4\x8cek Datum {2}'
+b'DocType: Asset Maintenance Task',b'Certificate Required',b'Zahtevano potrdilo'
+b'DocType: Company',b'Default Holiday List',b'Privzeti seznam praznikov'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +196',b'Row {0}: From Time and To Time of {1} is overlapping with {2}',b'Vrstica {0}: V \xc4\x8dasu in \xc4\x8dasu {1} se prekrivajo z {2}'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145',b'Stock Liabilities',b'Zaloga Obveznosti'
+b'DocType: Purchase Invoice',b'Supplier Warehouse',b'Dobavitelj Skladi\xc5\xa1\xc4\x8de'
+b'DocType: Opportunity',b'Contact Mobile No',b'Kontaktna mobilna \xc5\xa1tevilka'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +399',b'Select Company',b'Izberite podjetje'
+,b'Material Requests for which Supplier Quotations are not created',b'Material Pro\xc5\xa1nje za katere so Dobavitelj Citati ni ustvaril'
+b'DocType: Student Report Generation Tool',b'Print Section',b'Oddelek za tiskanje'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34',"b""User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.""",b'Uporabnik {0} nima privzetega profila POS. Preverite privzeto na vrstici {1} za tega uporabnika.'
+b'DocType: Student Group',b'Set 0 for no limit',b'Nastavite 0 za brez omejitev'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +122',b'The day(s) on which you are applying for leave are holidays. You need not apply for leave.',"b'Dan (s), na kateri se prijavljate za dopust, so prazniki. Vam ni treba zaprositi za dopust.'"
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64',b'Row {idx}: {field} is required to create the Opening {invoice_type} Invoices',b'Vrstica {idx}: {field} je potrebna za ustvarjanje ra\xc4\x8dunov za odpiranje {invoice_type}'
+b'DocType: Customer',b'Primary Address and Contact Detail',b'Osnovni naslov in kontaktni podatki'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20',b'Resend Payment Email',b'Ponovno po\xc5\xa1lji pla\xc4\x8dila Email'
+b'apps/erpnext/erpnext/templates/pages/projects.html +27',b'New task',b'Nova naloga'
+b'DocType: Consultation',b'Appointment',b'Imenovanje'
+b'apps/erpnext/erpnext/utilities/activation.py +74',b'Make Quotation',b'Naredite predra\xc4\x8dun'
+b'apps/erpnext/erpnext/config/education.py +230',b'Other Reports',b'Druga poro\xc4\x8dila'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +39',b'Please select at least one domain.',b'Izberite vsaj eno domeno.'
+b'DocType: Dependent Task',b'Dependent Task',b'Odvisna Task'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +444',b'Conversion factor for default Unit of Measure must be 1 in row {0}',"b'Faktor pretvorbe za privzeto mersko enoto, mora biti 1 v vrstici {0}'"
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +188',b'Leave of type {0} cannot be longer than {1}',b'Dopust tipa {0} ne more biti dalj\xc5\xa1i od {1}'
+b'DocType: Manufacturing Settings',b'Try planning operations for X days in advance.',b'Poskusite na\xc4\x8drtovanju operacij za X dni vnaprej.'
+b'DocType: HR Settings',b'Stop Birthday Reminders',b'Stop Birthday opomniki'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235',b'Please set Default Payroll Payable Account in Company {0}',"b'Prosimo, nastavite privzetega izpla\xc4\x8dane pla\xc4\x8de je treba pla\xc4\x8dati ra\xc4\x8dun v dru\xc5\xbebi {0}'"
+b'DocType: SMS Center',b'Receiver List',b'Sprejemnik Seznam'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1094',b'Search Item',b'Iskanje Item'
+b'DocType: Payment Schedule',b'Payment Amount',b'Znesek Pla\xc4\x8dila'
+b'DocType: Patient Appointment',b'Referring Physician',b'Referen\xc4\x8dni zdravnik'
+b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46',b'Consumed Amount',b'Porabljeni znesek'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +100',b'Net Change in Cash',b'Neto sprememba v gotovini'
+b'DocType: Assessment Plan',b'Grading Scale',b'Ocenjevalna lestvica'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +438',b'Unit of Measure {0} has been entered more than once in Conversion Factor Table',b'Merska enota {0} je v pretvorbeni faktor tabeli vpisana ve\xc4\x8d kot enkrat'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +639',b'Already completed',b'\xc5\xbee kon\xc4\x8dana'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33',b'Stock In Hand',b'Zaloga v roki'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64',b'Import Successful!',b'Uvoz uspe\xc5\xa1no!'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29',b'Payment Request already exists {0}',b'Pla\xc4\x8dilni Nalog \xc5\xbee obstaja {0}'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27',b'Cost of Issued Items',b'Stro\xc5\xa1ek izdanih postavk'
+b'DocType: Physician',b'Hospital',b'Bolni\xc5\xa1nica'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +385',b'Quantity must not be more than {0}',b'Koli\xc4\x8dina ne sme biti ve\xc4\x8d kot {0}'
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117',b'Previous Financial Year is not closed',b'Prej\xc5\xa1nja Prora\xc4\x8dunsko leto ni zaprt'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46',b'Age (Days)',b'Starost (dnevi)'
+b'DocType: Quotation Item',b'Quotation Item',b'Postavka ponudbe'
+b'DocType: Customer',b'Customer POS Id',b'ID POS stranka'
+b'DocType: Account',b'Account Name',b'Ime ra\xc4\x8duna'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40',b'From Date cannot be greater than To Date',b'Od datum ne more biti ve\xc4\x8dja kot doslej'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198',b'Serial No {0} quantity {1} cannot be a fraction',b'Serijska \xc5\xa1t {0} koli\xc4\x8dina {1} ne more biti del'
+b'apps/erpnext/erpnext/config/buying.py +43',b'Supplier Type master.',b'Dobavitelj Type gospodar.'
+b'DocType: Purchase Order Item',b'Supplier Part Number',b'Dobavitelj \xc5\xa0tevilka dela'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108',b'Conversion rate cannot be 0 or 1',b'Menjalno razmerje ne more biti 0 ali 1'
+b'DocType: Share Balance',b'To No',b'Na \xc5\xa1t'
+b'DocType: Subscription',b'Reference Document',b'referen\xc4\x8dni dokument'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +229',b'{0} {1} is cancelled or stopped',b'{0} {1} je preklican ali ustavljen'
+b'DocType: Accounts Settings',b'Credit Controller',b'Credit Controller'
+b'DocType: Grant Application',b'Applicant Type',b'Vrsta vlagatelja'
+b'DocType: Purchase Invoice',b'03-Deficiency in services',b'03-Pomanjkanje storitev'
+b'DocType: Delivery Note',b'Vehicle Dispatch Date',b'Vozilo Dispatch Datum'
+b'DocType: Healthcare Settings',b'Default Medical Code Standard',b'Privzeti standard za medicinsko kodo'
+b'DocType: Purchase Invoice Item',b'HSN/SAC',b'TARIC'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237',b'Purchase Receipt {0} is not submitted',b'Potrdilo o nakupu {0} ni predlo\xc5\xbeila'
+b'DocType: Company',b'Default Payable Account',b'Privzeto pla\xc4\x8dljivo ra\xc4\x8dun'
+b'apps/erpnext/erpnext/config/website.py +17',"b'Settings for online shopping cart such as shipping rules, price list etc.'","b'Nastavitve za spletni ko\xc5\xa1arici, kot so predpisi v pomorskem prometu, cenik itd'"
+b'apps/erpnext/erpnext/controllers/website_list_for_contact.py +113',b'{0}% Billed',b'{0}% zara\xc4\x8dunano'
+b'apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18',b'Reserved Qty',b'Rezervirano Kol'
+b'DocType: Party Account',b'Party Account',b'Ra\xc4\x8dun Party'
+b'apps/erpnext/erpnext/config/setup.py +122',b'Human Resources',b'\xc4\x8clove\xc5\xa1ki viri'
+b'DocType: Lead',b'Upper Income',b'Zgornja Prihodki'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17',b'Reject',b'Zavrni'
+b'DocType: Journal Entry Account',b'Debit in Company Currency',b'Debetno v podjetju valuti'
+b'DocType: BOM Item',b'BOM Item',b'BOM Postavka'
+b'DocType: Appraisal',b'For Employee',b'Za zaposlenega'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49',b'Make Disbursement Entry',b'Naredite izpla\xc4\x8dilu vnos'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138',b'Row {0}: Advance against Supplier must be debit',b'Vrstica {0}: Advance zoper dobavitelja mora biti v breme'
+b'DocType: Company',b'Default Values',b'Privzete vrednosti'
+b'DocType: Membership',b'INR',b'INR'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60',b'{frequency} Digest',b'{frekvenca} izvle\xc4\x8dek'
+b'DocType: Expense Claim',b'Total Amount Reimbursed',"b'Skupnega zneska, povrnjenega'"
+b'apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5',b'This is based on logs against this Vehicle. See timeline below for details',b'Ta temelji na dnevnikih glede na ta vozila. Oglejte si \xc4\x8dasovnico spodaj za podrobnosti'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90',b'Against Supplier Invoice {0} dated {1}',b'Zoper dobavitelja Ra\xc4\x8dun {0} dne {1}'
+b'DocType: Customer',b'Default Price List',b'Privzeto Cenik'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +322',b'Asset Movement record {0} created',b'zapis Gibanje sredstvo {0} ustvaril'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51',b'You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings',"b'Ne, ne more\xc5\xa1 brisati poslovnega leta {0}. Poslovno leto {0} je privzet v globalnih nastavitvah'"
+b'apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20',b'A customer with the same name already exists',b'Kupec z istim imenom \xc5\xbee obstaja'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +185',b'This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?',b'To bo poslalo pla\xc4\x8dne liste in ustvarilo \xc4\x8dasovni razpored poro\xc4\x8danja. \xc5\xbdelite nadaljevati?'
+b'DocType: Purchase Invoice',b'Total Net Weight',b'Skupna neto te\xc5\xbea'
+b'DocType: Purchase Invoice',b'Eligibility For ITC',b'Upravi\xc4\x8denost do ITC'
+b'DocType: Journal Entry',b'Entry Type',b'Za\xc4\x8detek Type'
+,b'Customer Credit Balance',b'Stranka Credit Balance'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +28',b'Net Change in Accounts Payable',b'Neto sprememba obveznosti do dobaviteljev'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48',b'EcritureLet',b'EcritureLet'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +209',b'Credit limit has been crossed for customer {0} ({1}/{2})',b'Kreditna meja je pre\xc5\xa1la za stranko {0} ({1} / {2})'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42',"b""Customer required for 'Customerwise Discount'""",b'Stranka zahteva za &quot;Customerwise popust&quot;'
+b'apps/erpnext/erpnext/config/accounts.py +140',b'Update bank payment dates with journals.',b'Posodobite rok pla\xc4\x8dila banka s revijah.'
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21',b'Pricing',b'Cenitev'
+b'DocType: Quotation',b'Term Details',b'Izraz Podrobnosti'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30',b'Cannot enroll more than {0} students for this student group.',b'ne more vpisati ve\xc4\x8d kot {0} \xc5\xa1tudentov za to \xc5\xa1tudentsko skupino.'
+b'apps/erpnext/erpnext/templates/print_formats/includes/total.html +4',b'Total (Without Tax)',b'Skupaj (brez davka)'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17',b'Lead Count',b'svinec \xc5\xa0tetje'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17',b'Lead Count',b'svinec \xc5\xa0tetje'
+b'apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15',b'{0} must be greater than 0',b'{0} mora biti ve\xc4\x8dje od 0'
+b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +30',b'Stock Available',b'Stock Na voljo'
+b'DocType: Manufacturing Settings',b'Capacity Planning For (Days)',b'Kapaciteta Na\xc4\x8drtovanje Za (dnevi)'
+b'apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10',b'Procurement',b'Javna naro\xc4\x8dila'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +66',b'None of the items have any change in quantity or value.',b'Nobena od postavk imate kakr\xc5\xa1ne koli spremembe v koli\xc4\x8dini ali vrednosti.'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17',b'Mandatory field - Program',b'Obvezno polje - program'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17',b'Mandatory field - Program',b'Obvezno polje - program'
+b'DocType: Special Test Template',b'Result Component',b'Komponenta rezultata'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46',b'Warranty Claim',b'Garancija zahtevek'
+,b'Lead Details',b'Podrobnosti ponudbe'
+b'DocType: Volunteer',b'Availability and Skills',b'Razpolo\xc5\xbeljivost in spretnosti'
+b'DocType: Salary Slip',b'Loan repayment',b'vra\xc4\x8dila posojila'
+b'DocType: Purchase Invoice',"b""End date of current invoice's period""",b'Kon\xc4\x8dni datum obdobja teko\xc4\x8dega faktura je'
+b'DocType: Pricing Rule',b'Applicable For',b'Velja za'
+b'DocType: Lab Test',b'Technician Name',b'Ime tehnika'
+b'DocType: Accounts Settings',b'Unlink Payment on Cancellation of Invoice',b'Prekinitev povezave med Pla\xc4\x8dilo na Izbris ra\xc4\x8duna'
+b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16',b'Current Odometer reading entered should be greater than initial Vehicle Odometer {0}',b'Trenutni Stanje kilometrov vpisana mora biti ve\xc4\x8dja od za\xc4\x8detne \xc5\xa1tevca prevo\xc5\xbeene poti vozila {0}'
+b'DocType: Restaurant Reservation',b'No Show',b'Ni predstave'
+b'DocType: Shipping Rule Country',b'Shipping Rule Country',b'Dr\xc5\xbeava dostavnega pravila'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10',b'Leave and Attendance',b'Pusti in postre\xc5\xbebo'
+b'DocType: Maintenance Visit',b'Partially Completed',b'Delno Dopolnil'
+b'apps/erpnext/erpnext/healthcare/setup.py +257',b'Moderate Sensitivity',b'Zmerna ob\xc4\x8dutljivost'
+b'DocType: Leave Type',b'Include holidays within leaves as leaves',b'Vklju\xc4\x8dite po\xc4\x8ditnice v listih kot listja'
+b'DocType: Sales Invoice',b'Packed Items',b'Pakirane Items'
+b'apps/erpnext/erpnext/config/support.py +27',b'Warranty Claim against Serial No.',b'Garancija zahtevek zoper Serial No.'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +197',"b""'Total'""",b'&quot;Skupaj&quot;'
+b'DocType: Shopping Cart Settings',b'Enable Shopping Cart',b'Omogo\xc4\x8di Ko\xc5\xa1arica'
+b'DocType: Employee',b'Permanent Address',b'stalni naslov'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260',b'Advance paid against {0} {1} cannot be greater \\\n\t\t\t\t\t\tthan Grand Total {2}',b'Izpla\xc4\x8dano predpla\xc4\x8dilo proti {0} {1} ne more biti ve\xc4\x8dja \\ kot Grand Total {2}'
+b'DocType: Consultation',b'Medication',b'Zdravila'
+b'DocType: Production Plan',b'Include Non Stock Items',b'Vklju\xc4\x8dite elemente brez zaloge'
+b'DocType: Project Update',b'Challenging/Slow',b'Izzivalno / po\xc4\x8dasno'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147',b'Please select item code',"b'Prosimo, izberite postavko kodo'"
+b'DocType: Student Sibling',b'Studying in Same Institute',b'\xc5\xa0tudij v istem in\xc5\xa1titutu'
+b'DocType: Territory',b'Territory Manager',b'Ozemlje Manager'
+b'DocType: Packed Item',b'To Warehouse (Optional)',b'Da Warehouse (po \xc5\xbeelji)'
+b'DocType: GST Settings',b'GST Accounts',b'GST ra\xc4\x8duni'
+b'DocType: Payment Entry',b'Paid Amount (Company Currency)',b'Pla\xc4\x8dan znesek (dru\xc5\xbeba Valuta)'
+b'DocType: Purchase Invoice',b'Additional Discount',b'Dodatni popust'
+b'DocType: Selling Settings',b'Selling Settings',b'Prodaja Nastavitve'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83',b'Confirm Action',b'Potrdi dejanje'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39',b'Online Auctions',b'Online Dra\xc5\xbebe'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +100',b'Please specify either Quantity or Valuation Rate or both',"b'Prosimo, navedite bodisi koli\xc4\x8dina ali Ocenite vrednotenja ali oboje'"
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18',b'Fulfillment',b'izpolnitev'
+b'apps/erpnext/erpnext/templates/generators/item.html +82',b'View in Cart',b'Poglej v ko\xc5\xa1arico'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103',b'Marketing Expenses',b'Marketing Stro\xc5\xa1ki'
+,b'Item Shortage Report',b'Postavka Pomanjkanje Poro\xc4\x8dilo'
+b'apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py +15',"b""Can't create standard criteria. Please rename the criteria""",b'Ne morem ustvariti standardnih meril. Preimenujte merila'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +311',"b'Weight is mentioned,\\nPlease mention ""Weight UOM"" too'","b'Te\xc5\xbea je omenjeno, \\ nProsim omenja &quot;Te\xc5\xbea UOM&quot; preve\xc4\x8d'"
+b'DocType: Stock Entry Detail',b'Material Request used to make this Stock Entry',b'Material Zahteva se uporablja za izdelavo tega stale\xc5\xbea Entry'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +68',b'Next Depreciation Date is mandatory for new asset',b'Naslednja Amortizacija Datum je obvezna za nove investicije'
+b'DocType: Student Group Creation Tool',b'Separate course based Group for every Batch',b'Lo\xc4\x8deno Group s sede\xc5\xbeem te\xc4\x8daj za vsako serijo'
+b'DocType: Student Group Creation Tool',b'Separate course based Group for every Batch',b'Lo\xc4\x8deno Group s sede\xc5\xbeem te\xc4\x8daj za vsako serijo'
+b'apps/erpnext/erpnext/config/support.py +32',b'Single unit of an Item.',b'Enotni enota to\xc4\x8dke.'
+b'DocType: Fee Category',b'Fee Category',b'Fee Kategorija'
+b'DocType: Agriculture Task',b'Next Business Day',b'Naslednji delovni dan'
+b'DocType: Drug Prescription',b'Dosage by time interval',b'Odmerjanje po \xc4\x8dasovnem intervalu'
+b'DocType: Cash Flow Mapper',b'Section Header',b'Naslov glave'
+,b'Student Fee Collection',b'\xc5\xa0tudent Fee Collection'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +24',b'Appointment Duration (mins)',b'Trajanje imenovanja (min)'
+b'DocType: Accounts Settings',b'Make Accounting Entry For Every Stock Movement',b'Naredite vknji\xc5\xbeba Za vsako borzno gibanje'
+b'DocType: Leave Allocation',b'Total Leaves Allocated',b'Skupaj Listi Dodeljena'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163',b'Warehouse required at Row No {0}',b'Skladi\xc5\xa1\xc4\x8de zahteva pri Row \xc5\xa1t {0}'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +145',b'Please enter valid Financial Year Start and End Dates',"b'Prosimo, vnesite veljaven prora\xc4\x8dunsko leto, datum za\xc4\x8detka in konca'"
+b'DocType: Employee',b'Date Of Retirement',b'Datum upokojitve'
+b'DocType: Upload Attendance',b'Get Template',b'Get predlogo'
+b'DocType: Material Request',b'Transferred',b'Preneseni'
+b'DocType: Vehicle',b'Doors',b'vrata'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117',b'ERPNext Setup Complete!',b'ERPNext Setup Complete!'
+b'DocType: Healthcare Settings',b'Collect Fee for Patient Registration',b'Zberi pristojbino za registracijo pacientov'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +678',b'Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item',b'Ne morem spremeniti atributov po transakciji z delnicami. Na novo postavko naredite nov element in prenesite zalogo'
+b'DocType: Course Assessment Criteria',b'Weightage',b'Weightage'
+b'DocType: Purchase Invoice',b'Tax Breakup',b'dav\xc4\x8dna Breakup'
+b'DocType: Packing Slip',b'PS-',b'PS-'
+b'DocType: Member',b'Non Profit Member',b'Neprofitni \xc4\x8dlan'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67',"b""{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.""","b'{0} {1}: Stro\xc5\xa1kovno mesto je zahtevano za ""Izkaz poslovnega izida"" ra\xc4\x8duna {2}. Nastavite privzeto stro\xc5\xa1kovno mesto za dru\xc5\xbebo.'"
+b'DocType: Payment Schedule',b'Payment Term',b'Pogoji pla\xc4\x8dila'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +160',b'A Customer Group exists with same name please change the Customer name or rename the Customer Group',"b'A Skupina kupcev obstaja z istim imenom, prosimo spremenite ime stranke ali preimenovati skupino odjemalcev'"
+b'DocType: Land Unit',b'Area',b'Obmo\xc4\x8dje'
+b'apps/erpnext/erpnext/public/js/templates/contact_list.html +37',b'New Contact',b'Nov kontakt'
+b'DocType: Territory',b'Parent Territory',b'Parent Territory'
+b'DocType: Purchase Invoice',b'Place of Supply',b'Kraj dobave'
+b'DocType: Quality Inspection Reading',b'Reading 2',b'Branje 2'
+b'DocType: Stock Entry',b'Material Receipt',b'Material Prejem'
+b'DocType: Homepage',b'Products',b'Izdelki'
+b'DocType: Announcement',b'Instructor',b'in\xc5\xa1truktor'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61',b'Select Item (optional)',b'Izberite postavko (neobvezno)'
+b'DocType: Fee Schedule Student Group',b'Fee Schedule Student Group',b'Skupina \xc5\xa1tudijskih ur'
+b'DocType: Student',b'AB+',b'AB +'
+b'DocType: Item',"b'If this item has variants, then it cannot be selected in sales orders etc.'","b'\xc4\x8ce ima ta postavka variante, potem ne more biti izbran v prodajnih naro\xc4\x8dil itd'"
+b'DocType: Lead',b'Next Contact By',b'Naslednja Kontakt Z'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +325',b'Quantity required for Item {0} in row {1}',"b'Koli\xc4\x8dina, potrebna za postavko {0} v vrstici {1}'"
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +45',b'Warehouse {0} can not be deleted as quantity exists for Item {1}',"b'Skladi\xc5\xa1\xc4\x8de {0} ni mogo\xc4\x8de izbrisati, kot obstaja koli\xc4\x8dina za postavko {1}'"
+b'DocType: Quotation',b'Order Type',b'Sklep Type'
+,b'Item-wise Sales Register',b'Element-pametno Sales Registriraj se'
+b'DocType: Asset',b'Gross Purchase Amount',b'Bruto znesek nakupa'
+b'apps/erpnext/erpnext/utilities/user_progress.py +39',b'Opening Balances',b'Za\xc4\x8detne stave'
+b'DocType: Asset',b'Depreciation Method',b'Metoda amortiziranja'
+b'DocType: Purchase Taxes and Charges',b'Is this Tax included in Basic Rate?',b'Je to DDV vklju\xc4\x8den v osnovni stopnji?'
+b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56',b'Total Target',b'Skupaj Target'
+b'DocType: Soil Texture',b'Sand Composition (%)',b'Sestava peska (%)'
+b'DocType: Job Applicant',b'Applicant for a Job',b'Kandidat za slu\xc5\xbebo'
+b'DocType: Production Plan Material Request',b'Production Plan Material Request',b'Proizvodnja Zahteva na\xc4\x8drt Material'
+b'DocType: Stock Reconciliation',b'Reconciliation JSON',b'Uskladitev JSON'
+b'apps/erpnext/erpnext/accounts/report/financial_statements.html +3',b'Too many columns. Export the report and print it using a spreadsheet application.',b'Preve\xc4\x8d stolpcev. Izvoziti poro\xc4\x8dilo in ga natisnete s pomo\xc4\x8djo aplikacije za preglednice.'
+b'DocType: Purchase Invoice Item',b'Batch No',b'Serija Ne'
+b'DocType: Selling Settings',"b""Allow multiple Sales Orders against a Customer's Purchase Order""",b'Dovoli ve\xc4\x8d prodajnih nalogov zoper naro\xc4\x8dnikovo narocilo'
+b'DocType: Student Group Instructor',b'Student Group Instructor',b'In\xc5\xa1truktor \xc5\xa0tudent Skupina'
+b'DocType: Student Group Instructor',b'Student Group Instructor',b'In\xc5\xa1truktor \xc5\xa0tudent Skupina'
+b'DocType: Grant Application',b'Assessment  Mark (Out of 10)',b'Ocenjevalna oznaka (od 10)'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61',b'Guardian2 Mobile No',b'Skrbnika2 Mobile No'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +218',b'Main',b'Main'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +72',b'Variant',b'Variant'
+b'DocType: Naming Series',b'Set prefix for numbering series on your transactions',b'Nastavite predpona za \xc5\xa1tevil\xc4\x8denje serij na va\xc5\xa1e transakcije'
+b'DocType: Employee Attendance Tool',b'Employees HTML',b'zaposleni HTML'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +458',b'Default BOM ({0}) must be active for this item or its template',b'Privzeto BOM ({0}) mora biti aktiven za to postavko ali njeno predlogo'
+b'DocType: Employee',b'Leave Encashed?',b'Dopusta unov\xc4\x8dijo?'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32',b'Opportunity From field is mandatory',b'Prilo\xc5\xbenost Iz polja je obvezno'
+b'DocType: Email Digest',b'Annual Expenses',b'letni stro\xc5\xa1ki'
+b'DocType: Item',b'Variants',b'Variante'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1148',b'Make Purchase Order',b'Naredite narocilo'
+b'DocType: SMS Center',b'Send To',b'Po\xc5\xa1lji'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133',b'There is not enough leave balance for Leave Type {0}',b'Ni dovolj bilanca dopust za dopust tipa {0}'
+b'DocType: Payment Reconciliation Payment',b'Allocated amount',b'Dodeljen znesek'
+b'DocType: Sales Team',b'Contribution to Net Total',b'Prispevek k Net Total'
+b'DocType: Sales Invoice Item',"b""Customer's Item Code""",b'Koda artikla stranke'
+b'DocType: Stock Reconciliation',b'Stock Reconciliation',b'Uskladitev zalog'
+b'DocType: Territory',b'Territory Name',b'Territory Name'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +204',b'Work-in-Progress Warehouse is required before Submit',b'Work-in-Progress Warehouse je pred potreben Submit'
+b'apps/erpnext/erpnext/config/hr.py +40',b'Applicant for a Job.',b'Kandidat za slu\xc5\xbebo.'
+b'DocType: Purchase Order Item',b'Warehouse and Reference',b'Skladi\xc5\xa1\xc4\x8de in Reference'
+b'DocType: Supplier',b'Statutory info and other general information about your Supplier',b'Statutarna info in druge splo\xc5\xa1ne informacije o va\xc5\xa1em dobavitelju'
+b'DocType: Item',b'Serial Nos and Batches',b'Serijska \xc5\xa1t in Serije'
+b'DocType: Item',b'Serial Nos and Batches',b'Serijska \xc5\xa1t in Serije'
+b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42',b'Student Group Strength',b'\xc5\xa0tudent Skupina mo\xc4\x8d'
+b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42',b'Student Group Strength',b'\xc5\xa0tudent Skupina mo\xc4\x8d'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +261',b'Against Journal Entry {0} does not have any unmatched {1} entry',b'Proti listu Za\xc4\x8detek {0} nima neprimerljivo {1} vnos'
+b'apps/erpnext/erpnext/config/hr.py +142',b'Appraisals',b'cenitve'
+b'apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8',b'Training Events',b'Dogodki za usposabljanje'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205',b'Duplicate Serial No entered for Item {0}',b'Podvajati Zaporedna \xc5\xa1tevilka vpisana v postavko {0}'
+b'apps/erpnext/erpnext/config/selling.py +179',b'Track Leads by Lead Source.',b'Sledite navodilom po viru.'
+b'DocType: Shipping Rule Condition',b'A condition for a Shipping Rule',b'Pogoj za Shipping pravilu'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +167',b'Please enter ',b'vnesite'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43',b'Maintenance Log',b'Dnevnik vzdr\xc5\xbeevanja'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +236',b'Please set filter based on Item or Warehouse',"b'Prosim, nastavite filter, ki temelji na postavki ali skladi\xc5\xa1\xc4\x8de'"
+b'DocType: Packing Slip',b'The net weight of this package. (calculated automatically as sum of net weight of items)',b'Neto te\xc5\xbea tega paketa. (samodejno izra\xc4\x8duna kot vsota neto te\xc5\xbeo blaga)'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +802',b'Discount amount cannot be greater than 100%',b'Znesek popusta ne sme biti ve\xc4\x8dji od 100%'
+b'DocType: Sales Order',b'To Deliver and Bill',b'Dostaviti in Bill'
+b'DocType: Student Group',b'Instructors',b'in\xc5\xa1truktorji'
+b'DocType: GL Entry',b'Credit Amount in Account Currency',b'Credit Znesek v Valuta ra\xc4\x8duna'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +603',b'BOM {0} must be submitted',b'BOM {0} je treba predlo\xc5\xbeiti'
+b'apps/erpnext/erpnext/config/accounts.py +460',b'Share Management',b'Deljeno upravljanje'
+b'DocType: Authorization Control',b'Authorization Control',b'Pooblastilo za nadzor'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +317',b'Row #{0}: Rejected Warehouse is mandatory against rejected Item {1}',b'Vrstica # {0}: zavrnitev Skladi\xc5\xa1\xc4\x8de je obvezno proti zavrnil postavki {1}'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810',b'Payment',b'Pla\xc4\x8dilo'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +92',"b'Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.'","b'Skladi\xc5\xa1\xc4\x8de {0} ni povezano z nobenim ra\xc4\x8dunom, navedite ra\xc4\x8dun v evidenco skladi\xc5\xa1\xc4\x8de ali nastavite privzeto inventarja ra\xc4\x8dun v dru\xc5\xbebi {1}.'"
+b'apps/erpnext/erpnext/utilities/activation.py +81',b'Manage your orders',b'Upravljajte naro\xc4\x8dila'
+b'DocType: Work Order Operation',b'Actual Time and Cost',b'Dejanski \xc4\x8das in stro\xc5\xa1ki'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +56',b'Material Request of maximum {0} can be made for Item {1} against Sales Order {2}',b'Material Zahteva za najve\xc4\x8d {0} se lahko izvede za postavko {1} proti Sales Order {2}'
+b'DocType: Crop',b'Crop Spacing',b'Razmik rastlin'
+b'DocType: Course',b'Course Abbreviation',b'Kratica za te\xc4\x8daj'
+b'DocType: Student Leave Application',b'Student Leave Application',b'\xc5\xa0tudent Zapusti Uporaba'
+b'DocType: Item',b'Will also apply for variants',b'Bo veljalo tudi za variante'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +217',"b'Asset cannot be cancelled, as it is already {0}'","b'Sredstvo ni mogo\xc4\x8de preklicati, saj je \xc5\xbee {0}'"
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29',b'Employee {0} on Half day on {1}',b'Zaposlenih {0} v pol dneva na {1}'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42',b'Total working hours should not be greater than max working hours {0}',b'Skupaj delovni \xc4\x8das ne sme biti ve\xc4\x8dja od max delovnih ur {0}'
+b'apps/erpnext/erpnext/templates/pages/task_info.html +90',b'On',b'na'
+b'apps/erpnext/erpnext/config/selling.py +62',b'Bundle items at time of sale.',b'Bundle predmeti v \xc4\x8dasu prodaje.'
+b'DocType: Material Request Plan Item',b'Actual Qty',b'Dejanska Koli\xc4\x8dina'
+b'DocType: Sales Invoice Item',b'References',b'Reference'
+b'DocType: Quality Inspection Reading',b'Reading 10',b'Branje 10'
+b'DocType: Item',b'Barcodes',b'\xc4\x8crtne kode'
+b'DocType: Hub Category',b'Hub Node',b'Vozli\xc5\xa1\xc4\x8dna to\xc4\x8dka'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78',b'You have entered duplicate items. Please rectify and try again.',"b'Vnesli ste podvojene elemente. Prosimo, popravite in poskusite znova.'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129',b'Associate',b'Sodelavec'
+b'DocType: Asset Movement',b'Asset Movement',b'Gibanje sredstvo'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +508',b'Work Order {0} must be submitted',b'Delovni nalog {0} mora biti predlo\xc5\xbeen'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2214',b'New Cart',b'Nova ko\xc5\xa1arico'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44',b'Item {0} is not a serialized Item',b'Postavka {0} ni serialized postavka'
+b'DocType: SMS Center',b'Create Receiver List',b'Ustvarite sprejemnik seznam'
+b'DocType: Vehicle',b'Wheels',b'kolesa'
+b'DocType: Packing Slip',b'To Package No.',b'\xc4\x8ce \xc5\xbeelite Paket No.'
+b'DocType: Patient Relation',b'Family',b'Dru\xc5\xbeina'
+b'DocType: Production Plan',b'Material Requests',b'Material Zahteve'
+b'DocType: Warranty Claim',b'Issue Date',b'Datum izdaje'
+b'DocType: Activity Cost',b'Activity Cost',b'Stro\xc5\xa1ki dejavnost'
+b'DocType: Sales Invoice Timesheet',b'Timesheet Detail',b'timesheet Podrobnosti'
+b'DocType: Purchase Receipt Item Supplied',b'Consumed Qty',b'Porabljeno Kol'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52',b'Telecommunications',b'Telekomunikacije'
+b'apps/erpnext/erpnext/accounts/party.py +263',"b""Billing currency must be equal to either default company's currency or party account currency""",b'Valuta za obra\xc4\x8dun mora biti enaka valuti podjetja ali valuti stranke'
+b'DocType: Packing Slip',b'Indicates that the package is a part of this delivery (Only Draft)',"b'Ka\xc5\xbee, da je paket del tega dostave (samo osnutka)'"
+b'DocType: Soil Texture',b'Loam',b'Loam'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +705',b'Row {0}: Due Date cannot be before posting date',b'Vrstica {0}: Datum roka ne more biti pred datumom objavljanja'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36',b'Make Payment Entry',b'Naredite Entry pla\xc4\x8dila'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129',b'Quantity for Item {0} must be less than {1}',b'Koli\xc4\x8dina za postavko {0} sme biti manj\xc5\xa1a od {1}'
+,b'Sales Invoice Trends',b'Prodajni fakturi Trendi'
+b'DocType: Leave Application',b'Apply / Approve Leaves',b'Uporabi / Odobri Leaves'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3',b'For',b'Za'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +167',"b""Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total'""","b'Lahko sklicuje vrstico le, \xc4\x8de je tip naboj &quot;Na prej\xc5\xa1nje vrstice Znesek&quot; ali &quot;prej\xc5\xa1nje vrstice Total&quot;'"
+b'DocType: Sales Order Item',b'Delivery Warehouse',b'Dostava Skladi\xc5\xa1\xc4\x8de'
+b'apps/erpnext/erpnext/config/accounts.py +241',b'Tree of financial Cost Centers.',b'Drevo centrov finan\xc4\x8dnih stro\xc5\xa1kov.'
+b'DocType: Serial No',b'Delivery Document No',b'Dostava dokument \xc5\xa1t'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191',"b""Please set 'Gain/Loss Account on Asset Disposal' in Company {0}""",b'Prosim nastavite &quot;dobi\xc4\x8dek / izguba ra\xc4\x8dun pri odtujitvi sredstev&quot; v dru\xc5\xbebi {0}'
+b'DocType: Landed Cost Voucher',b'Get Items From Purchase Receipts',b'Dobili predmetov iz nakupa Prejemki'
+b'DocType: Serial No',b'Creation Date',b'Datum nastanka'
+b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33',b'Item {0} appears multiple times in Price List {1}',b'Postavka {0} pojavi ve\xc4\x8dkrat v Ceniku {1}'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41',"b'Selling must be checked, if Applicable For is selected as {0}'","b'Prodajanje je treba preveriti, \xc4\x8de se uporablja za izbrana kot {0}'"
+b'DocType: Production Plan Material Request',b'Material Request Date',b'Material Zahteva Datum'
+b'DocType: Purchase Order Item',b'Supplier Quotation Item',b'Dobavitelj Kotacija Postavka'
+b'DocType: Student',b'Student Mobile Number',b'\xc5\xa0tudent mobilno \xc5\xa1tevilko'
+b'DocType: Item',b'Has Variants',b'Ima razli\xc4\x8dice'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +488',"b'Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings'","b'Za postavko {0} v vrstici {1} ne moremo prese\xc4\x8di ve\xc4\x8d kot {2}. \xc4\x8ce \xc5\xbeelite omogo\xc4\x8diti prekomerno zara\xc4\x8dunavanje, nastavite nastavitve zalog'"
+b'apps/erpnext/erpnext/templates/emails/training_event.html +11',b'Update Response',b'Posodobi odgovor'
+b'apps/erpnext/erpnext/public/js/utils.js +232',b'You have already selected items from {0} {1}',b'Ste \xc5\xbee izbrane postavke iz {0} {1}'
+b'DocType: Monthly Distribution',b'Name of the Monthly Distribution',b'Ime mese\xc4\x8dnim izpla\xc4\x8dilom'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +95',b'Batch ID is mandatory',b'Serija ID je obvezen'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +95',b'Batch ID is mandatory',b'Serija ID je obvezen'
+b'DocType: Sales Person',b'Parent Sales Person',b'Nadrejena Sales oseba'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +100',b'The seller and the buyer cannot be the same',b'Prodajalec in kupec ne moreta biti isti'
+b'DocType: Project',b'Collect Progress',b'Zberite napredek'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24',b'Select the program first',b'Najprej izberite program'
+b'DocType: Patient Appointment',b'Patient Age',b'Pacientova doba'
+b'apps/erpnext/erpnext/config/learn.py +253',b'Managing Projects',b'Upravljanje projektov'
+b'DocType: Supplier',b'Supplier of Goods or Services.',b'Dobavitelj blaga ali storitev.'
+b'DocType: Budget',b'Fiscal Year',b'Poslovno leto'
+b'DocType: Asset Maintenance Log',b'Planned',b'Na\xc4\x8drtovano'
+b'DocType: Healthcare Settings',b'Default receivable accounts to be used if not set in Patient to book Consultation charges.',"b'Nepla\xc4\x8dani ra\xc4\x8duni za terjatve, ki jih je treba uporabiti, \xc4\x8de niso dolo\xc4\x8deni v Patientu za rezervacijo stro\xc5\xa1kov posvetovanja.'"
+b'DocType: Vehicle Log',b'Fuel Price',b'gorivo Cena'
+b'DocType: Budget',b'Budget',b'Prora\xc4\x8dun'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +65',b'Set Open',b'Nastavi odprto'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +258',b'Fixed Asset Item must be a non-stock item.',b'Osnovno sredstvo to\xc4\x8dka mora biti postavka ne-stock.'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50',"b""Budget cannot be assigned against {0}, as it's not an Income or Expense account""","b'Prora\xc4\x8dun ne more biti dodeljena pred {0}, ker to ni prihodek ali odhodek ra\xc4\x8dun'"
+b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51',b'Achieved',b'Dose\xc5\xbeeni'
+b'DocType: Student Admission',b'Application Form Route',b'Prijavnica pot'
+b'apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66',b'Territory / Customer',b'Territory / Stranka'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44',b'Leave Type {0} cannot be allocated since it is leave without pay',"b'Pusti tipa {0} ni mogo\xc4\x8de dodeliti, ker je zapustil brez pla\xc4\x8dila'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +167',b'Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2}',"b'Vrstica {0}: Dodeljena koli\xc4\x8dina {1}, mora biti manj\xc5\xa1a ali enaka zara\xc4\x8dunati neodpla\xc4\x8danega {2}'"
+b'DocType: Sales Invoice',b'In Words will be visible once you save the Sales Invoice.',"b'V besedi bo viden, ko boste prihranili prodajni fakturi.'"
+b'DocType: Lead',b'Follow Up',b'Nadaljuj'
+b'DocType: Item',b'Is Sales Item',b'Je Sales Postavka'
+b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21',b'Item Group Tree',b'Element Group Tree'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69',b'Item {0} is not setup for Serial Nos. Check Item master',b'Postavka {0} ni setup za Serijska \xc5\xa1t. Preverite item mojster'
+b'DocType: Maintenance Visit',b'Maintenance Time',b'Vzdr\xc5\xbeevanje \xc4\x8das'
+,b'Amount to Deliver',"b'Znesek, Deliver'"
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +335',b'Same item has been entered multiple times. {0}',b'Isti element je bil ve\xc4\x8dkrat vnesen. {0}'
+b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +30',b'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.',"b'Datum izraz za\xc4\x8detka ne more biti zgodnej\xc5\xa1i od datuma Leto za\xc4\x8detku \xc5\xa1tudijskega leta, v katerem je izraz povezan (\xc5\xa1tudijsko leto {}). Popravite datum in poskusite znova.'"
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +190',b'There were errors.',b'Tam so bile napake.'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +166',b'Employee {0} has already applied for {1} between {2} and {3} : ',b'Zaposleni {0} je \xc5\xbee zaprosil za {1} med {2} in {3}:'
+b'DocType: Guardian',b'Guardian Interests',b'Guardian Zanima'
+b'DocType: Naming Series',b'Current Value',b'Trenutna vrednost'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +273',b'Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year',"b'obstaja ve\xc4\x8d prora\xc4\x8dunskih let za datum {0}. Prosim, nastavite podjetje v poslovnem letu'"
+b'DocType: Education Settings',b'Instructor Records to be created by',"b'Zapise za in\xc5\xa1truktorje, ki jih bo ustvaril'"
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229',b'{0} created',b'{0} ustvaril'
+b'DocType: GST Account',b'GST Account',b'GST ra\xc4\x8dun'
+b'DocType: Delivery Note Item',b'Against Sales Order',b'Za Naro\xc4\x8dilo Kupca'
+,b'Serial No Status',b'Serijska Status Ne'
+b'DocType: Payment Entry Reference',b'Outstanding',b'Izjemna'
+b'DocType: Supplier',b'Warn POs',b'Opozori PO'
+,b'Daily Timesheet Summary',b'Dnevni Timesheet Povzetek'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137',"b'Row {0}: To set {1} periodicity, difference between from and to date \\\n\t\t\t\t\t\tmust be greater than or equal to {2}'","b'Vrstica {0}: nastavi {1} periodi\xc4\x8dnost, razlika med od do sedaj \\ mora biti ve\xc4\x8dja od ali enaka {2}'"
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6',b'This is based on stock movement. See {0} for details',b'Ta temelji na gibanju zalog. Glej {0} za podrobnosti'
+b'DocType: Pricing Rule',b'Selling',b'Prodaja'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +392',b'Amount {0} {1} deducted against {2}',b'Znesek {0} {1} od\xc5\xa1teti pred {2}'
+b'DocType: Employee',b'Salary Information',b'Pla\xc4\x8da Informacije'
+b'DocType: Sales Person',b'Name and Employee ID',b'Ime in zaposlenih ID'
+b'apps/erpnext/erpnext/accounts/party.py +308',b'Due Date cannot be before Posting Date',b'Rok ne more biti pred datumom knji\xc5\xbeenja'
+b'DocType: Website Item Group',b'Website Item Group',b'Spletna stran Element Group'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +463',b'No salary slip found to submit for the above selected criteria OR salary slip already submitted',"b'Za zgoraj navedena izbrana merila ILI pla\xc4\x8dilni list, ki je \xc5\xbee bil predlo\xc5\xbeen, ni bilo mogo\xc4\x8de najti nobene pla\xc4\x8dilne liste'"
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150',b'Duties and Taxes',b'Dajatve in davki'
+b'DocType: Projects Settings',b'Projects Settings',b'Nastavitve projektov'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356',b'Please enter Reference date',b'Vnesite Referen\xc4\x8dni datum'
+b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44',b'{0} payment entries can not be filtered by {1}',b'{0} vnosov pla\xc4\x8dil ni mogo\xc4\x8de filtrirati s {1}'
+b'DocType: Item Website Specification',b'Table for Item that will be shown in Web Site',"b'Tabela za postavko, ki bo prikazana na spletni strani'"
+b'DocType: Purchase Order Item Supplied',b'Supplied Qty',b'Prilo\xc5\xbeena Kol'
+b'DocType: Purchase Order Item',b'Material Request Item',b'Material Zahteva Postavka'
+b'apps/erpnext/erpnext/config/selling.py +75',b'Tree of Item Groups.',b'Drevo skupin artiklov.'
+b'DocType: Production Plan',b'Total Produced Qty',b'Skupno \xc5\xa1tevilo proizvedenih koli\xc4\x8din'
+b'DocType: Payroll Entry',b'Get Employee Details',b'Pridobite podrobnosti o zaposlenih'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177',b'Cannot refer row number greater than or equal to current row number for this Charge type',b'Ne more sklicevati \xc5\xa1tevilko vrstice ve\xc4\x8dja ali enaka do trenutne \xc5\xa1tevilke vrstice za to vrsto Charge'
+b'DocType: Asset',b'Sold',b'Prodano'
+,b'Item-wise Purchase History',b'Element-pametno Zgodovina nakupov'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230',"b""Please click on 'Generate Schedule' to fetch Serial No added for Item {0}""","b'Prosimo, kliknite na &quot;ustvarjajo Seznamu&quot; pu\xc5\xa1\xc4\x8dati Serijska \xc5\xa1t dodal za postavko {0}'"
+b'DocType: Account',b'Frozen',b'Frozen'
+b'DocType: Sales Invoice Payment',b'Base Amount (Company Currency)',b'Osnovna Znesek (dru\xc5\xbeba Valuta)'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +928',b'Raw Materials',b'Surovine'
+b'DocType: Payment Reconciliation Payment',b'Reference Row',b'referen\xc4\x8dna Row'
+b'DocType: Installation Note',b'Installation Time',b'Namestitev \xc4\x8das'
+b'DocType: Sales Invoice',b'Accounting Details',b'Ra\xc4\x8dunovodstvo Podrobnosti'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +113',b'Delete all the Transactions for this Company',b'Izbri\xc5\xa1i vse transakcije za to dru\xc5\xbebo'
+b'DocType: Patient',b'O Positive',b'O Pozitivno'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68',b'Investments',b'Nalo\xc5\xbebe'
+b'DocType: Issue',b'Resolution Details',b'Resolucija Podrobnosti'
+b'apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3',b'Allocations',b'dodelitve'
+b'DocType: Item Quality Inspection Parameter',b'Acceptance Criteria',b'Merila sprejemljivosti'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159',b'Please enter Material Requests in the above table',b'Vnesite Material Pro\xc5\xa1nje v zgornji tabeli'
+b'DocType: Item Attribute',b'Attribute Name',b'Ime atributa'
+b'DocType: BOM',b'Show In Website',b'Poka\xc5\xbei V Website'
+b'DocType: Shopping Cart Settings',b'Show Quantity in Website',b'Prika\xc5\xbei Koli\xc4\x8dina na spletni strani'
+b'DocType: Employee Loan Application',b'Total Payable Amount',b'Skupaj pla\xc4\x8dljivo Znesek'
+b'DocType: Task',b'Expected Time (in hours)',b'Pri\xc4\x8dakovani \xc4\x8das (v urah)'
+b'DocType: Item Reorder',b'Check in (group)',b'Preverite v (skupina)'
+b'DocType: Soil Texture',b'Silt',b'Silt'
+,b'Qty to Order',b'Koli\xc4\x8dina naro\xc4\x8diti'
+b'DocType: Period Closing Voucher',"b'The account head under Liability or Equity, in which Profit/Loss will be booked'","b'Glava ra\xc4\x8dun v odgovornosti ali kapitala, v katerem se bo dobi\xc4\x8dek / izguba rezervirana'"
+b'apps/erpnext/erpnext/config/projects.py +36',b'Gantt chart of all tasks.',b'Ganttov diagram vseh nalog.'
+b'DocType: Opportunity',b'Mins to First Response',b'Minut do prvega odziva'
+b'DocType: Pricing Rule',b'Margin Type',b'Margin Type'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15',b'{0} hours',b'{0} ur'
+b'DocType: Course',b'Default Grading Scale',b'Privzeti Ocenjevalna lestvica'
+b'DocType: Appraisal',b'For Employee Name',b'Za imena zaposlenih'
+b'DocType: Holiday List',b'Clear Table',b'Po\xc4\x8disti tabelo'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +119',b'Available slots',b'Razpolo\xc5\xbeljive slote'
+b'DocType: C-Form Invoice Detail',b'Invoice No',b'Ra\xc4\x8dun \xc5\xa1t'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +363',b'Make Payment',b'Pla\xc4\x8dam'
+b'DocType: Room',b'Room Name',b'soba Ime'
+b'DocType: Prescription Duration',b'Prescription Duration',b'Trajanje recepta'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +81',"b'Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}'","b'Pustite se ne more uporabiti / preklicana pred {0}, saj je bilanca dopust \xc5\xbee-carry posredujejo v evidenco dodeljevanja dopust prihodnji {1}'"
+b'DocType: Activity Cost',b'Costing Rate',b'Stanejo Rate'
+b'apps/erpnext/erpnext/config/selling.py +234',b'Customer Addresses And Contacts',b'Naslovi strank in kontakti'
+,b'Campaign Efficiency',b'kampanja U\xc4\x8dinkovitost'
+b'DocType: Discussion',b'Discussion',b'Diskusija'
+b'DocType: Payment Entry',b'Transaction ID',b'Transaction ID'
+b'DocType: Volunteer',b'Anytime',b'Kadarkoli'
+b'DocType: Patient',b'Surgical History',b'Kirur\xc5\xa1ka zgodovina'
+b'DocType: Employee',b'Resignation Letter Date',b'Odstop pismo Datum'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39',b'Pricing Rules are further filtered based on quantity.',b'Cenovne Pravila so dodatno filtriran temelji na koli\xc4\x8dini.'
+b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +127',b'Not Set',b'Ni nastavljeno'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335',b'Please set the Date Of Joining for employee {0}',"b'Prosimo, da dolo\xc4\x8di datum Vstop za zaposlenega {0}'"
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335',b'Please set the Date Of Joining for employee {0}',"b'Prosimo, da dolo\xc4\x8di datum Vstop za zaposlenega {0}'"
+b'DocType: Task',b'Total Billing Amount (via Time Sheet)',b'Skupni znesek pla\xc4\x8devanja (preko \xc4\x8cas lista)'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61',b'Repeat Customer Revenue',b'Ponovite Customer Prihodki'
+b'DocType: Soil Texture',b'Silty Clay Loam',b'Silty Clay Loam'
+b'DocType: Chapter',b'Chapter',b'Poglavje'
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Pair',b'Par'
+b'DocType: Mode of Payment Account',b'Default account will be automatically updated in POS Invoice when this mode is selected.',"b'Privzet ra\xc4\x8dun se samodejno posodablja v ra\xc4\x8dunu POS, ko je ta na\xc4\x8din izbran.'"
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +970',b'Select BOM and Qty for Production',b'Izberite BOM in Koli\xc4\x8dina za proizvodnjo'
+b'DocType: Asset',b'Depreciation Schedule',b'Amortizacija Razpored'
+b'apps/erpnext/erpnext/config/selling.py +124',b'Sales Partner Addresses And Contacts',b'Prodaja Partner naslovi in kontakti'
+b'DocType: Bank Reconciliation Detail',b'Against Account',b'Proti ra\xc4\x8dun'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52',b'Half Day Date should be between From Date and To Date',b'Poldnevni datum mora biti med Od datuma in Do datuma'
+b'DocType: Maintenance Schedule Detail',b'Actual Date',b'Dejanski datum'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +139',b'Please set the Default Cost Center in {0} company.',b'Center za privzete stro\xc5\xa1ke nastavite v {0} podjetju.'
+b'DocType: Item',b'Has Batch No',b'Ima \xc5\xa1tevilko serije'
+b'apps/erpnext/erpnext/public/js/utils.js +106',b'Annual Billing: {0}',b'Letni obra\xc4\x8dun: {0}'
+b'apps/erpnext/erpnext/config/accounts.py +200',b'Goods and Services Tax (GST India)',b'Dav\xc4\x8dna blago in storitve (DDV Indija)'
+b'DocType: Delivery Note',b'Excise Page Number',b'Tro\xc5\xa1arinska \xc5\xa0tevilka strani'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +227',"b'Company, From Date and To Date is mandatory'","b'Podjetje, od datuma do datuma je obvezen'"
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33',b'Get from Consultation',b'Pojdite s posvetovanja'
+b'DocType: Asset',b'Purchase Date',b'Datum nakupa'
+b'DocType: Volunteer',b'Volunteer Type',b'Volunteer Type'
+b'DocType: Student',b'Personal Details',b'Osebne podrobnosti'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193',"b""Please set 'Asset Depreciation Cost Center' in Company {0}""",b'Prosim nastavite &quot;Asset Center Amortizacija stro\xc5\xa1kov&quot; v dru\xc5\xbebi {0}'
+,b'Maintenance Schedules',b'Vzdr\xc5\xbeevanje Urniki'
+b'DocType: Task',b'Actual End Date (via Time Sheet)',b'Dejanski kon\xc4\x8dni datum (preko \xc4\x8cas lista)'
+b'DocType: Soil Texture',b'Soil Type',b'Vrsta tal'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +387',b'Amount {0} {1} against {2} {3}',b'Znesek {0} {1} proti {2} {3}'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +277',b'New Message',b'Novo sporo\xc4\x8dilo'
+,b'Quotation Trends',b'Trendi ponudb'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +160',b'Item Group not mentioned in item master for item {0}',"b'Element Group, ki niso navedeni v to\xc4\x8dki mojster za postavko {0}'"
+b'DocType: GoCardless Mandate',b'GoCardless Mandate',b'GoCardless mandat'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +368',b'Debit To account must be a Receivable account',b'Bremenitev ra\xc4\x8duna mora biti Terjatve ra\xc4\x8dun'
+b'DocType: Shipping Rule',b'Shipping Amount',b'Znesek Dostave'
+b'DocType: Supplier Scorecard Period',b'Period Score',b'Obdobje obdobja'
+b'apps/erpnext/erpnext/utilities/user_progress.py +66',b'Add Customers',b'Dodaj stranke'
+b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20',b'Pending Amount',b'Dokler Znesek'
+b'DocType: Lab Test Template',b'Special',b'Poseben'
+b'DocType: Purchase Order Item Supplied',b'Conversion Factor',b'Faktor pretvorbe'
+b'DocType: Purchase Order',b'Delivered',b'Dostavljeno'
+,b'Vehicle Expenses',b'Stro\xc5\xa1ki vozil'
+b'DocType: Serial No',b'Invoice Details',b'Podrobnosti na ra\xc4\x8dunu'
+b'DocType: Grant Application',b'Show on Website',b'Prika\xc5\xbei na spletni strani'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +212',b'Expected value after useful life must be greater than or equal to {0}',"b'Pri\xc4\x8dakovana vrednost po \xc5\xbeivljenjski dobi, mora biti ve\xc4\x8dja ali enaka {0}'"
+b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29',b'Start on',b'Za\xc4\x8dni'
+b'DocType: Hub Category',b'Hub Category',b'Kategorija vozli\xc5\xa1\xc4\x8da'
+b'DocType: Purchase Invoice',b'SEZ',b'SEZ'
+b'DocType: Purchase Receipt',b'Vehicle Number',b'\xc5\xa0tevilo vozil'
+b'DocType: Employee Loan',b'Loan Amount',b'Znesek posojila'
+b'DocType: Student Report Generation Tool',b'Add Letterhead',b'Dodaj slovo'
+b'DocType: Program Enrollment',b'Self-Driving Vehicle',b'Self-Vo\xc5\xbenja vozil'
+b'DocType: Supplier Scorecard Standing',b'Supplier Scorecard Standing',b'Stalni ocenjevalni list dobavitelja'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +443',b'Row {0}: Bill of Materials not found for the Item {1}',b'Vrstica {0}: Kosovnica nismo na\xc5\xa1li v postavki {1}'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98',b'Total allocated leaves {0} cannot be less than already approved leaves {1} for the period',b'Skupaj dodeljena listi {0} ne sme biti manj\xc5\xa1i od \xc5\xbee odobrenih listov {1} za obdobje'
+b'DocType: Journal Entry',b'Accounts Receivable',b'Terjatve'
+,b'Supplier-Wise Sales Analytics',b'Dobavitelj-Wise Prodajna Analytics'
+b'DocType: Purchase Invoice',b'Availed ITC Central Tax',b'Uporabil centralni dav\xc4\x8dni sistem za ITC'
+b'DocType: Salary Structure',b'Select employees for current Salary Structure',b'Izberite zaposlenih za sedanje strukture pla\xc4\x8d'
+b'DocType: Sales Invoice',b'Company Address Name',b'Naslov podjetja Ime'
+b'DocType: Work Order',b'Use Multi-Level BOM',b'Uporabite Multi-Level BOM'
+b'DocType: Bank Reconciliation',b'Include Reconciled Entries',b'Vklju\xc4\x8di usklajene vnose'
+b'DocType: Course',"b""Parent Course (Leave blank, if this isn't part of Parent Course)""","b'Mati\xc4\x8dno igri\xc5\xa1\xc4\x8de (pustite prazno, \xc4\x8de to ni del obvladujo\xc4\x8de Course)'"
+b'DocType: Course',"b""Parent Course (Leave blank, if this isn't part of Parent Course)""","b'Mati\xc4\x8dno igri\xc5\xa1\xc4\x8de (pustite prazno, \xc4\x8de to ni del obvladujo\xc4\x8de Course)'"
+b'DocType: Leave Control Panel',b'Leave blank if considered for all employee types',"b'Pustite prazno, \xc4\x8de velja za vse vrste zaposlenih'"
+b'DocType: Landed Cost Voucher',b'Distribute Charges Based On',b'Distribuirajo pristojbin na podlagi'
+b'DocType: Projects Settings',b'Timesheets',b'Evidence prisotnosti'
+b'DocType: HR Settings',b'HR Settings',b'Nastavitve \xc4\x8dlove\xc5\xa1kih virov'
+b'DocType: Salary Slip',b'net pay info',b'net info pla\xc4\x8dilo'
+b'DocType: Lab Test Template',b'This value is updated in the Default Sales Price List.',b'Ta vrednost se posodablja na seznamu Privzeta prodajna cena.'
+b'DocType: Email Digest',b'New Expenses',b'Novi stro\xc5\xa1ki'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +79',b'PDC/LC Amount',b'PDC / LC Znesek'
+b'DocType: Shareholder',b'Shareholder',b'Delni\xc4\x8dar'
+b'DocType: Purchase Invoice',b'Additional Discount Amount',b'Dodatni popust Koli\xc4\x8dina'
+b'DocType: Cash Flow Mapper',b'Position',b'Polo\xc5\xbeaj'
+b'DocType: Patient',b'Patient Details',b'Podrobnosti bolnika'
+b'DocType: Patient',b'B Positive',b'B Pozitivni'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +596',"b'Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.'","b'Row # {0}: Kol mora biti 1, kot to\xc4\x8dka je osnovno sredstvo. Prosimo, uporabite lo\xc4\x8deno vrstico za ve\xc4\x8dkratno Kol.'"
+b'DocType: Leave Block List Allow',b'Leave Block List Allow',b'Pustite Block List Dovoli'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +317',b'Abbr can not be blank or space',b'Abbr ne more biti prazna ali presledek'
+b'DocType: Patient Medical Record',b'Patient Medical Record',b'Zdravni\xc5\xa1ki zapis bolnika'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +68',b'Group to Non-Group',b'Skupina Non-Group'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50',b'Sports',b'\xc5\xa0port'
+b'DocType: Loan Type',b'Loan Name',b'posojilo Ime'
+b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56',b'Total Actual',b'Skupaj Actual'
+b'DocType: Lab Test UOM',b'Test UOM',b'Test UOM'
+b'DocType: Student Siblings',b'Student Siblings',b'\xc5\xa0tudentski Bratje in sestre'
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Unit',b'Enota'
+b'apps/erpnext/erpnext/stock/get_item_details.py +138',b'Please specify Company',"b'Prosimo, navedite Company'"
+,b'Customer Acquisition and Loyalty',b'Stranka Pridobivanje in zvestobe'
+b'DocType: Asset Maintenance Task',b'Maintenance Task',b'Vzdr\xc5\xbeevalna naloga'
+b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +118',b'Please set B2C Limit in GST Settings.',b'Nastavite omejitev B2C v nastavitvah GST.'
+b'DocType: Purchase Invoice',b'Warehouse where you are maintaining stock of rejected items',"b'Skladi\xc5\xa1\xc4\x8de, kjer ste vzdr\xc5\xbeevanje zalog zavrnjenih predmetov'"
+b'DocType: Work Order',b'Skip Material Transfer',b'Presko\xc4\x8di Material Transfer'
+b'DocType: Work Order',b'Skip Material Transfer',b'Presko\xc4\x8di Material Transfer'
+b'apps/erpnext/erpnext/setup/utils.py +109',b'Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually',b'Mogo\xc4\x8de najti menjalni te\xc4\x8daj za {0} in {1} za klju\xc4\x8d datumu {2}. Prosimo ustvariti zapis Valuta Exchange ro\xc4\x8dno'
+b'DocType: POS Profile',b'Price List',b'Cenik'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +22',b'{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.',"b'{0} je zdaj privzeto poslovno leto. Prosimo, osve\xc5\xbeite brskalnik, da se sprememba uveljavi.'"
+b'apps/erpnext/erpnext/projects/doctype/task/task.js +45',b'Expense Claims',b'Odhodkov Terjatve'
+b'DocType: Issue',b'Support',b'Podpora'
+,b'BOM Search',b'BOM Iskanje'
+b'DocType: Project',b'Total Consumed Material Cost  (via Stock Entry)',b'Skupni stro\xc5\xa1ki porabljenega materiala (preko zaloge na borzi)'
+b'DocType: Item',"b'Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.'","b'Objavite &quot;Na zalogi&quot; ali &quot;Ni na zalogi&quot; na vozli\xc5\xa1\xc4\x8du na podlagi zalog, ki so na voljo v tem skladi\xc5\xa1\xc4\x8du.'"
+b'DocType: Vehicle',b'Fuel Type',b'Vrsta goriva'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27',b'Please specify currency in Company',"b'Prosimo, navedite valuto v dru\xc5\xbebi'"
+b'DocType: Workstation',b'Wages per hour',b'Pla\xc4\x8de na uro'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47',b'Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3}',b'Stock ravnote\xc5\xbeje Serija {0} bo postal negativen {1} za postavko {2} v skladi\xc5\xa1\xc4\x8du {3}'
+b'apps/erpnext/erpnext/templates/emails/reorder_item.html +1',"b""Following Material Requests have been raised automatically based on Item's re-order level""",b'Po Material Zahteve so bile samodejno dvigne temelji na ravni re-naro\xc4\x8dilnico elementa'
+b'DocType: Email Digest',b'Pending Sales Orders',b'Dokler prodajnih naro\xc4\x8dil'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +312',b'Account {0} is invalid. Account Currency must be {1}',b'Ra\xc4\x8dun {0} ni veljaven. Valuta ra\xc4\x8duna mora biti {1}'
+b'DocType: Healthcare Settings',b'Remind Before',b'Opomni pred'
+b'apps/erpnext/erpnext/buying/utils.py +34',b'UOM Conversion factor is required in row {0}',b'Faktor UOM Pretvorba je potrebno v vrstici {0}'
+b'DocType: Production Plan Item',b'material_request_item',b'material_request_item'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1087',"b'Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry'","b'Row # {0}: Reference Vrsta dokumenta mora biti eden od prodajnega naloga, prodaje ra\xc4\x8duna ali Journal Entry'"
+b'DocType: Salary Component',b'Deduction',b'Odbitek'
+b'DocType: Item',b'Retain Sample',b'Ohrani vzorec'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115',b'Row {0}: From Time and To Time is mandatory.',b'Vrstica {0}: Od \xc4\x8dasa in do \xc4\x8dasa je obvezna.'
+b'DocType: Stock Reconciliation Item',b'Amount Difference',b'znesek Razlika'
+b'apps/erpnext/erpnext/stock/get_item_details.py +356',b'Item Price added for {0} in Price List {1}',b'Postavka Cena dodana za {0} v Ceniku {1}'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8',b'Please enter Employee Id of this sales person',b'Vnesite ID Employee te prodaje oseba'
+b'DocType: Territory',b'Classification of Customers by region',b'Razvrstitev stranke po regijah'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71',b'In Production',b'V izdelavi'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +65',b'Difference Amount must be zero',b'Razlika Znesek mora biti ni\xc4\x8d'
+b'DocType: Project',b'Gross Margin',b'Gross Margin'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +61',b'Please enter Production Item first',"b'Prosimo, da najprej vnesete Production artikel'"
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45',b'Calculated Bank Statement balance',b'Izra\xc4\x8dunan Izjava bilance banke'
+b'DocType: Normal Test Template',b'Normal Test Template',b'Obi\xc4\x8dajna preskusna predloga'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64',b'disabled user',b'onemogo\xc4\x8dena uporabnik'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +919',b'Quotation',b'Ponudba'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +984',b'Cannot set a received RFQ to No Quote',b'Prejeti RFQ ni mogo\xc4\x8de nastaviti na nobeno ceno'
+b'DocType: Quotation',b'QTN-',b'QTN-'
+b'DocType: Salary Slip',b'Total Deduction',b'Skupaj Odbitek'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +18',b'Select an account to print in account currency',"b'Izberite ra\xc4\x8dun, ki ga \xc5\xbeelite natisniti v valuti ra\xc4\x8duna'"
+,b'Production Analytics',b'proizvodne Analytics'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6',b'This is based on transactions against this Patient. See timeline below for details',b'To temelji na transakcijah proti temu bolniku. Podrobnosti si oglejte spodaj'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +204',b'Cost Updated',b'Stro\xc5\xa1kovno Posodobljeno'
+b'DocType: Patient',b'Date of Birth',b'Datum rojstva'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +133',b'Item {0} has already been returned',b'Postavka {0} je bil \xc5\xbee vrnjen'
+b'DocType: Fiscal Year',b'**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.',b'**Poslovno leto** predstavlja knjigovodsko leto. Vse vknji\xc5\xbebe in druge transakcije so povezane s **poslovnim letom**.'
+b'DocType: Opportunity',b'Customer / Lead Address',b'Stranka / Naslov ponudbe'
+b'DocType: Supplier Scorecard Period',b'Supplier Scorecard Setup',b'Nastavitev kazal\xc4\x8devega kazalnika'
+b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133',b'Assessment Plan Name',b'Ime na\xc4\x8drta ocenjevanja'
+b'DocType: Work Order Operation',b'Work Order Operation',b'Delovni nalog'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +233',b'Warning: Invalid SSL certificate on attachment {0}',b'Opozorilo: Neveljavno potrdilo SSL za pritrditev {0}'
+b'apps/erpnext/erpnext/utilities/activation.py +64',"b'Leads help you get business, add all your contacts and more as your leads'","b'Interesenti vam pomaga dobiti posel, dodamo vse svoje stike in ve\xc4\x8d kot va\xc5\xa1e vodi'"
+b'DocType: Work Order Operation',b'Actual Operation Time',b'Dejanska Operacija \xc4\x8das'
+b'DocType: Authorization Rule',b'Applicable To (User)',b'Ki se uporabljajo za (Uporabnik)'
+b'DocType: Purchase Taxes and Charges',b'Deduct',b'Odbitka'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238',b'Job Description',b'Opis dela'
+b'DocType: Student Applicant',b'Applied',b'Applied'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874',b'Re-open',b'Re-open'
+b'DocType: Sales Invoice Item',b'Qty as per Stock UOM',b'Kol. kot na UOM'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59',b'Guardian2 Name',b'Ime skrbnika2'
+b'DocType: Purchase Invoice',b'02-Post Sale Discount',b'Popust za prodajo po po\xc5\xa1ti'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +132',"b'Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series'","b'Posebni znaki razen ""-"" ""."", ""#"", in ""/"" niso dovoljeni v poimenovanju zaporedja'"
+b'DocType: Campaign',"b'Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.'","b'Spremljajte prodajnih akcij. Spremljajte Interesenti, citatov, Sales Order itd iz akcije, da bi ocenili donosnost nalo\xc5\xbebe.'"
+,b'SO Qty',b'SO Kol'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +91',b'The field To Shareholder cannot be blank',b'Polje Delni\xc4\x8darju ne more biti prazno'
+b'DocType: Guardian',b'Work Address',b'Delovni naslov'
+b'DocType: Appraisal',b'Calculate Total Score',b'Izra\xc4\x8dunaj skupni rezultat'
+b'DocType: Health Insurance',b'Health Insurance',b'Zdravstveno zavarovanje'
+b'DocType: Asset Repair',b'Manufacturing Manager',b'Proizvodnja Manager'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191',b'Serial No {0} is under warranty upto {1}',b'Serijska \xc5\xa1t {0} je pod garancijo stanuje {1}'
+b'DocType: Plant Analysis Criteria',b'Minimum Permissible Value',b'Najmanj\xc5\xa1a dovoljena vrednost'
+b'apps/erpnext/erpnext/education/doctype/guardian/guardian.py +41',b'User {0} already exists',b'Uporabnik {0} \xc5\xbee obstaja'
+b'apps/erpnext/erpnext/hooks.py +109',b'Shipments',b'Po\xc5\xa1iljke'
+b'DocType: Payment Entry',b'Total Allocated Amount (Company Currency)',b'Skupaj Dodeljena Znesek (dru\xc5\xbeba Valuta)'
+b'DocType: Purchase Order Item',b'To be delivered to customer',b'Ki jih je treba dostaviti kupcu'
+b'DocType: BOM',b'Scrap Material Cost',b'Stro\xc5\xa1ki odpadnega materiala'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227',b'Serial No {0} does not belong to any Warehouse',b'Serijska \xc5\xa1t {0} ne pripada nobeni Warehouse'
+b'DocType: Grant Application',b'Email Notification Sent',b'Poslano obvestilo o e-po\xc5\xa1ti'
+b'DocType: Purchase Invoice',b'In Words (Company Currency)',b'V besedi (dru\xc5\xbeba Valuta)'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1018',"b'Item Code, warehouse, quantity are required on row'","b'Koda postavke, skladi\xc5\xa1\xc4\x8de, koli\xc4\x8dina sta potrebna v vrstici'"
+b'DocType: Pricing Rule',b'Supplier',b'Dobavitelj'
+b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41',b'Show Payment Details',b'Prika\xc5\xbei podatke o pla\xc4\x8dilu'
+b'DocType: Consultation',b'Consultation Time',b'\xc4\x8cas posvetovanja'
+b'DocType: C-Form',b'Quarter',b'Quarter'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106',b'Miscellaneous Expenses',b'Razni stro\xc5\xa1ki'
+b'DocType: Global Defaults',b'Default Company',b'Privzeto Podjetje'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +227',b'Expense or Difference account is mandatory for Item {0} as it impacts overall stock value',b'Odhodek ali Razlika ra\xc4\x8dun je obvezna za postavko {0} saj to vpliva na skupna vrednost zalog'
+b'DocType: Payment Request',b'PR',b'PR'
+b'DocType: Cheque Print Template',b'Bank Name',b'Ime Banke'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +30',b'-Above',b'-Nad'
+b'DocType: Employee Loan',b'Employee Loan Account',b'Zaposlenih Loan ra\xc4\x8dun'
+b'DocType: Leave Application',b'Total Leave Days',b'Skupaj dni dopusta'
+b'DocType: Email Digest',b'Note: Email will not be sent to disabled users',b'Opomba: E-mail ne bo poslano uporabnike invalide'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14',b'Number of Interaction',b'\xc5\xa0tevilo interakcij'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14',b'Number of Interaction',b'\xc5\xa0tevilo interakcij'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +105',b'Item Variant Settings',b'Nastavitve razli\xc4\x8dice postavke'
+b'apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +37',b'Select Company...',b'Izberite Company ...'
+b'DocType: Leave Control Panel',b'Leave blank if considered for all departments',"b'Pustite prazno, \xc4\x8de velja za vse oddelke'"
+b'apps/erpnext/erpnext/config/hr.py +228',"b'Types of employment (permanent, contract, intern etc.).'","b'Vrste zaposlitve (trajna, pogodbeni, intern itd).'"
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434',b'{0} is mandatory for Item {1}',b'{0} je obvezen za postavko {1}'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +136',"b'Item {0}: {1} qty produced, '","b'Postavka {0}: {1} proizvedena koli\xc4\x8dina,'"
+b'DocType: Payroll Entry',b'Fortnightly',b'vsakih \xc5\xa1tirinajst dni'
+b'DocType: Currency Exchange',b'From Currency',b'Iz valute'
+b'DocType: Vital Signs',b'Weight (In Kilogram)',b'Te\xc5\xbea (v kilogramih)'
+b'DocType: Chapter',b'chapters/chapter_name\nleave blank automatically set after saving chapter.',b'poglavja / poglavje_name pustite samodejno nastaviti prazno po shranjevanju poglavja.'
+b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +202',b'Please set GST Accounts in GST Settings',b'Nastavite GST ra\xc4\x8dune v nastavitvah GST'
+b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +31',b'Type of Business',b'Vrsta podjetja'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +171',"b'Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row'","b'Prosimo, izberite Dodeljeni znesek, fakture Vrsta in \xc5\xa1tevilka ra\xc4\x8duna v atleast eno vrstico'"
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128',b'Cost of New Purchase',b'Stro\xc5\xa1ki New Nakup'
+b'apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +35',b'All tasks for the detected diseases were imported',b'Uva\xc5\xbeale so se vse naloge za odkrite bolezni'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97',b'Sales Order required for Item {0}',b'Sales Order potreben za postavko {0}'
+b'DocType: Grant Application',b'Grant Description',b'Grant Opis'
+b'DocType: Purchase Invoice Item',b'Rate (Company Currency)',b'Oceni (dru\xc5\xbeba Valuta)'
+b'DocType: Student Guardian',b'Others',b'Drugi'
+b'DocType: Payment Entry',b'Unallocated Amount',b'nerazporejena Znesek'
+b'apps/erpnext/erpnext/templates/includes/product_page.js +91',b'Cannot find a matching Item. Please select some other value for {0}.',"b'Ne morete najti ujemanja artikel. Prosimo, izberite kak\xc5\xa1no drugo vrednost za {0}.'"
+b'DocType: POS Profile',b'Taxes and Charges',b'Davki in dajatve'
+b'DocType: Item',"b'A Product or a Service that is bought, sold or kept in stock.'","b'Izdelek ali storitev, ki je kupil, prodal ali jih hranijo na zalogi.'"
+b'apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44',b'No more updates',b'Ni\xc4\x8d ve\xc4\x8d posodobitve'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171',"b""Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row""",b'Ne morete izbrati vrsto naboja kot &quot;On prej\xc5\xa1nje vrstice Znesek&quot; ali &quot;Na prej\xc5\xa1nje vrstice Total&quot; za prvi vrsti'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6',b'This covers all scorecards tied to this Setup',"b'To zajema vse kazalnike, povezane s tem Setup'"
+b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29',b'Child Item should not be a Product Bundle. Please remove item `{0}` and save',b'Otrok to\xc4\x8dka ne bi smela biti izdelka Bundle. Odstranite element &#39;{0}&#39; in shranite'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12',b'Banking',b'Ban\xc4\x8dni\xc5\xa1tvo'
+b'apps/erpnext/erpnext/utilities/activation.py +108',b'Add Timesheets',b'Dodaj \xc4\x8dasovnice'
+b'DocType: Vehicle Service',b'Service Item',b'Service Element'
+b'DocType: Bank Guarantee',b'Bank Guarantee',b'Ban\xc4\x8dna garancija'
+b'DocType: Bank Guarantee',b'Bank Guarantee',b'Ban\xc4\x8dna garancija'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39',"b""Please click on 'Generate Schedule' to get schedule""","b'Prosimo, kliknite na &quot;ustvarjajo Seznamu&quot;, da bi dobili razpored'"
+b'DocType: Bin',b'Ordered Quantity',b'Naro\xc4\x8deno Koli\xc4\x8dina'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +118',"b'e.g. ""Build tools for builders""'",b'npr &quot;Build orodja za gradbenike&quot;'
+b'DocType: Grading Scale',b'Grading Scale Intervals',b'Ocenjevalna lestvica intervali'
+b'apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39',b'Profit for the year',b'Dobi\xc4\x8dek za leto'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125',b'{0} {1}: Accounting Entry for {2} can only be made in currency: {3}',b'{0} {1}: ra\xc4\x8dunovodski zapis za {2} se lahko zapi\xc5\xa1e le v valuti: {3}'
+b'DocType: Fee Schedule',b'In Process',b'V postopku'
+b'DocType: Authorization Rule',b'Itemwise Discount',b'Itemwise Popust'
+b'apps/erpnext/erpnext/config/accounts.py +75',b'Tree of financial accounts.',b'Drevo finan\xc4\x8dnih ra\xc4\x8dunov.'
+b'DocType: Cash Flow Mapping',b'Cash Flow Mapping',b'Kartiranje denarnih tokov'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364',b'{0} against Sales Order {1}',b'{0} za Naro\xc4\x8dilnico {1}'
+b'DocType: Account',b'Fixed Asset',b'Osnovno sredstvo'
+b'apps/erpnext/erpnext/config/stock.py +324',b'Serialized Inventory',b'Zaporednimi Inventory'
+b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74',b'Email not found in default contact',b'V privzetem stiku ni mogo\xc4\x8de najti e-po\xc5\xa1te'
+b'DocType: Employee Loan',b'Account Info',b'Informacije o ra\xc4\x8dunu'
+b'DocType: Activity Type',b'Default Billing Rate',b'Privzeto Oceni pla\xc4\x8devanja'
+b'DocType: Fees',b'Include Payment',b'Vklju\xc4\x8di pla\xc4\x8dilo'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77',b'{0} Student Groups created.',b'{0} skupine \xc5\xa1tudentov ustvarjene'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77',b'{0} Student Groups created.',b'{0} skupine \xc5\xa1tudentov ustvarjene'
+b'DocType: Sales Invoice',b'Total Billing Amount',b'Skupni znesek pla\xc4\x8devanja'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50',b'Program in the Fee Structure and Student Group {0} are different.',b'Program v strukturi pristojbin in \xc5\xa1tudentski skupini {0} je druga\xc4\x8den.'
+b'DocType: Fee Schedule',b'Receivable Account',b'Terjatev ra\xc4\x8dun'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +618',b'Row #{0}: Asset {1} is already {2}',b'Row # {0}: Asset {1} je \xc5\xbee {2}'
+b'DocType: Quotation Item',b'Stock Balance',b'Stock Balance'
+b'apps/erpnext/erpnext/config/selling.py +321',b'Sales Order to Payment',b'Sales Order do pla\xc4\x8dila'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123',b'CEO',b'direktor'
+b'DocType: Purchase Invoice',b'With Payment of Tax',b'S pla\xc4\x8dilom davka'
+b'DocType: Expense Claim Detail',b'Expense Claim Detail',b'Expense Zahtevek Detail'
+b'DocType: Purchase Invoice',b'TRIPLICATE FOR SUPPLIER',b'Trojnih dobavitelja'
+b'DocType: Land Unit',b'Is Container',b'Je kontejner'
+b'DocType: Crop Cycle',b'This will be day 1 of the crop cycle',b'To bo dan 1 ciklusa polj\xc5\xa1\xc4\x8din'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +871',b'Please select correct account',"b'Prosimo, izberite ustrezen ra\xc4\x8dun'"
+b'DocType: Purchase Invoice Item',b'Weight UOM',b'Te\xc5\xbea UOM'
+b'apps/erpnext/erpnext/config/accounts.py +466',b'List of available Shareholders with folio numbers',b'Seznam razpolo\xc5\xbeljivih delni\xc4\x8darjev s \xc5\xa1tevilkami folije'
+b'DocType: Salary Structure Employee',b'Salary Structure Employee',b'Struktura Pla\xc4\x8d zaposlenih'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45',b'Show Variant Attributes',b'Prika\xc5\xbei lastnosti razli\xc4\x8dic'
+b'DocType: Student',b'Blood Group',b'Blood Group'
+b'DocType: Course',b'Course Name',b'Ime predmeta'
+b'DocType: Employee Leave Approver',"b""Users who can approve a specific employee's leave applications""","b'Uporabniki, ki lahko potrdijo zahtevke zapustiti dolo\xc4\x8denega zaposlenega'"
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52',b'Office Equipments',b'Pisarni\xc5\xa1ka oprema'
+b'DocType: Purchase Invoice Item',b'Qty',b'Kol.'
+b'DocType: Fiscal Year',b'Companies',b'Podjetja'
+b'DocType: Supplier Scorecard',b'Scoring Setup',b'Nastavitev to\xc4\x8dkovanja'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24',b'Electronics',b'Electronics'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +326',b'Debit ({0})',b'Debet ({0})'
+b'DocType: Stock Settings',b'Raise Material Request when stock reaches re-order level',b'Dvignite Material Zahtevaj ko stock dose\xc5\xbee stopnjo ponovnega naro\xc4\x8dila'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98',b'Full-time',b'Polni delovni \xc4\x8das'
+b'DocType: Payroll Entry',b'Employees',b'zaposleni'
+b'DocType: Employee',b'Contact Details',b'Kontaktni podatki'
+b'DocType: C-Form',b'Received Date',b'Prejela Datum'
+b'DocType: Delivery Note',"b'If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.'","b'\xc4\x8ce ste ustvarili standardno predlogo v prodaji davkov in dajatev predlogo, izberite eno in kliknite na gumb spodaj.'"
+b'DocType: BOM Scrap Item',b'Basic Amount (Company Currency)',b'Osnovni znesek (dru\xc5\xbeba Valuta)'
+b'DocType: Student',b'Guardians',b'skrbniki'
+b'apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html +13',b'Payment Confirmation',b'Potrdilo pla\xc4\x8dila'
+b'DocType: Shopping Cart Settings',b'Prices will not be shown if Price List is not set',"b'Cene se ne bodo pokazale, \xc4\x8de Cenik ni nastavljen'"
+b'DocType: Stock Entry',b'Total Incoming Value',b'Skupaj Dohodni Vrednost'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362',b'Debit To is required',b'Bremenitev je potrebno'
+b'apps/erpnext/erpnext/utilities/activation.py +109',"b'Timesheets help keep track of time, cost and billing for activites done by your team'","b'Timesheets pomaga slediti \xc4\x8dasa, stro\xc5\xa1kov in zara\xc4\x8dunavanje za aktivnostmi s svojo ekipo, podpisan'"
+b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39',b'Purchase Price List',b'Nakup Cenik'
+b'apps/erpnext/erpnext/config/buying.py +155',b'Templates of supplier scorecard variables.',b'Predloge spremenljivk rezultatov dobaviteljev.'
+b'DocType: Job Offer Term',b'Offer Term',b'Ponudba Term'
+b'DocType: Asset',b'Quality Manager',b'Quality Manager'
+b'DocType: Job Applicant',b'Job Opening',b'Job Otvoritev'
+b'DocType: Payment Reconciliation',b'Payment Reconciliation',b'Uskladitev pla\xc4\x8dil'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153',"b""Please select Incharge Person's name""","b'Prosimo, izberite ime zadol\xc5\xbeen osebe'"
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51',b'Technology',b'Tehnologija'
+b'DocType: Hub Settings',b'Unregister from Hub',b'Odjavite se iz Hub'
+b'apps/erpnext/erpnext/public/js/utils.js +108',b'Total Unpaid: {0}',b'Skupaj nepla\xc4\x8dano: {0}'
+b'DocType: BOM Website Operation',b'BOM Website Operation',b'BOM Spletna stran Operacija'
+b'DocType: Supplier Scorecard',b'Supplier Score',b'Ocen dobavitelja'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +213',b'Total Invoiced Amt',b'Skupaj Fakturna Amt'
+b'DocType: Supplier',b'Warn RFQs',b'Opozori RFQs'
+b'DocType: BOM',b'Conversion Rate',b'Stopnja konverzije'
+b'apps/erpnext/erpnext/templates/pages/product_search.html +3',b'Product Search',b'Iskanje'
+b'DocType: Assessment Plan',b'To Time',b'Time'
+b'DocType: Authorization Rule',b'Approving Role (above authorized value)',b'Odobritvi vloge (nad poobla\xc5\xa1\xc4\x8deni vrednosti)'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118',b'Credit To account must be a Payable account',b'Credit Za ra\xc4\x8dunu mora biti pla\xc4\x8dljivo ra\xc4\x8dun'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43',b'Please select Student Admission which is mandatory for the paid student applicant',"b'Prosimo, izberite \xc5\xa0tudentski Pristop, ki je obvezen za \xc5\xa1tudenta, ki pla\xc4\x8da \xc5\xa1tudent'"
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +355',b'BOM recursion: {0} cannot be parent or child of {2}',b'BOM rekurzija: {0} ne more biti star\xc5\xa1 ali otrok {2}'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +21',b'Please select a Price List to publish pricing',b'Izberite cenik za objavo cen'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38',b'Budget List',b'Prora\xc4\x8dunski seznam'
+b'DocType: Work Order Operation',b'Completed Qty',b'Kon\xc4\x8dano \xc5\xa1tevilo'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148',"b'For {0}, only debit accounts can be linked against another credit entry'","b'Za {0}, lahko le debetne ra\xc4\x8dune povezati proti drugemu knji\xc5\xbeenje'"
+b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27',b'Price List {0} is disabled',b'Seznam Cena {0} je onemogo\xc4\x8dena'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127',b'Row {0}: Completed Qty cannot be more than {1} for operation {2}',b'Vrstica {0}: Zaklju\xc4\x8den Koli\xc4\x8dina ne sme biti ve\xc4\x8dja od {1} za delovanje {2}'
+b'DocType: Manufacturing Settings',b'Allow Overtime',b'Dovoli Nadurno delo'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148',"b'Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry'","b'Zaporednimi Postavka {0} ni mogo\xc4\x8de posodobiti s pomo\xc4\x8djo zaloge sprave, uporabite zaloge Entry'"
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148',"b'Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry'","b'Zaporednimi Postavka {0} ni mogo\xc4\x8de posodobiti s pomo\xc4\x8djo zaloge sprave, uporabite zaloge Entry'"
+b'DocType: Training Event Employee',b'Training Event Employee',b'Dogodek usposabljanje zaposlenih'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1031',b'Maximum Samples - {0} can be retained for Batch {1} and Item {2}.',b'Najve\xc4\x8dje vzorce - {0} lahko hranite za paket {1} in element {2}.'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +7',b'Add Time Slots',b'Dodaj \xc4\x8dasovne re\xc5\xbee'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201',b'{0} Serial Numbers required for Item {1}. You have provided {2}.',b'{0} serijska(e) \xc5\xa1tevilka(e) zahtevana(e) za postavko {1}. Navedli ste {2}.'
+b'DocType: Stock Reconciliation Item',b'Current Valuation Rate',b'Trenutni te\xc4\x8daj Vrednotenje'
+b'DocType: Training Event',b'Advance',b'Napredovanje'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'for making recurring again.',b'za ponovni ponovitev.'
+b'apps/erpnext/erpnext/config/erpnext_integrations.py +13',b'GoCardless payment gateway settings',b'GoCardless nastavitve pla\xc4\x8dilnih prehodov'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122',b'Exchange Gain/Loss',b'Exchange dobi\xc4\x8dek / izguba'
+b'DocType: Opportunity',b'Lost Reason',b'Lost Razlog'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +265',b'Row #{0}: Account {1} does not belong to company {2}',b'Vrstica # {0}: Ra\xc4\x8dun {1} ne pripada podjetju {2}'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +30',b'Unable to find DocType {0}',b'Datoteke DocType {0} ni mogo\xc4\x8de najti'
+b'apps/erpnext/erpnext/public/js/templates/address_list.html +22',b'New Address',b'New Naslov'
+b'DocType: Quality Inspection',b'Sample Size',b'Velikost vzorca'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47',b'Please enter Receipt Document',b'Vnesite Prejem dokumenta'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +369',b'All items have already been invoiced',b'Vsi predmeti so bili \xc5\xbee obra\xc4\x8dunano'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49',"b""Please specify a valid 'From Case No.'""","b'Prosimo, navedite veljaven &quot;Od zadevi \xc5\xa1t &#39;'"
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24',b'Further cost centers can be made under Groups but entries can be made against non-Groups',"b'Nadaljnje stro\xc5\xa1kovna mesta se lahko izvede v skupinah, vendar vnosi lahko zoper niso skupin'"
+b'apps/erpnext/erpnext/config/setup.py +66',b'Users and Permissions',b'Uporabniki in dovoljenja'
+b'DocType: Vehicle Log',b'VLOG.',b'Vlog.'
+b'DocType: Branch',b'Branch',b'Branch'
+b'DocType: Soil Analysis',b'Ca/(K+Ca+Mg)',b'Ca / (K + Ca + Mg)'
+b'DocType: Delivery Trip',b'Fulfillment User',b'Uporabnik izpolnjevanja'
+b'apps/erpnext/erpnext/config/setup.py +61',b'Printing and Branding',b'Tiskanje in Branding'
+b'DocType: Company',b'Total Monthly Sales',b'Skupna mese\xc4\x8dna prodaja'
+b'DocType: Agriculture Analysis Criteria',b'Weather',b'Vreme'
+b'DocType: Bin',b'Actual Quantity',b'Dejanska koli\xc4\x8dina'
+b'DocType: Shipping Rule',b'example: Next Day Shipping',b'Primer: Next Day Shipping'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187',b'Serial No {0} not found',b'Serijska \xc5\xa1t {0} ni bilo mogo\xc4\x8de najti'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +291',b'Subscription has been {0}',b'Naro\xc4\x8dnina je bila {0}'
+b'DocType: Fee Schedule Program',b'Fee Schedule Program',b'Program urnika'
+b'DocType: Fee Schedule Program',b'Student Batch',b'\xc5\xa1tudent serije'
+b'apps/erpnext/erpnext/utilities/activation.py +119',b'Make Student',b'Naredite \xc5\xa0tudent'
+b'DocType: Supplier Scorecard Scoring Standing',b'Min Grade',b'Min razred'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +218',b'You have been invited to collaborate on the project: {0}',b'Ti so bili povabljeni k sodelovanju na projektu: {0}'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +157',b'Physician not available on {0}',b'Zdravnik ni na voljo na {0}'
+b'DocType: Leave Block List Date',b'Block Date',b'Block Datum'
+b'DocType: Crop',b'Crop',b'Pridelek'
+b'DocType: Purchase Receipt',b'Supplier Delivery Note',b'Opomba: dobavitelj dostava'
+b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70',b'Apply Now',b'Prijavi se zdaj'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25',b'Actual Qty {0} / Waiting Qty {1}',b'Dejanska Kol {0} / \xc4\x8dakajo\xc4\x8di Kol {1}'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25',b'Actual Qty {0} / Waiting Qty {1}',b'Dejanska Kol {0} / \xc4\x8dakajo\xc4\x8di Kol {1}'
+b'DocType: Purchase Invoice',b'E-commerce GSTIN',b'E-trgovina GSTIN'
+b'DocType: Sales Order',b'Not Delivered',b'Ne Delivered'
+,b'Bank Clearance Summary',b'Banka Potrditev Povzetek'
+b'apps/erpnext/erpnext/config/setup.py +106',"b'Create and manage daily, weekly and monthly email digests.'","b'Ustvarjanje in upravljanje dnevne, tedenske in mese\xc4\x8dne email prebavlja.'"
+b'DocType: Appraisal Goal',b'Appraisal Goal',b'Cenitev cilj'
+b'DocType: Stock Reconciliation Item',b'Current Amount',b'Trenutni znesek'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58',b'Buildings',b'zgradbe'
+b'DocType: Fee Schedule',b'Fee Structure',b'Fee Struktura'
+b'DocType: Timesheet Detail',b'Costing Amount',b'Stanejo Znesek'
+b'DocType: Student Admission Program',b'Application Fee',b'Fee uporaba'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +52',b'Submit Salary Slip',b'Predlo\xc5\xbei pla\xc4\x8dilni list'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +137',b'Maxiumm discount for Item {0} is {1}%',b'Maxiumm popust za Element {0} je {1}%'
+b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16',b'Import in Bulk',b'Uvoz v razsutem stanju'
+b'DocType: Sales Partner',b'Address & Contacts',b'Naslov &amp; Kontakti'
+b'DocType: SMS Log',b'Sender Name',b'Sender Name'
+b'DocType: Agriculture Analysis Criteria',b'Agriculture Analysis Criteria',b'Kriteriji za analizo kmetijstva'
+b'DocType: POS Profile',b'[Select]',b'[Izberite]'
+b'DocType: Vital Signs',b'Blood Pressure (diastolic)',b'Krvni tlak (diastoli\xc4\x8dni)'
+b'DocType: SMS Log',b'Sent To',b'Poslano'
+b'DocType: Agriculture Task',b'Holiday Management',b'Upravljanje praznikov'
+b'DocType: Payment Request',b'Make Sales Invoice',b'Naredi ra\xc4\x8dun'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61',b'Softwares',b'Programska oprema'
+b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +53',b'Next Contact Date cannot be in the past',b'Naslednja Stik datum ne more biti v preteklosti'
+b'DocType: Company',b'For Reference Only.',b'Samo za referenco.'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +112',b'Physician {0} not available on {1}',b'Zdravnik {0} ni na voljo {1}'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2581',b'Select Batch No',b'Izberite Serija \xc5\xa1t'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +61',b'Invalid {0}: {1}',b'Neveljavna {0}: {1}'
+,b'GSTR-1',b'GSTR-1'
+b'DocType: Purchase Invoice',b'PINV-RET-',b'PINV-RET-'
+b'DocType: Fee Validity',b'Reference Inv',b'Reference Inv'
+b'DocType: Sales Invoice Advance',b'Advance Amount',b'Advance Znesek'
+b'DocType: Manufacturing Settings',b'Capacity Planning',b'Na\xc4\x8drtovanje zmogljivosti'
+b'DocType: Supplier Quotation',b'Rounding Adjustment (Company Currency',b'Prilagajanje zaokro\xc5\xbeevanja (Valuta podjetja'
+b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43',"b""'From Date' is required""","b'Zahtevano je ""Od datuma""'"
+b'DocType: Journal Entry',b'Reference Number',b'Referen\xc4\x8dna \xc5\xa1tevilka'
+b'DocType: Employee',b'Employment Details',b'Podatki o zaposlitvi'
+b'DocType: Employee',b'New Workplace',b'Novo delovno mesto'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17',b'Set as Closed',b'Nastavi kot Zaprto'
+b'apps/erpnext/erpnext/stock/get_item_details.py +127',b'No Item with Barcode {0}',b'Ne Postavka s \xc4\x8drtno kodo {0}'
+b'DocType: Normal Test Items',b'Require Result Value',b'Zahtevajte vrednost rezultata'
+b'DocType: Item',b'Show a slideshow at the top of the page',b'Prika\xc5\xbei diaprojekcijo na vrhu strani'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +532',b'Boms',b'Boms'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +162',b'Stores',b'Trgovine'
+b'DocType: Project Type',b'Projects Manager',b'Projekti Manager'
+b'DocType: Serial No',b'Delivery Time',b'\xc4\x8cas dostave'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +33',b'Ageing Based On',"b'Staranje, ki temelji na'"
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +61',b'Appointment cancelled',b'Imenovanje je preklicano'
+b'DocType: Item',b'End of Life',b'End of Life'
+b'apps/erpnext/erpnext/demo/setup/setup_data.py +331',b'Travel',b'Potovanja'
+b'DocType: Student Report Generation Tool',b'Include All Assessment Group',b'Vklju\xc4\x8di vse ocenjevalne skupine'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183',b'No active or default Salary Structure found for employee {0} for the given dates',"b'Ni aktivnega ali privzeti pla\xc4\x8d struktura, ugotovljena za zaposlenega {0} za datumoma'"
+b'DocType: Leave Block List',b'Allow Users',b'Dovoli uporabnike'
+b'DocType: Purchase Order',b'Customer Mobile No',b'Stranka Mobile No'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1',b'Recurring',b'Ponavljajo\xc4\x8di'
+b'DocType: Cash Flow Mapping Template Details',b'Cash Flow Mapping Template Details',b'Podrobnosti o predlogi za kartiranje denarnega toka'
+b'DocType: Cost Center',b'Track separate Income and Expense for product verticals or divisions.',b'Sledi lo\xc4\x8deno prihodki in odhodki za vertikal proizvodov ali delitve.'
+b'DocType: Rename Tool',b'Rename Tool',b'Preimenovanje orodje'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72',b'Update Cost',b'Posodobitev Stro\xc5\xa1ki'
+b'DocType: Item Reorder',b'Item Reorder',b'Postavka Preureditev'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463',b'Show Salary Slip',b'Prika\xc5\xbei Pla\xc4\x8da listek'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +849',b'Transfer Material',b'Prenos Material'
+b'DocType: Fees',b'Send Payment Request',b'Po\xc5\xa1iljanje zahtevka za pla\xc4\x8dilo'
+b'DocType: BOM',"b'Specify the operations, operating cost and give a unique Operation no to your operations.'","b'Dolo\xc4\x8dite operacij, obratovalne stro\xc5\xa1ke in daje edinstveno Operacija ni na va\xc5\xa1e poslovanje.'"
+b'DocType: Water Analysis',b'Origin',b'Izvor'
+b'apps/erpnext/erpnext/controllers/status_updater.py +204',b'This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?',"b'Ta dokument je nad mejo, ki jo {0} {1} za postavko {4}. Dela\xc5\xa1 drugo {3} zoper isto {2}?'"
+b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1154',b'Please set recurring after saving',"b'Prosim, nastavite ponavljajo\xc4\x8dih se po shranjevanju'"
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +769',b'Select change amount account',b'znesek ra\xc4\x8duna Izberite sprememba'
+b'DocType: Purchase Invoice',b'Price List Currency',b'Cenik Valuta'
+b'DocType: Naming Series',b'User must always select',b'Uporabnik mora vedno izbrati'
+b'DocType: Stock Settings',b'Allow Negative Stock',b'Dovoli Negative Stock'
+b'DocType: Installation Note',b'Installation Note',b'Namestitev Opomba'
+b'DocType: Soil Texture',b'Clay',b'Glina'
+b'DocType: Topic',b'Topic',b'tema'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +45',b'Cash Flow from Financing',b'Denarni tok iz financiranja'
+b'DocType: Budget Account',b'Budget Account',b'prora\xc4\x8dun ra\xc4\x8duna'
+b'DocType: Quality Inspection',b'Verified By',b'Verified by'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +78',"b""Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.""","b'Ne more spremeniti privzeto valuto dru\xc5\xbebe, saj so obstoje\xc4\x8di posli. Transakcije se treba odpovedati, da spremenite privzeto valuto.'"
+b'DocType: Cash Flow Mapping',b'Is Income Tax Liability',b'Je obveznost dohodnine'
+b'DocType: Grading Scale Interval',b'Grade Description',b'razred Opis'
+b'DocType: Stock Entry',b'Purchase Receipt No',b'Potrdilo o nakupu Ne'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30',b'Earnest Money',b'Kapara'
+b'DocType: Sales Invoice',b' Shipping Bill Number',b'\xc5\xa0tevilka naro\xc4\x8dila'
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34',b'Traceability',b'sledljivost'
+b'DocType: Asset Maintenance Log',b'Actions performed',b'Izvedeni ukrepi'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51',b'Customer &gt; Customer Group &gt; Territory',b'Stranka&gt; Skupina strank&gt; Teritorija'
+b'DocType: Cash Flow Mapper',b'Section Leader',b'Oddelek Leader'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137',b'Source of Funds (Liabilities)',b'Vir sredstev (obveznosti)'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +431',b'Quantity in row {0} ({1}) must be same as manufactured quantity {2}',b'Koli\xc4\x8dina v vrstici {0} ({1}) mora biti enaka kot je bila proizvedena koli\xc4\x8dina {2}'
+b'DocType: Supplier Scorecard Scoring Standing',b'Employee',b'Zaposleni'
+b'DocType: Asset Repair',b'Failure Date',b'Datum odpovedi'
+b'DocType: Sample Collection',b'Collected Time',b'Zbrani \xc4\x8das'
+b'DocType: Company',b'Sales Monthly History',b'Mese\xc4\x8dna zgodovina prodaje'
+b'DocType: Asset Maintenance Task',b'Next Due Date',b'Naslednji datum roka'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214',b'Select Batch',b'Izberite Serija'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244',b'{0} {1} is fully billed',b'{0} {1} je v celoti zara\xc4\x8dunano'
+b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +31',b'Vital Signs',b'\xc5\xbdivljenjski znaki'
+b'DocType: Training Event',b'End Time',b'Kon\xc4\x8dni \xc4\x8das'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63',b'Active Salary Structure {0} found for employee {1} for the given dates',b'Aktivne Struktura Pla\xc4\x8da {0} ugotovljeno za delavca {1} za dane termin'
+b'DocType: Payment Entry',b'Payment Deductions or Loss',b'Pla\xc4\x8dilni Odbitki ali izguba'
+b'DocType: Soil Analysis',b'Soil Analysis Criterias',b'Kriteriji za analizo tal'
+b'apps/erpnext/erpnext/config/setup.py +42',b'Standard contract terms for Sales or Purchase.',b'Standardni pogodbeni pogoji za prodajo ali nakup.'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +112',b'Group by Voucher',b'Skupina kupon'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +233',b'Are you sure you want to cancel this appointment?',"b'Ali ste prepri\xc4\x8dani, da \xc5\xbeelite preklicati ta sestanek?'"
+b'DocType: Hotel Room Pricing Package',b'Hotel Room Pricing Package',b'Paket hotelskih cen'
+b'apps/erpnext/erpnext/config/crm.py +6',b'Sales Pipeline',b'prodaja Pipeline'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201',b'Please set default account in Salary Component {0}',"b'Prosim, nastavite privzetega ra\xc4\x8duna v pla\xc4\x8d komponento {0}'"
+b'apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7',b'Required On',b'Zahtevani Na'
+b'DocType: Rename Tool',b'File to Rename',b'Datoteka za preimenovanje'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200',b'Please select BOM for Item in Row {0}',b'Izberite BOM za postavko v vrstici {0}'
+b'apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28',b'Account {0} does not match with Company {1} in Mode of Account: {2}',b'Ra\xc4\x8dun {0} ne ujema z dru\xc5\xbebo {1} v na\xc4\x8dinu ra\xc4\x8dun: {2}'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +464',b'Specified BOM {0} does not exist for Item {1}',b'Dolo\xc4\x8deno BOM {0} ne obstaja za postavko {1}'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +301',b'Course: ',b'Te\xc4\x8daj:'
+b'DocType: Soil Texture',b'Sandy Loam',b'Sandy Loam'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232',b'Maintenance Schedule {0} must be cancelled before cancelling this Sales Order',b'Vzdr\xc5\xbeevanje Urnik {0} je treba odpovedati pred preklicem te Sales Order'
+b'DocType: POS Profile',b'Applicable for Users',b'Uporabno za uporabnike'
+b'DocType: Notification Control',b'Expense Claim Approved',b'Expense Zahtevek Odobreno'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231',b'No Work Orders created',b'\xc5\xa0t delovnih nalogov ustvarjenih'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321',b'Salary Slip of employee {0} already created for this period',b'Pla\xc4\x8da Slip delavca {0} \xc5\xbee ustvarili za to obdobje'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155',b'Pharmaceutical',b'Pharmaceutical'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26',b'Cost of Purchased Items',b'Vrednost kupljenih artiklov'
+b'DocType: Selling Settings',b'Sales Order Required',b'Zahtevano je naro\xc4\x8dilo'
+b'DocType: Purchase Invoice',b'Credit To',b'Kredit'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46',b'PieceDate',b'PieceDate'
+b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31',b'Active Leads / Customers',b'Aktivne ponudbe / Stranke'
+b'DocType: Employee Education',b'Post Graduate',b'Post Graduate'
+b'DocType: Maintenance Schedule Detail',b'Maintenance Schedule Detail',b'Vzdr\xc5\xbeevanje Urnik Detail'
+b'DocType: Supplier Scorecard',b'Warn for new Purchase Orders',b'Opozori na nova naro\xc4\x8dila'
+b'DocType: Quality Inspection Reading',b'Reading 9',b'Branje 9'
+b'DocType: Supplier',b'Is Frozen',b'Je zamrznjena'
+b'apps/erpnext/erpnext/stock/utils.py +224',b'Group node warehouse is not allowed to select for transactions',b'Skupina vozli\xc5\xa1\xc4\x8de skladi\xc5\xa1\xc4\x8de ni dovoljeno izbrati za transakcije'
+b'DocType: Buying Settings',b'Buying Settings',b'Nastavitve nabave'
+b'DocType: Stock Entry Detail',b'BOM No. for a Finished Good Item',b'BOM No. za Kon\xc4\x8dni Good postavki'
+b'DocType: Upload Attendance',b'Attendance To Date',b'Udele\xc5\xbeba na teko\xc4\x8dem'
+b'DocType: Request for Quotation Supplier',b'No Quote',b'Brez cenika'
+b'DocType: Warranty Claim',b'Raised By',b'Raised By'
+b'DocType: Payment Gateway Account',b'Payment Account',b'Pla\xc4\x8dilo ra\xc4\x8duna'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +909',b'Please specify Company to proceed',"b'Prosimo, navedite Company nadaljevati'"
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +27',b'Net Change in Accounts Receivable',b'Neto sprememba terjatev do kupcev'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88',b'Compensatory Off',b'Kompenzacijske Off'
+b'DocType: Job Offer',b'Accepted',b'Sprejeto'
+b'DocType: Grant Application',b'Organization',b'organizacija'
+b'DocType: Grant Application',b'Organization',b'organizacija'
+b'DocType: BOM Update Tool',b'BOM Update Tool',b'Orodje za posodobitev BOM'
+b'DocType: SG Creation Tool Course',b'Student Group Name',b'Ime \xc5\xa1tudent Group'
+b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js +17',b'Show exploded view',b'Poka\xc5\xbei eksplodiran pogled'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7',b'Creating Fees',b'Ustvarjanje pristojbin'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +91',b'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.',"b'Prosimo, preverite, ali ste prepri\xc4\x8dani, da \xc5\xbeelite izbrisati vse posle, za te dru\xc5\xbebe. Va\xc5\xa1i mati\xc4\x8dni podatki bodo ostali kot je. Ta ukrep ni mogo\xc4\x8de razveljaviti.'"
+b'apps/erpnext/erpnext/templates/pages/product_search.html +21',b'Search Results',b'Rezultati iskanja'
+b'DocType: Room',b'Room Number',b'\xc5\xa0tevilka sobe'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +107',b'Invalid reference {0} {1}',b'Neveljavna referen\xc4\x8dna {0} {1}'
+b'DocType: Shipping Rule',b'Shipping Rule Label',b'Oznaka dostavnega pravila'
+b'DocType: Journal Entry Account',b'Payroll Entry',b'Vnos pla\xc4\x8de'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +75',b'View Fees Records',b'Oglejte si zapisi o prispevkih'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +35',b'Make Tax Template',b'Naredi dav\xc4\x8dno predlogo'
+b'apps/erpnext/erpnext/public/js/conf.js +28',b'User Forum',b'Uporabni\xc5\xa1ki forum'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +319',b'Raw Materials cannot be blank.',b'Surovine ne more biti prazno.'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +498',"b'Could not update stock, invoice contains drop shipping item.'","b'Ni mogel posodobiti vozni park, faktura vsebuje padec element ladijskega prometa.'"
+b'DocType: Lab Test Sample',b'Lab Test Sample',b'Vzorec laboratorijskega testa'
+b'DocType: Item Variant Settings',b'Allow Rename Attribute Value',b'Dovoli preimenovanje vrednosti atributa'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +491',b'Quick Journal Entry',b'Hitro Journal Entry'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200',b'You can not change rate if BOM mentioned agianst any item',"b'Vi stopnje ni mogo\xc4\x8de spremeniti, \xc4\x8de BOM omenjeno agianst vsako postavko'"
+b'DocType: Restaurant',b'Invoice Series Prefix',b'Predpisi serije ra\xc4\x8dunov'
+b'DocType: Employee',b'Previous Work Experience',b'Prej\xc5\xa1nja Delovne izku\xc5\xa1nje'
+b'DocType: Stock Entry',b'For Quantity',b'Za Koli\xc4\x8dino'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205',b'Please enter Planned Qty for Item {0} at row {1}',b'Vnesite na\xc4\x8drtovanih Koli\xc4\x8dina za postavko {0} v vrstici {1}'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +93',b'Google Maps integration is not enabled',b'Integracija Google Zemljevidov ni omogo\xc4\x8dena'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241',b'{0} {1} is not submitted',b'{0} {1} ni vlo\xc5\xbeen'
+b'DocType: Member',b'Membership Expiry Date',b'Datum prenehanja \xc4\x8dlanstva'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +131',b'{0} must be negative in return document',b'{0} mora biti negativno na povratnem dokumentu'
+,b'Minutes to First Response for Issues',b'Minut do prvega odziva na vpra\xc5\xa1anja'
+b'DocType: Purchase Invoice',b'Terms and Conditions1',b'Pogoji in razmer1'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +109',b'The name of the institute for which you are setting up this system.',"b'Ime zavoda, za katerega vzpostavitev tega sistema.'"
+b'DocType: Accounts Settings',"b'Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.'","b'Vknji\xc5\xbeba zamrzniti do tega datuma, nih\xc4\x8de ne more narediti / spremeniti vnos razen vlogi dolo\xc4\x8deno spodaj.'"
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116',b'Please save the document before generating maintenance schedule',"b'Prosimo, shranite dokument pred ustvarjanjem razpored vzdr\xc5\xbeevanja'"
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30',b'Latest price updated in all BOMs',b'Najnovej\xc5\xa1a cena posodobljena v vseh BOM'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28',b'Project Status',b'Stanje projekta'
+b'DocType: UOM',b'Check this to disallow fractions. (for Nos)',"b'Preverite, da je to prepoveste frakcij. (za \xc5\xa1tevilkami)'"
+b'DocType: Student Admission Program',b'Naming Series (for Student Applicant)',b'Poimenovanje Series (za Student prijavitelja)'
+b'DocType: Delivery Note',b'Transporter Name',b'Transporter Name'
+b'DocType: Authorization Rule',b'Authorized Value',b'Dovoljena vrednost'
+b'DocType: BOM',b'Show Operations',b'prika\xc5\xbei Operations'
+,b'Minutes to First Response for Opportunity',b'Minut do prvega odziva za prilo\xc5\xbenost'
+b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Absent',b'Skupaj Odsoten'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +862',b'Item or Warehouse for row {0} does not match Material Request',b'Postavka ali skladi\xc5\xa1\xc4\x8da za vrstico {0} ne ujema Material dogovoru'
+b'apps/erpnext/erpnext/config/stock.py +191',b'Unit of Measure',b'Merska enota'
+b'DocType: Fiscal Year',b'Year End Date',b'Leto End Date'
+b'DocType: Task Depends On',b'Task Depends On',b'Naloga je odvisna od'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1026',b'Opportunity',b'Prilo\xc5\xbenost'
+b'DocType: Operation',b'Default Workstation',b'Privzeto Workstation'
+b'DocType: Notification Control',b'Expense Claim Approved Message',b'Expense Zahtevek Odobreno Sporo\xc4\x8dilo'
+b'DocType: Payment Entry',b'Deductions or Loss',b'Odbitki ali izguba'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247',b'{0} {1} is closed',b'{0} {1} je zaprt'
+b'DocType: Email Digest',b'How frequently?',b'Kako pogosto?'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +55',b'Total Collected: {0}',b'Skupno zbranih: {0}'
+b'DocType: Purchase Receipt',b'Get Current Stock',b'Pridobite trenutne zaloge'
+b'DocType: Purchase Invoice',b'ineligible',b'neupravi\xc4\x8deno'
+b'apps/erpnext/erpnext/config/manufacturing.py +46',b'Tree of Bill of Materials',b'Drevo Bill of Materials'
+b'DocType: Student',b'Joining Date',b'Vstop Datum'
+,b'Employees working on a holiday',b'Zaposleni na po\xc4\x8ditnice'
+b'DocType: Share Balance',b'Current State',b'Trenutno stanje'
+b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152',b'Mark Present',b'Mark Present'
+b'DocType: Share Transfer',b'From Shareholder',b'Od delni\xc4\x8darja'
+b'DocType: Project',b'% Complete Method',b'% kon\xc4\x8dano'
+b'apps/erpnext/erpnext/healthcare/setup.py +181',b'Drug',b'Zdravilo'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200',b'Maintenance start date can not be before delivery date for Serial No {0}',b'Datum za\xc4\x8detka vzdr\xc5\xbeevanje ne more biti pred datumom dostave za serijsko \xc5\xa1t {0}'
+b'DocType: Work Order',b'Actual End Date',b'Dejanski kon\xc4\x8dni datum'
+b'DocType: Cash Flow Mapping',b'Is Finance Cost Adjustment',b'Je prilagoditev stro\xc5\xa1kov financiranja'
+b'DocType: BOM',b'Operating Cost (Company Currency)',b'Obratovalni stro\xc5\xa1ki (dru\xc5\xbeba Valuta)'
+b'DocType: Purchase Invoice',b'PINV-',b'PINV-'
+b'DocType: Authorization Rule',b'Applicable To (Role)',b'Ki se uporabljajo za (vloga)'
+b'DocType: BOM Update Tool',b'Replace BOM',b'Zamenjajte BOM'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110',b'Code {0} already exist',b'Koda {0} \xc5\xbee obstaja'
+b'DocType: Employee Advance',b'Purpose',b'Namen'
+b'DocType: Company',b'Fixed Asset Depreciation Settings',b'Osnovno sredstvo Nastavitve amortizacije'
+b'DocType: Item',b'Will also apply for variants unless overrridden',b'Bo veljalo tudi za variante razen overrridden'
+b'DocType: Purchase Invoice',b'Advances',b'Predpla\xc4\x8dila'
+b'DocType: Work Order',b'Manufacture against Material Request',b'Izdelava proti Material zahtevo'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +14',b'Assessment Group: ',b'Ocenjevalna skupina:'
+b'DocType: Item Reorder',b'Request for',b'Pro\xc5\xa1nja za'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32',b'Approving User cannot be same as user the rule is Applicable To',"b'Odobritvi Uporabnik ne more biti isto kot uporabnika je pravilo, ki veljajo za'"
+b'DocType: Stock Entry Detail',b'Basic Rate (as per Stock UOM)',b'Osnovni te\xc4\x8daj (kot na borzi UOM)'
+b'DocType: SMS Log',b'No of Requested SMS',b'\xc5\xa0t zapro\xc5\xa1ene SMS'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +246',b'Leave Without Pay does not match with approved Leave Application records',b'Pusti brez pla\xc4\x8dila ne ujema z odobrenimi evidence Leave aplikacij'
+b'DocType: Campaign',b'Campaign-.####',b'Akcija -. ####'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21',b'Next Steps',b'Naslednji koraki'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +796',b'Please supply the specified items at the best possible rates',"b'Prosimo, da dolo\xc4\x8dene elemente na najbolj\xc5\xa1ih mo\xc5\xbenih cenah'"
+b'DocType: Membership',b'USD',b'ameri\xc5\xa1ki dolar'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28',b'Make Invoice',b'Izra\xc4\x8dunajte'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +80',b'Remaining Balance',b'Ostati v ravnote\xc5\xbeju'
+b'DocType: Selling Settings',b'Auto close Opportunity after 15 days',b'Auto blizu Prilo\xc5\xbenost po 15 dneh'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +86',b'Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.',b'Nakupna naro\xc4\x8dila niso dovoljena za {0} zaradi postavke ocene rezultatov {1}.'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +498',b'Barcode {0} is not a valid {1} code',b'\xc4\x8crtna koda {0} ni veljavna {1} koda'
+b'apps/erpnext/erpnext/public/js/financial_statements.js +83',b'End Year',b'Leto zaklju\xc4\x8dka'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23',b'Quot/Lead %',b'Quot / svinec%'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23',b'Quot/Lead %',b'Quot / svinec%'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +124',b'Contract End Date must be greater than Date of Joining',b'Naro\xc4\x8dilo Kon\xc4\x8dni datum mora biti ve\xc4\x8dja od Datum pridru\xc5\xbeitve'
+b'DocType: Driver',b'Driver',b'Voznik'
+b'DocType: Vital Signs',b'Nutrition Values',b'Prehranske vrednosti'
+b'DocType: Lab Test Template',b'Is billable',b'Je zara\xc4\x8dunljiv'
+b'DocType: Delivery Note',b'DN-',b'DN-'
+b'DocType: Sales Partner',b'A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.',"b'Distributer tretja oseba / trgovec / provizije agent / podru\xc5\xbenica / prodajalec, ki prodaja podjetja, izdelke za provizijo.'"
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376',b'{0} against Purchase Order {1}',b'{0} za Naro\xc4\x8dilo {1}'
+b'DocType: Patient',b'Patient Demographics',b'Demografija pacienta'
+b'DocType: Task',b'Actual Start Date (via Time Sheet)',b'Dejanski za\xc4\x8detni datum (preko \xc4\x8cas lista)'
+b'apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15',b'This is an example website auto-generated from ERPNext',b'To je primer spletne strani samodejno ustvari iz ERPNext'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +43',b'Ageing Range 1',b'Staranje Razpon 1'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +212',b'Total advance amount cannot be greater than total claimed amount',b'Skupni znesek vnaprej ne more biti ve\xc4\x8dji od skupnega zahtevanega zneska'
+b'DocType: Purchase Taxes and Charges Template',"b'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.\n\n#### Note\n\nThe 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.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **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.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. 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).\n9. 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.\n10. Add or Deduct: Whether you want to add or deduct the tax.'","b'Standardna dav\xc4\x8dna predlogo, ki se lahko uporablja za vse nakupnih poslov. To predlogo lahko vsebuje seznam dav\xc4\x8dnih glavami in tudi drugih odhodkov glavah, kot so &quot;Shipping&quot;, &quot;zavarovanje&quot;, &quot;Ravnanje&quot; itd #### Opomba dav\xc4\x8dno stopnjo, ki jo dolo\xc4\x8dite tu bo standard dav\xc4\x8dna stopnja za vse ** To\xc4\x8dke * *. \xc4\x8ce obstajajo ** Items **, ki imajo razli\xc4\x8dne stopnje, ki jih je treba dodati v ** Element davku ** miza v ** Element ** mojstra. #### Opis Stolpci 1. Vrsta Izra\xc4\x8dun: - To je lahko na ** Net Total ** (to je vsota osnovnega zneska). - ** Na prej\xc5\xa1nje vrstice Total / Znesek ** (za kumulativnih davkov ali dajatev). \xc4\x8ce izberete to mo\xc5\xbenost, bo davek treba uporabiti kot odstotek prej\xc5\xa1nje vrstice (dav\xc4\x8dne tabele) znesek ali skupaj. - ** Dejanska ** (kot je omenjeno). 2. Ra\xc4\x8dun Head: The knjiga ra\xc4\x8dun, pod katerimi se bodo rezervirana ta davek 3. stro\xc5\xa1kovni center: \xc4\x8ce davek / pristojbina je prihodek (kot ladijski promet) ali odhodek je treba rezervirana proti centru stro\xc5\xa1kov. 4. Opis: Opis davka (bo, da se natisne v faktur / narekovajev). 5. stopnja: Dav\xc4\x8dna stopnja. 6. Znesek: Dav\xc4\x8dna znesek. 7. Skupaj: Kumulativno do te to\xc4\x8dke. 8. Vnesite Row: \xc4\x8ce je na osnovi &quot;Prej\xc5\xa1nji Row Total&quot; lahko izberete \xc5\xa1tevilko vrstice, ki bo sprejet kot osnova za ta izra\xc4\x8dun (privzeta je prej\xc5\xa1nja vrstica). 9. Razmislite davek ali dajatev za: V tem razdelku lahko dolo\xc4\x8dite, \xc4\x8de je davek / pristojbina le za vrednotenje (ni del skupaj) ali samo za skupno (ne dodajajo vrednost za postavko), ali pa oboje. 10. Dodajte ali od\xc5\xa1tejemo: Ali \xc5\xbeelite dodati ali odbiti davek.'"
+b'DocType: Homepage',b'Homepage',b'Doma\xc4\x8da stran'
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +68',b'Select Physician...',b'Izberite zdravnika ...'
+b'DocType: Grant Application',b'Grant Application Details ',b'Podrobnosti o aplikaciji za dodelitev sredstev'
+b'DocType: Purchase Receipt Item',b'Recd Quantity',b'Recd Koli\xc4\x8dina'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +65',b'Fee Records Created - {0}',b'Fee Records Created - {0}'
+b'DocType: Asset Category Account',b'Asset Category Account',b'Sredstvo Kategorija ra\xc4\x8dun'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +913',b'Row #{0} (Payment Table): Amount must be positive',b'Vrstica # {0} (Tabela pla\xc4\x8dil): znesek mora biti pozitiven'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44',b'CompteNum',b'CompteNum'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +137',b'Cannot produce more Item {0} than Sales Order quantity {1}',b'Ne more proizvajati ve\xc4\x8d item {0} od prodaje kol {1}'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +391',b'Select Attribute Values',b'Izberite vrednosti atributa'
+b'DocType: Purchase Invoice',b'Reason For Issuing document',b'Razlog za izdajo dokumenta'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539',b'Stock Entry {0} is not submitted',b'Stock Za\xc4\x8detek {0} ni predlo\xc5\xbeila'
+b'DocType: Payment Reconciliation',b'Bank / Cash Account',b'Banka / Gotovinski ra\xc4\x8dun'
+b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +47',b'Next Contact By cannot be same as the Lead Email Address',b'Naslednja Kontakt Po ne more biti enaka kot vodilni e-po\xc5\xa1tni naslov'
+b'DocType: Tax Rule',b'Billing City',b'Zara\xc4\x8dunavanje Mesto'
+b'DocType: Asset',b'Manual',b'Ro\xc4\x8dno'
+b'DocType: Salary Component Account',b'Salary Component Account',b'Pla\xc4\x8da Komponenta ra\xc4\x8dun'
+b'DocType: Global Defaults',b'Hide Currency Symbol',b'Skrij valutni simbol'
+b'apps/erpnext/erpnext/config/non_profit.py +58',b'Donor information.',b'Podatki o donatorju.'
+b'apps/erpnext/erpnext/config/accounts.py +330',"b'e.g. Bank, Cash, Credit Card'","b'npr Bank, gotovini, Kreditna kartica'"
+b'DocType: Lead Source',b'Source Name',b'Source Name'
+b'DocType: Vital Signs',"b'Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""'","b'Normalni krvni tlak pri odraslih je pribli\xc5\xbeno 120 mmHg sistoli\xc4\x8dnega in 80 mmHg diastoli\xc4\x8dnega, okraj\xc5\xa1anega &quot;120/80 mmHg&quot;'"
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +119',"b'Set items shelf life in days, to set expiry based on manufacturing_date plus self life'","b'Dolo\xc4\x8dite rok trajanja v dnevih, nastavite potek veljavnosti glede na production_date plus \xc5\xbeivljenjsko dobo'"
+b'DocType: Journal Entry',b'Credit Note',b'Dobropis'
+b'DocType: Projects Settings',b'Ignore Employee Time Overlap',b'Prezreti \xc4\x8das prekrivanja zaposlenih'
+b'DocType: Warranty Claim',b'Service Address',b'Storitev Naslov'
+b'DocType: Asset Maintenance Task',b'Calibration',b'Praznovanje'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +97',b'{0} is a company holiday',b'{0} je praznik podjetja'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49',b'Furnitures and Fixtures',b'Pohi\xc5\xa1tvo in Fixtures'
+b'DocType: Item',b'Manufacture',b'Izdelava'
+b'apps/erpnext/erpnext/utilities/user_progress.py +27',b'Setup Company',b'Setup Company'
+,b'Lab Test Report',b'Poro\xc4\x8dilo o laboratorijskem testu'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13',b'Please Delivery Note first',b'Prosimo Delivery Note prvi'
+b'DocType: Student Applicant',b'Application Date',b'uporaba Datum'
+b'DocType: Salary Detail',b'Amount based on formula',"b'Znesek, ki temelji na formuli'"
+b'DocType: Purchase Invoice',b'Currency and Price List',b'Gotovina in Cenik'
+b'DocType: Opportunity',b'Customer / Lead Name',b'Stranka / Ime ponudbe'
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +115',b'Clearance Date not mentioned',b'Potrditev Datum ni omenjena'
+b'apps/erpnext/erpnext/config/manufacturing.py +7',b'Production',b'Proizvodnja'
+b'DocType: Guardian',b'Occupation',b'poklic'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74',b'Row {0}:Start Date must be before End Date',b'Vrstica {0}: Za\xc4\x8detni datum mora biti pred kon\xc4\x8dnim datumom'
+b'DocType: Crop',b'Planting Area',b'Obmo\xc4\x8dje sajenja'
+b'apps/erpnext/erpnext/controllers/trends.py +19',b'Total(Qty)',b'Skupaj (Kol)'
+b'DocType: Installation Note Item',b'Installed Qty',b'Name\xc5\xa1\xc4\x8den Kol'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4',b'This could be because of some invalid Email Addresses in the',b'To je lahko zaradi nekaterih neveljavnih e - po\xc5\xa1tnih naslovov v'
+b'apps/erpnext/erpnext/utilities/user_progress.py +31',b'You added ',b'Dodali ste'
+b'DocType: Purchase Taxes and Charges',b'Parenttype',b'Parenttype'
+b'apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10',b'Training Result',b'Rezultat usposabljanja'
+b'DocType: Purchase Invoice',b'Is Paid',b'je pla\xc4\x8dano'
+b'DocType: Salary Structure',b'Total Earning',b'Skupaj zaslu\xc5\xbeka'
+b'DocType: Purchase Receipt',b'Time at which materials were received',"b'\xc4\x8cas, v katerem so bile prejete materiale'"
+b'DocType: Products Settings',b'Products per Page',b'Izdelki na stran'
+b'DocType: Stock Ledger Entry',b'Outgoing Rate',b'Odhodni Rate'
+b'apps/erpnext/erpnext/config/hr.py +233',b'Organization branch master.',b'Organizacija podru\xc5\xbenica gospodar.'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +313',b' or ',b'ali'
+b'DocType: Sales Order',b'Billing Status',b'Status zara\xc4\x8dunavanje'
+b'apps/erpnext/erpnext/public/js/conf.js +32',b'Report an Issue',b'Prijavi te\xc5\xbeavo'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120',b'Utility Expenses',b'Pomo\xc5\xbeni Stro\xc5\xa1ki'
+b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64',b'90-Above',b'90-Nad'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +252',b'Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher',b'Row # {0}: Journal Entry {1} nima ra\xc4\x8duna {2} ali pa so \xc5\xbee primerjali z drugo kupona'
+b'DocType: Supplier Scorecard Criteria',b'Criteria Weight',b'Te\xc5\xbea meril'
+b'DocType: Buying Settings',b'Default Buying Price List',b'Privzet nabavni cenik'
+b'DocType: Payroll Entry',b'Salary Slip Based on Timesheet',b'Pla\xc4\x8da Slip Na Timesheet'
+b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +43',b'Buying Rate',b'Nakupna cena'
+b'DocType: Notification Control',b'Sales Order Message',b'Sales Order Sporo\xc4\x8dilo'
+b'apps/erpnext/erpnext/config/setup.py +15',"b'Set Default Values like Company, Currency, Current Fiscal Year, etc.'","b'Privzeta nastavitev Vrednote, kot so podjetja, valuta, teko\xc4\x8dem prora\xc4\x8dunskem letu, itd'"
+b'DocType: Payment Entry',b'Payment Type',b'Na\xc4\x8din pla\xc4\x8dila'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +240',b'Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement',"b'Izberite Serija za postavko {0}. Ni mogo\xc4\x8de, da bi na\xc5\xa1li eno serijo, ki izpolnjuje te zahteve'"
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +240',b'Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement',"b'Izberite Serija za postavko {0}. Ni mogo\xc4\x8de, da bi na\xc5\xa1li eno serijo, ki izpolnjuje te zahteve'"
+b'DocType: Hub Category',b'Parent Category',b'Kategorija star\xc5\xa1ev'
+b'DocType: Payroll Entry',b'Select Employees',b'Izberite Zaposleni'
+b'DocType: Opportunity',b'Potential Sales Deal',b'Potencialni Sales Deal'
+b'DocType: Complaint',b'Complaints',b'Prito\xc5\xbebe'
+b'DocType: Payment Entry',b'Cheque/Reference Date',b'\xc4\x8cek / Referen\xc4\x8dni datum'
+b'DocType: Purchase Invoice',b'Total Taxes and Charges',b'Skupaj davki in dajatve'
+b'DocType: Employee',b'Emergency Contact',b'Zasilna Kontakt'
+b'DocType: Bank Reconciliation Detail',b'Payment Entry',b'Za\xc4\x8detek pla\xc4\x8dilo'
+,b'sales-browser',b'prodaja brskalnik'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +79',b'Ledger',b'Ledger'
+b'DocType: Patient Medical Record',b'PMR-',b'PMR-'
+b'DocType: Drug Prescription',b'Drug Code',b'Koda zdravil'
+b'DocType: Target Detail',b'Target  Amount',b'Ciljni znesek'
+b'DocType: POS Profile',b'Print Format for Online',b'Format tiskanja za spletno'
+b'DocType: Shopping Cart Settings',b'Shopping Cart Settings',b'Nastavitve Ko\xc5\xa1arica'
+b'DocType: Journal Entry',b'Accounting Entries',b'Vknji\xc5\xbebe'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17',"b""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.""","b'\xc4\x8ce je izbrano cenovno pravilo za &quot;Oceni&quot;, bo prepisalo cenik. Cena pravilnika je kon\xc4\x8dna obrestna mera, zato ni treba uporabljati dodatnega popusta. Zato se pri transakcijah, kot je prodajna naro\xc4\x8dilo, naro\xc4\x8dilnica itd., Dobijo v polju \xc2\xbbOceni\xc2\xab, ne pa na \xc2\xbbcenik te\xc4\x8daja\xc2\xab.'"
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24',b'Duplicate Entry. Please check Authorization Rule {0}',"b'Podvojenega vnosa. Prosimo, preverite Dovoljenje Pravilo {0}'"
+b'DocType: Journal Entry Account',b'Reference Due Date',b'Referen\xc4\x8dni datum roka'
+b'DocType: Purchase Order',b'Ref SQ',b'Ref SQ'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55',b'Receipt document must be submitted',b'Potrdilo dokument je treba predlo\xc5\xbeiti'
+b'DocType: Purchase Invoice Item',b'Received Qty',b'Prejela Kol'
+b'DocType: Stock Entry Detail',b'Serial No / Batch',b'Zaporedna \xc5\xa1tevilka / Batch'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340',b'Not Paid and Not Delivered',b'Ne pla\xc4\x8da in ne Delivered'
+b'DocType: Product Bundle',b'Parent Item',b'Parent Item'
+b'DocType: Account',b'Account Type',b'Vrsta ra\xc4\x8duna'
+b'DocType: Delivery Note',b'DN-RET-',b'DN-RET-'
+b'apps/erpnext/erpnext/templates/pages/projects.html +58',b'No time sheets',b'Ni listami'
+b'DocType: GoCardless Mandate',b'GoCardless Customer',b'GoCardless stranka'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123',b'Leave Type {0} cannot be carry-forwarded',"b'Pustite Type {0} ni mogo\xc4\x8de izvajati, posredovati'"
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215',"b""Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule'""","b'Vzdr\xc5\xbeevanje Urnik se ne ustvari za vse postavke. Prosimo, kliknite na &quot;ustvarjajo Seznamu&quot;'"
+,b'To Produce',b'Za izdelavo'
+b'apps/erpnext/erpnext/config/hr.py +93',b'Payroll',b'izpla\xc4\x8dane pla\xc4\x8de'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +196',"b'For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included'","b'Za vrstico {0} v {1}. \xc4\x8ce \xc5\xbeelite vklju\xc4\x8diti {2} v stopnji Element, {3}, mora biti vklju\xc4\x8dena tudi vrstice'"
+b'DocType: Patient Service Unit',b'Parent Service Unit',b'Enota star\xc5\xa1evske slu\xc5\xbebe'
+b'apps/erpnext/erpnext/utilities/activation.py +101',b'Make User',b'Naredite uporabnika'
+b'DocType: Packing Slip',b'Identification of the package for the delivery (for print)',b'Identifikacija paketu za dostavo (za tisk)'
+b'DocType: Bin',b'Reserved Quantity',b'Rezervirano Koli\xc4\x8dina'
+b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34',b'Please enter valid email address',b'Vnesite veljaven e-po\xc5\xa1tni naslov'
+b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34',b'Please enter valid email address',b'Vnesite veljaven e-po\xc5\xa1tni naslov'
+b'DocType: Volunteer Skill',b'Volunteer Skill',b'Sposobnost prostovoljcev'
+b'DocType: Bank Reconciliation',b'Include POS Transactions',b'Vklju\xc4\x8dite POS transakcije'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +784',b'Please select an item in the cart',"b'Prosimo, izberite predmet v vozi\xc4\x8dku'"
+b'DocType: Landed Cost Voucher',b'Purchase Receipt Items',b'Nakup Prejem Items'
+b'apps/erpnext/erpnext/config/learn.py +21',b'Customizing Forms',b'Prilagajanje Obrazci'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74',b'Arrear',b'arrear'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158',b'Depreciation Amount during the period',b'Amortizacija Znesek v obdobju'
+b'apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43',b'Disabled template must not be default template',b'Onemogo\xc4\x8deno predloga ne sme biti kot privzeto'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +314',b'For row {0}: Enter planned qty',b'Za vrstico {0}: vnesite na\xc4\x8drtovani qty'
+b'DocType: Shareholder',b'SH-',b'SH-'
+b'DocType: Account',b'Income Account',b'Prihodki ra\xc4\x8dun'
+b'DocType: Payment Request',"b""Amount in customer's currency""",b'Znesek v valuti stranke'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +825',b'Delivery',b'Dostava'
+b'DocType: Volunteer',b'Weekdays',b'Delovni dnevi'
+b'DocType: Stock Reconciliation Item',b'Current Qty',b'Trenutni Kol'
+b'DocType: Restaurant Menu',b'Restaurant Menu',b'Restavracija Meni'
+b'apps/erpnext/erpnext/templates/generators/item_group.html +36',b'Prev',b'prej\xc5\xa1nja'
+b'DocType: Appraisal Goal',b'Key Responsibility Area',b'Key Odgovornost Area'
+b'apps/erpnext/erpnext/utilities/activation.py +127',"b'Student Batches help you track attendance, assessments and fees for students'","b'\xc5\xa0tudentski Paketi vam pomaga slediti sejnin, ocene in pristojbine za \xc5\xa1tudente'"
+b'DocType: Payment Entry',b'Total Allocated Amount',b'Skupaj Dodeljena Znesek'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +151',b'Set default inventory account for perpetual inventory',b'Privzeta nastavitev popis ra\xc4\x8dun za stalne inventarizacije'
+b'DocType: Item Reorder',b'Material Request Type',b'Material Zahteva Type'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252',b'Accural Journal Entry for salaries from {0} to {1}',b'Accural list Vstop za pla iz {0} in {1}'
+b'apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17',b'Send Grant Review Email',b'Po\xc5\xa1lji e-po\xc5\xa1to za pregled e-po\xc5\xa1te'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +848',"b'LocalStorage is full, did not save'","b'Lokalno shrambo je polna, ni re\xc5\xa1il'"
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +100',b'Row {0}: UOM Conversion Factor is mandatory',b'Vrstica {0}: UOM Conversion Factor je obvezna'
+b'apps/erpnext/erpnext/utilities/user_progress.py +235',b'Room Capacity',b'Zmogljivost sob'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +95',b'Ref',b'Ref'
+b'DocType: Lab Test',b'LP-',b'LP-'
+b'DocType: Healthcare Settings',b'Registration Fee',b'Kotizacija'
+b'DocType: Budget',b'Cost Center',b'Stro\xc5\xa1kovno Center'
+b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45',b'Voucher #',b'Voucher #'
+b'DocType: Notification Control',b'Purchase Order Message',b'Naro\xc4\x8dilnica sporo\xc4\x8dilo'
+b'DocType: Tax Rule',b'Shipping Country',b'Dostava Dr\xc5\xbeava'
+b'DocType: Selling Settings',"b""Hide Customer's Tax Id from Sales Transactions""",b'Skrij ID za DDV naro\xc4\x8dnika od prodajnih transakcij'
+b'DocType: Upload Attendance',b'Upload HTML',b'Nalo\xc5\xbei HTML'
+b'DocType: Employee',b'Relieving Date',b'Laj\xc5\xa1anje Datum'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14',"b'Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.'","b'Cen Pravilo je narejen prepisati Cenik / dolo\xc4\x8diti diskontno odstotek, na podlagi nekaterih kriterijev.'"
+b'DocType: Serial No',b'Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt',b'Skladi\xc5\xa1\xc4\x8de je mogo\xc4\x8de spremeniti samo prek borze Vstop / Delivery Note / Potrdilo o nakupu'
+b'DocType: Employee Education',b'Class / Percentage',b'Razred / Odstotek'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134',b'Head of Marketing and Sales',b'Vodja marketinga in prodaje'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72',b'Income Tax',b'Davek na prihodek'
+b'apps/erpnext/erpnext/config/selling.py +174',b'Track Leads by Industry Type.',b'Track Interesenti ga Industry Type.'
+b'apps/erpnext/erpnext/utilities/user_progress.py +101',b'Go to Letterheads',b'Pojdite v Letterheads'
+b'DocType: Item Supplier',b'Item Supplier',b'Postavka Dobavitelj'
+b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1255',b'Please enter Item Code to get batch no',b'Vnesite Koda dobiti serijo no'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +880',b'Please select a value for {0} quotation_to {1}',"b'Prosimo, izberite vrednost za {0} quotation_to {1}'"
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +419',b'No Items selected for transfer',b'Ni izbranih elementov za prenos'
+b'apps/erpnext/erpnext/config/selling.py +46',b'All Addresses.',b'Vsi naslovi.'
+b'DocType: Company',b'Stock Settings',b'Nastavitve Stock'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +183',"b'Merging is only possible if following properties are same in both records. Is Group, Root Type, Company'","b'Spajanje je mogo\xc4\x8de le, \xc4\x8de so naslednje lastnosti enaka v obeh evidencah. Je skupina, Root Type, Company'"
+b'DocType: Vehicle',b'Electric',b'elektri\xc4\x8dni'
+b'DocType: Task',b'% Progress',b'% napredka'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123',b'Gain/Loss on Asset Disposal',b'Dobi\xc4\x8dek / izgube pri prodaji premo\xc5\xbeenja'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +117',b'Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.',b'\xc5\xa0tevilka ra\xc4\x8duna za ra\xc4\x8dun {0} ni na voljo. <br> Pravilno nastavite svoj ra\xc4\x8dun.'
+b'DocType: Task',b'Depends on Tasks',b'Odvisno od Opravila'
+b'apps/erpnext/erpnext/config/selling.py +36',b'Manage Customer Group Tree.',b'Upravljanje drevesa skupine kupcev.'
+b'DocType: Shopping Cart Settings',b'Attachments can be shown without enabling the shopping cart',"b'Priklju\xc4\x8dki se lahko doka\xc5\xbee, ne da bi omogo\xc4\x8dili nakupovalni vozi\xc4\x8dek'"
+b'DocType: Normal Test Items',b'Result Value',b'Vrednost rezultata'
+b'DocType: Hotel Room',b'Hotels',b'Hoteli'
+b'DocType: Supplier Quotation',b'SQTN-',b'SQTN-'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22',b'New Cost Center Name',b'New Stro\xc5\xa1ki Center Ime'
+b'DocType: Leave Control Panel',b'Leave Control Panel',b'Pustite Nadzorna plo\xc5\xa1\xc4\x8da'
+b'DocType: Project',b'Task Completion',b'naloga Zaklju\xc4\x8dek'
+b'apps/erpnext/erpnext/templates/includes/product_page.js +22',b'Not in Stock',b'Ni na zalogi'
+b'DocType: Volunteer',b'Volunteer Skills',b'Prostovoljne spretnosti'
+b'DocType: Appraisal',b'HR User',b'Uporabnik \xc4\x8dlove\xc5\xa1kih virov'
+b'DocType: Purchase Invoice',b'Taxes and Charges Deducted',b'Davki in dajatve Odbitek'
+b'apps/erpnext/erpnext/hooks.py +142',b'Issues',b'Vpra\xc5\xa1anja'
+b'apps/erpnext/erpnext/controllers/status_updater.py +12',b'Status must be one of {0}',b'Stanje mora biti eno od {0}'
+b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64',b'Reminder to update GSTIN Sent',b'Opomnik za posodobitev GSTIN Poslano'
+b'DocType: Sales Invoice',b'Debit To',b'Bremenitev'
+b'DocType: Restaurant Menu Item',b'Restaurant Menu Item',b'Restavracija Menu Item'
+b'DocType: Delivery Note',b'Required only for sample item.',b'Zahteva le za to\xc4\x8dko vzorca.'
+b'DocType: Stock Ledger Entry',b'Actual Qty After Transaction',b'Dejanska Kol Po Transaction'
+,b'Pending SO Items For Purchase Request',b'Dokler SO To\xc4\x8dke za nakup dogovoru'
+b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35',b'Student Admissions',b'\xc5\xa0tudentski Sprejemi'
+b'apps/erpnext/erpnext/accounts/party.py +388',b'{0} {1} is disabled',b'{0} {1} je onemogo\xc4\x8deno'
+b'DocType: Supplier',b'Billing Currency',b'Zara\xc4\x8dunavanje Valuta'
+b'DocType: Sales Invoice',b'SINV-RET-',b'SINV-RET-'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200',b'Extra Large',b'Extra Large'
+b'DocType: Crop',b'Scientific Name',b'Znanstveno ime'
+b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Leaves',b'Skupaj Listi'
+b'DocType: Customer',"b'Reselect, if the chosen contact is edited after save'","b'Ponovno izbere, \xc4\x8de je izbrani stik po urejanju urejen'"
+b'DocType: Consultation',b'In print',b'V tisku'
+,b'Profit and Loss Statement',b'Izkaz poslovnega izida'
+b'DocType: Bank Reconciliation Detail',b'Cheque Number',b'\xc4\x8cek \xc5\xa0tevilo'
+,b'Sales Browser',b'Prodaja Browser'
+b'DocType: Journal Entry',b'Total Credit',b'Skupaj Credit'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542',b'Warning: Another {0} # {1} exists against stock entry {2}',b'Opozorilo: Drug {0} # {1} obstaja pred vstopom parka {2}'
+b'apps/erpnext/erpnext/utilities/user_progress_utils.py +66',b'Local',b'Lokalno'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26',b'Loans and Advances (Assets)',b'Posojila in predujmi (sredstva)'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12',b'Debtors',b'Dol\xc5\xbeniki'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199',b'Large',b'Velika'
+b'DocType: Homepage Featured Product',b'Homepage Featured Product',b'Doma\xc4\x8da stran izbranega izdelka'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +248',b'All Assessment Groups',b'Vse skupine za ocenjevanje'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15',b'New Warehouse Name',b'Novo skladi\xc5\xa1\xc4\x8de Ime'
+b'apps/erpnext/erpnext/accounts/report/financial_statements.py +259',b'Total {0} ({1})',b'Skupno {0} ({1})'
+b'DocType: C-Form Invoice Detail',b'Territory',b'Ozemlje'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151',b'Please mention no of visits required',b'Navedite ni obiskov zahtevanih'
+b'DocType: Stock Settings',b'Default Valuation Method',b'Na\xc4\x8din Privzeto Vrednotenje'
+b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26',b'Fee',b'Fee'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +154',b'Update in progress. It might take a while.',b'Posodabljanje je v teku. Mogo\xc4\x8de bo trajalo nekaj \xc4\x8dasa.'
+b'DocType: Production Plan Item',b'Produced Qty',b'Proizvedeno koli\xc4\x8dino'
+b'DocType: Vehicle Log',b'Fuel Qty',b'gorivo Kol'
+b'DocType: Stock Entry',b'Target Warehouse Name',b'Ime ciljne skladi\xc5\xa1\xc4\x8da'
+b'DocType: Work Order Operation',b'Planned Start Time',b'Na\xc4\x8drtovano Start Time'
+b'DocType: Course',b'Assessment',b'ocena'
+b'DocType: Payment Entry Reference',b'Allocated',b'Razporejeni'
+b'apps/erpnext/erpnext/config/accounts.py +267',b'Close Balance Sheet and book Profit or Loss.',b'Zapri Bilanca stanja in rezervirajte poslovnem izidu.'
+b'DocType: Student Applicant',b'Application Status',b'Status uporaba'
+b'DocType: Sensitivity Test Items',b'Sensitivity Test Items',b'Testi preizkusov ob\xc4\x8dutljivosti'
+b'DocType: Project Update',b'Project Update',b'Posodobitev projekta'
+b'DocType: Fees',b'Fees',b'pristojbine'
+b'DocType: Currency Exchange',b'Specify Exchange Rate to convert one currency into another',b'Dolo\xc4\x8dite Menjalni te\xc4\x8daj za pretvorbo ene valute v drugo'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159',b'Quotation {0} is cancelled',b'Ponudba {0} je odpovedana'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +119',b'Total Outstanding Amount',b'Skupni preostali znesek'
+b'DocType: Sales Partner',b'Targets',b'Cilji'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js +54',b'Please register the SIREN number in the company information file',"b'Prosimo, registrirajte \xc5\xa1tevilko SIREN v podatkovni datoteki podjetja'"
+b'DocType: Price List',b'Price List Master',b'Cenik Master'
+b'DocType: GST Account',b'CESS Account',b'CESS ra\xc4\x8dun'
+b'DocType: Sales Person',b'All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.',"b'Vse prodajne transakcije je lahko ozna\xc4\x8dena pred \xc5\xa1tevilnimi ** Prodajni Osebe **, tako da lahko nastavite in spremljanje ciljev.'"
+,b'S.O. No.',b'SO No.'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241',b'Please create Customer from Lead {0}',"b'Prosimo, da ustvarite strank iz svinca {0}'"
+b'apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3',b'Select Patient',b'Izberite Patient'
+b'DocType: Price List',b'Applicable for Countries',b'Velja za dr\xc5\xbeave'
+b'DocType: Supplier Scorecard Scoring Variable',b'Parameter Name',b'Ime parametra'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52',b'Student Group Name is mandatory in row {0}',b'\xc5\xa0tudent Group Ime je obvezno v vrsti {0}'
+b'DocType: Homepage',b'Products to be shown on website homepage',"b'Proizvodi, ki se prika\xc5\xbee na spletni strani'"
+b'apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13',b'This is a root customer group and cannot be edited.',b'To je skupina koren stranke in jih ni mogo\xc4\x8de urejati.'
+b'DocType: Student',b'AB-',b'AB-'
+b'DocType: POS Profile',b'Ignore Pricing Rule',b'Ignoriraj Pricing pravilo'
+b'DocType: Employee Education',b'Graduate',b'Maturirati'
+b'DocType: Leave Block List',b'Block Days',b'Block dnevi'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83',"b'Shipping Address does not have country, which is required for this Shipping Rule'","b'Naslov za dostavo nima dr\xc5\xbeave, ki je potrebna za to pravilo o po\xc5\xa1iljanju'"
+b'DocType: Journal Entry',b'Excise Entry',b'Tro\xc5\xa1arina Za\xc4\x8detek'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65',"b""Warning: Sales Order {0} already exists against Customer's Purchase Order {1}""",b'Opozorilo: Sales Order {0} \xc5\xbee obstaja zoper naro\xc4\x8dnikovo narocilo {1}'
+b'DocType: Terms and Conditions',"b'Standard Terms and Conditions that can be added to Sales and Purchases.\n\nExamples:\n\n1. Validity of the offer.\n1. Payment Terms (In Advance, On Credit, part advance etc).\n1. What is extra (or payable by the Customer).\n1. Safety / usage warning.\n1. Warranty if any.\n1. Returns Policy.\n1. Terms of shipping, if applicable.\n1. Ways of addressing disputes, indemnity, liability, etc.\n1. Address and Contact of your Company.'","b'Standardni Pogoji, ki se lahko dodajajo prodaje in nakupe. Primeri: 1. Veljavnost ponudbe. 1. Pla\xc4\x8dilni pogoji (vnaprej, na kredit, del predujem itd). 1. Kaj je dodatno (ali ga je dol\xc5\xbean pla\xc4\x8dati davek). Opozorilo / uporaba 1. varnost. 1. Garancija \xc4\x8de sploh. 1. Izjava zasebnosti. 1. Pogoji ladijskega prometa, \xc4\x8de je to primerno. 1. na\xc4\x8dine re\xc5\xa1evanja sporov, jamstva, odgovornosti, itd 1. Naslov in kontaktne va\xc5\xa1ega podjetja.'"
+b'DocType: Issue',b'Issue Type',b'Vrsta izdaje'
+b'DocType: Attendance',b'Leave Type',b'Zapusti Type'
+b'DocType: Purchase Invoice',b'Supplier Invoice Details',b'Dobavitelj Podrobnosti ra\xc4\x8duna'
+b'DocType: Agriculture Task',b'Ignore holidays',b'Prezri odmor'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +233',"b""Expense / Difference account ({0}) must be a 'Profit or Loss' account""",b'Expense / Razlika ra\xc4\x8dun ({0}) mora biti ra\xc4\x8dun &quot;poslovni izid&quot;'
+b'DocType: Project',b'Copied From',b'Kopirano iz'
+b'DocType: Project',b'Copied From',b'Kopirano iz'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +340',b'Invoice already created for all billing hours',"b'Ra\xc4\x8dun, ki je \xc5\xbee ustvarjen za vse obra\xc4\x8dunske ure'"
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96',b'Name error: {0}',b'Ime napaka: {0}'
+b'DocType: Cash Flow Mapping',b'Is Finance Cost',b'Je stro\xc5\xa1ek financiranja'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18',b'Attendance for employee {0} is already marked',b'Udele\xc5\xbeba na zaposlenega {0} je \xc5\xbee ozna\xc4\x8deno'
+b'DocType: Packing Slip',b'If more than one package of the same type (for print)',b'\xc4\x8ce ve\xc4\x8d paketov istega tipa (v tisku)'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27',b'Please set default customer in Restaurant Settings',b'Privzeto stran nastavite v nastavitvah restavracij'
+,b'Salary Register',b'pla\xc4\x8da Registracija'
+b'DocType: Warehouse',b'Parent Warehouse',b'Parent Skladi\xc5\xa1\xc4\x8de'
+b'DocType: C-Form Invoice Detail',b'Net Total',b'Neto Skupaj'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +546',b'Default BOM not found for Item {0} and Project {1}',b'Privzeti BOM nismo na\xc5\xa1li v postavki {0} in projektno {1}'
+b'apps/erpnext/erpnext/config/hr.py +168',b'Define various loan types',b'Opredeliti razli\xc4\x8dne vrste posojil'
+b'DocType: Bin',b'FCFS Rate',b'FCFS Rate'
+b'DocType: Opening Invoice Creation Tool Item',b'Outstanding Amount',b'Neporavnani znesek'
+b'apps/erpnext/erpnext/templates/generators/bom.html +71',b'Time(in mins)',b'\xc4\x8cas (v minutah)'
+b'DocType: Project Task',b'Working',b'Delovna'
+b'DocType: Stock Ledger Entry',b'Stock Queue (FIFO)',b'Stock Queue (FIFO)'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +127',b'Financial Year',b'Finan\xc4\x8dno leto'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46',b'{0} does not belong to Company {1}',b'{0} ne pripada dru\xc5\xbebi {1}'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66',b'Could not solve criteria score function for {0}. Make sure the formula is valid.',"b'Za {0} ni bilo mogo\xc4\x8de re\xc5\xa1iti funkcije ocene rezultatov. Prepri\xc4\x8dajte se, da formula velja.'"
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122',b'Cost as on',b'Stane na'
+b'DocType: Healthcare Settings',b'Out Patient Settings',b'Out Patient Settings'
+b'DocType: Account',b'Round Off',b'Zaokro\xc5\xbeite'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +259',b'Quantity must be positive',b'Koli\xc4\x8dina mora biti pozitivna'
+b'DocType: Material Request Plan Item',b'Requested Qty',b'Zahteval Kol'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +96',b'The fields From Shareholder and To Shareholder cannot be blank',b'Polja Od delni\xc4\x8darja in delni\xc4\x8darja ne morejo biti prazna'
+b'DocType: Tax Rule',b'Use for Shopping Cart',b'Uporabite za Ko\xc5\xa1arica'
+b'apps/erpnext/erpnext/controllers/item_variant.py +101',b'Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2}',b'Vrednost {0} za Attribute {1} ne obstaja na seznamu veljavnega to\xc4\x8dke Lastnost Vrednosti za postavko {2}'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79',b'Select Serial Numbers',b'Izberite serijsko \xc5\xa1tevilko'
+b'DocType: BOM Item',b'Scrap %',b'Ostanki%'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46',"b'Charges will be distributed proportionately based on item qty or amount, as per your selection'","b'Dajatve bodo razdeljeni sorazmerno na podlagi postavka Kol ali znesek, glede na va\xc5\xa1o izbiro'"
+b'DocType: Maintenance Visit',b'Purposes',b'Nameni'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +112',b'Atleast one item should be entered with negative quantity in return document',"b'Atleast en element, se vpi\xc5\xa1e z negativnim koli\xc4\x8dino v povratni dokument'"
+b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71',"b'Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations'","b'Operacija {0} dlje od vseh razpolo\xc5\xbeljivih delovnih ur v delovni postaji {1}, raz\xc4\x8dleniti operacijo na ve\xc4\x8d operacij'"
+b'DocType: Membership',b'Membership Status',b'Status \xc4\x8dlanstva'
+,b'Requested',b'Zahteval'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93',b'No Remarks',b'Ni Opombe'
+b'DocType: Asset',b'In Maintenance',b'V vzdr\xc5\xbeevanju'
+b'DocType: Purchase Invoice',b'Overdue',b'Zapadle'
+b'DocType: Account',b'Stock Received But Not Billed',b'Prejete Stock Ampak ne zara\xc4\x8duna'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +84',b'Root Account must be a group',b'Root ra\xc4\x8dun mora biti skupina'
+b'DocType: Drug Prescription',b'Drug Prescription',b'Predpis o drogah'
+b'DocType: Fees',b'FEE.',b'FEE.'
+b'DocType: Employee Loan',b'Repaid/Closed',b'Povrne / Zaprto'
+b'DocType: Item',b'Total Projected Qty',b'Skupne projekcije Kol'
+b'DocType: Monthly Distribution',b'Distribution Name',b'Porazdelitev Name'
+b'apps/erpnext/erpnext/stock/stock_ledger.py +477',"b'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'","b'Stopnja vrednotenja ni mogo\xc4\x8de najti za postavko {0}, ki je potrebna za izvr\xc5\xa1itev ra\xc4\x8dunovodskih vnosov za {1} {2}. \xc4\x8ce je predmet predmet transakcije kot element ni\xc4\x8delne vrednosti za vrednost v {1}, navedite to v tabeli {1} Item. V nasprotnem primeru ustvarite transakcijo dohodne delnice za postavko ali navedite stopnjo vrednotenja v zapisu postavke in poskusite poslati / preklicati ta vnos'"
+b'DocType: Course',b'Course Code',b'Koda predmeta'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +337',b'Quality Inspection required for Item {0}',b'In\xc5\xa1pekcija kakovosti potrebna za postavko {0}'
+b'DocType: POS Settings',b'Use POS in Offline Mode',b'Uporabite POS v na\xc4\x8dinu brez povezave'
+b'DocType: Supplier Scorecard',b'Supplier Variables',b'Spremenljivke dobavitelja'
+b'DocType: Quotation',"b""Rate at which customer's currency is converted to company's base currency""","b'Obrestna mera, po kateri kupec je valuti, se pretvori v osnovni valuti dru\xc5\xbebe'"
+b'DocType: Purchase Invoice Item',b'Net Rate (Company Currency)',b'Net Rate (dru\xc5\xbeba Valuta)'
+b'DocType: Salary Detail',b'Condition and Formula Help',b'Stanje in Formula Pomo\xc4\x8d'
+b'apps/erpnext/erpnext/config/selling.py +105',b'Manage Territory Tree.',b'Upravljanje Territory drevo.'
+b'DocType: Patient Service Unit',b'Patient Service Unit',b'Enota za bolnike'
+b'DocType: Journal Entry Account',b'Sales Invoice',b'Ra\xc4\x8dun'
+b'DocType: Journal Entry Account',b'Party Balance',b'Balance Party'
+b'DocType: Cash Flow Mapper',b'Section Subtotal',b'Vmesni del vsote'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +498',b'Please select Apply Discount On',"b'Prosimo, izberite Uporabi popust na'"
+b'DocType: Stock Settings',b'Sample Retention Warehouse',b'Skladi\xc5\xa1\xc4\x8de za shranjevanje vzorcev'
+b'DocType: Company',b'Default Receivable Account',b'Privzeto Terjatve ra\xc4\x8dun'
+b'DocType: Physician Schedule',b'Physician Schedule',b'Urnik zdravnika'
+b'DocType: Purchase Invoice',b'Deemed Export',b'Izbrisani izvoz'
+b'DocType: Stock Entry',b'Material Transfer for Manufacture',b'Prenos materialov za proizvodnjo'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20',b'Discount Percentage can be applied either against a Price List or for all Price List.',b'Popust Odstotek se lahko uporablja bodisi proti ceniku ali za vse cenik.'
+b'DocType: Subscription',b'Half-yearly',b'Polletni'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +407',b'Accounting Entry for Stock',b'Ra\xc4\x8dunovodstvo Vstop za zalogi'
+b'DocType: Lab Test',b'LabTest Approver',b'Odobritev LabTest'
+b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +61',b'You have already assessed for the assessment criteria {}.',b'Ste \xc5\xbee ocenili za ocenjevalnih meril {}.'
+b'DocType: Vehicle Service',b'Engine Oil',b'Motorno olje'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1005',b'Work Orders Created: {0}',b'Ustvarjeni delovni nalogi: {0}'
+b'DocType: Sales Invoice',b'Sales Team1',b'Prodaja TEAM1'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +547',b'Item {0} does not exist',b'Element {0} ne obstaja'
+b'DocType: Sales Invoice',b'Customer Address',b'Naslov stranke'
+b'DocType: Employee Loan',b'Loan Details',b'posojilo Podrobnosti'
+b'DocType: Company',b'Default Inventory Account',b'Privzeti Popis ra\xc4\x8dun'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +192',b'The folio numbers are not matching',b'Folio \xc5\xa1tevilke se ne ujemajo'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124',b'Row {0}: Completed Qty must be greater than zero.',b'Vrstica {0}: Zaklju\xc4\x8den Kol mora biti ve\xc4\x8dji od ni\xc4\x8d.'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +262',b'Payment Request for {0}',b'Zahteva za pla\xc4\x8dilo za {0}'
+b'DocType: Item Barcode',b'Barcode Type',b'Tip \xc4\x8drtne kode'
+b'DocType: Antibiotic',b'Antibiotic Name',b'Ime antibiotika'
+b'DocType: Purchase Invoice',b'Apply Additional Discount On',b'Uporabi dodatni popust na'
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +66',b'Select Type...',b'Izberite Vrsta ...'
+b'DocType: Crop Cycle',b'A link to all the Land Units in which the Crop is growing',"b'Povezava na vse enote kopenskih povr\xc5\xa1in, v katerih rastlina raste'"
+b'DocType: Account',b'Root Type',b'Root Type'
+b'DocType: Item',b'FIFO',b'FIFO'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +136',b'Row # {0}: Cannot return more than {1} for Item {2}',b'Vrstica # {0}: ne more vrniti ve\xc4\x8d kot {1} za postavko {2}'
+b'DocType: Item Group',b'Show this slideshow at the top of the page',b'Poka\xc5\xbeite ta diaprojekcije na vrhu strani'
+b'DocType: BOM',b'Item UOM',b'Postavka UOM'
+b'DocType: Sales Taxes and Charges',b'Tax Amount After Discount Amount (Company Currency)',b'Dav\xc4\x8dna Znesek Po Popust Znesek (dru\xc5\xbeba Valuta)'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +177',b'Target warehouse is mandatory for row {0}',b'Ciljna skladi\xc5\xa1\xc4\x8de je obvezna za vrstico {0}'
+b'DocType: Cheque Print Template',b'Primary Settings',b'primarni Nastavitve'
+b'DocType: Purchase Invoice',b'Select Supplier Address',b'Izberite Dobavitelj naslov'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397',b'Add Employees',b'Dodaj Zaposleni'
+b'DocType: Purchase Invoice Item',b'Quality Inspection',b'Quality Inspection'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196',b'Extra Small',b'Extra Small'
+b'DocType: Company',b'Standard Template',b'standard Template'
+b'DocType: Training Event',b'Theory',b'teorija'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +806',b'Warning: Material Requested Qty is less than Minimum Order Qty',"b'Opozorilo: Material Zahtevana Koli\xc4\x8dina je manj kot minimalna, da Kol'"
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211',b'Account {0} is frozen',b'Ra\xc4\x8dun {0} je zamrznjen'
+b'DocType: Company',b'Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.',b'Pravna oseba / H\xc4\x8derinska dru\xc5\xbeba z lo\xc4\x8denim ra\xc4\x8dunom ki pripada organizaciji.'
+b'DocType: Payment Request',b'Mute Email',b'Mute Email'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29',"b'Food, Beverage & Tobacco'","b'Hrana, pija\xc4\x8da, tobak'"
+b'DocType: Account',b'Account Number',b'\xc5\xa0tevilka ra\xc4\x8duna'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +752',b'Can only make payment against unbilled {0}',b'Lahko le pla\xc4\x8dilo proti neobra\xc4\x8dunano {0}'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +102',b'Commission rate cannot be greater than 100',b'Stopnja Komisija ne more biti ve\xc4\x8dja od 100'
+b'DocType: Volunteer',b'Volunteer',b'Prostovoljka'
+b'DocType: Stock Entry',b'Subcontract',b'Podizvajalska pogodba'
+b'apps/erpnext/erpnext/public/js/utils/party.js +166',b'Please enter {0} first',b'Vnesite {0} najprej'
+b'apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +104',b'No replies from',b'Ni odgovorov'
+b'DocType: Work Order Operation',b'Actual End Time',b'Dejanski Kon\xc4\x8dni \xc4\x8das'
+b'DocType: Item',b'Manufacturer Part Number',b'\xc5\xa0tevilka dela proizvajalca'
+b'DocType: Work Order Operation',b'Estimated Time and Cost',b'Predvideni \xc4\x8das in stro\xc5\xa1ki'
+b'DocType: Bin',b'Bin',b'Bin'
+b'DocType: Crop',b'Crop Name',b'Ime pridelka'
+b'DocType: SMS Log',b'No of Sent SMS',b'\xc5\xa0tevilo poslanih SMS'
+b'DocType: Antibiotic',b'Healthcare Administrator',b'Skrbnik zdravstva'
+b'apps/erpnext/erpnext/utilities/user_progress.py +47',b'Set a Target',b'Nastavite cilj'
+b'DocType: Dosage Strength',b'Dosage Strength',b'Odmerek'
+b'DocType: Account',b'Expense Account',b'Expense ra\xc4\x8dun'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49',b'Software',b'Programska oprema'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203',b'Colour',b'Barva'
+b'DocType: Assessment Plan Criteria',b'Assessment Plan Criteria',b'Merila na\xc4\x8drt ocenjevanja'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +118',b'Expiry date is mandatory for selected item',b'Datum izteka roka je obvezen za izbrani predmet'
+b'DocType: Supplier Scorecard Scoring Standing',b'Prevent Purchase Orders',b'Prepre\xc4\x8devanje nakupnih naro\xc4\x8dil'
+b'apps/erpnext/erpnext/healthcare/setup.py +258',b'Susceptible',b'Ob\xc4\x8dutljivo'
+b'DocType: Patient Appointment',b'Scheduled',b'Na\xc4\x8drtovano'
+b'apps/erpnext/erpnext/config/buying.py +18',b'Request for quotation.',b'Zahteva za ponudbo.'
+b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13',"b'Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle'","b'Prosimo, izberite postavko, kjer &quot;Stock postavka je&quot; &quot;Ne&quot; in &quot;Je Sales Postavka&quot; je &quot;Yes&quot; in ni druge Bundle izdelka'"
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148',b'Select Customer',b'Izberite stranko'
+b'DocType: Student Log',b'Academic',b'akademski'
+b'DocType: Patient',b'Personal and Social History',b'Osebna in socialna zgodovina'
+b'apps/erpnext/erpnext/education/doctype/guardian/guardian.py +51',b'User {0} created',b'Uporabnik {0} je ustvaril'
+b'DocType: Fee Schedule',b'Fee Breakup for each student',b'Povra\xc4\x8dilo stro\xc5\xa1kov za vsakega \xc5\xa1tudenta'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +541',b'Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2})',b'Skupaj predpla\xc4\x8dilo ({0}) proti odredbi {1} ne more biti ve\xc4\x8dja od Grand Total ({2})'
+b'DocType: Sales Partner',b'Select Monthly Distribution to unevenly distribute targets across months.',b'Izberite mese\xc4\x8dnim izpla\xc4\x8dilom neenakomerno distribucijo ciljev po mesecih.'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78',b'Change Code',b'Spremeni kodo'
+b'DocType: Purchase Invoice Item',b'Valuation Rate',b'Oceni Vrednotenje'
+b'DocType: Stock Reconciliation',b'SR/',b'SR /'
+b'DocType: Vehicle',b'Diesel',b'Diesel'
+b'apps/erpnext/erpnext/stock/get_item_details.py +388',b'Price List Currency not selected',b'Cenik Valuta ni izbran'
+b'DocType: Purchase Invoice',b'Availed ITC Cess',b'Uporabil ITC Cess'
+,b'Student Monthly Attendance Sheet',b'\xc5\xa0tudent Mese\xc4\x8dni Udele\xc5\xbeba Sheet'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96',b'Shipping rule only applicable for Selling',b'Pravilo o dostavi velja samo za prodajo'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30',b'Project Start Date',b'Projekt Start Date'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +23',b'Until',b'Do'
+b'DocType: Rename Tool',b'Rename Log',b'Preimenovanje Prijava'
+b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27',b'Student Group or Course Schedule is mandatory',b'\xc5\xa0tudent skupine ali te\xc4\x8daj Urnik je obvezna'
+b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27',b'Student Group or Course Schedule is mandatory',b'\xc5\xa0tudent skupine ali te\xc4\x8daj Urnik je obvezna'
+b'DocType: HR Settings',b'Maintain Billing Hours and Working Hours Same on Timesheet',b'Ohranite pla\xc4\x8devanja Ure in delovni \xc4\x8das Same na Timesheet'
+b'DocType: Maintenance Visit Purpose',b'Against Document No',b'Proti dokument \xc5\xa1t'
+b'DocType: BOM',b'Scrap',b'Odpadno'
+b'apps/erpnext/erpnext/utilities/user_progress.py +217',b'Go to Instructors',b'Pojdi na In\xc5\xa1truktorje'
+b'apps/erpnext/erpnext/config/selling.py +110',b'Manage Sales Partners.',b'Upravljanje prodajne partnerje.'
+b'DocType: Quality Inspection',b'Inspection Type',b'In\xc5\xa1pekcijski Type'
+b'DocType: Fee Validity',b'Visited yet',b'Obiskal \xc5\xa1e'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +134',b'Warehouses with existing transaction can not be converted to group.',b'Skladi\xc5\xa1\xc4\x8da z obstoje\xc4\x8dim poslom ni mogo\xc4\x8de pretvoriti v skupino.'
+b'DocType: Assessment Result Tool',b'Result HTML',b'rezultat HTML'
+b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35',b'Expires On',b'Pote\xc4\x8de'
+b'apps/erpnext/erpnext/utilities/activation.py +117',b'Add Students',b'Dodaj \xc5\xa0tudenti'
+b'apps/erpnext/erpnext/public/js/utils.js +270',b'Please select {0}',"b'Prosimo, izberite {0}'"
+b'DocType: C-Form',b'C-Form No',b'C-forma'
+b'DocType: BOM',b'Exploded_items',b'Exploded_items'
+b'apps/erpnext/erpnext/utilities/user_progress.py +139',b'List your products or services that you buy or sell.',"b'Navedite svoje izdelke ali storitve, ki jih kupite ali prodajate.'"
+b'DocType: Water Analysis',b'Storage Temperature',b'Temperatura shranjevanja'
+b'DocType: Employee Attendance Tool',b'Unmarked Attendance',b'neozna\xc4\x8dena in postre\xc5\xbebo'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137',b'Researcher',b'Raziskovalec'
+b'DocType: Program Enrollment Tool Student',b'Program Enrollment Tool Student',b'Program Vpis Orodje Student'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16',b'Start date should be less than end date for task {0}',b'Za\xc4\x8detni datum mora biti kraj\xc5\xa1i od kon\xc4\x8dnega datuma za opravilo {0}'
+b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25',b'Name or Email is mandatory',b'Ime ali E-po\xc5\xa1ta je obvezna'
+b'DocType: Member',b'MEM-',b'MEM-'
+b'DocType: Instructor',b'Instructor Log',b'Dnevnik in\xc5\xa1truktorja'
+b'DocType: Purchase Order Item',b'Returned Qty',b'Vrnjeno Kol'
+b'DocType: Student',b'Exit',b'Izhod'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +156',b'Root Type is mandatory',b'Root Tip je obvezna'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29',b'Failed to install presets',b'Namestitev prednastavitev ni uspela'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +44',"b'{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.'",b'{0} ima trenutno {1} oceno dobavitelja in naro\xc4\x8dila temu dobavitelju je treba izdajati s previdnostjo'
+b'DocType: Chapter',b'Non Profit Manager',b'Neprofitni mened\xc5\xbeer'
+b'DocType: BOM',b'Total Cost(Company Currency)',b'Skupni stro\xc5\xa1ki (dru\xc5\xbeba Valuta)'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315',b'Serial No {0} created',b'Serijska \xc5\xa1t {0} ustvaril'
+b'DocType: Homepage',b'Company Description for website homepage',b'Podjetje Opis za doma\xc4\x8do stran spletnega mesta'
+b'DocType: Item Customer Detail',"b'For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes'","b'Za udobje kupcev lahko te kode se uporabljajo v tiskanih oblikah, kot so na ra\xc4\x8dunih in dobavnicah'"
+b'apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18',b'Suplier Name',b'Ime suplier'
+b'apps/erpnext/erpnext/accounts/report/financial_statements.py +174',b'Could not retrieve information for {0}.',b'Podatkov za {0} ni bilo mogo\xc4\x8de pridobiti.'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +134',b'Opening Entry Journal',b'Otvoritveni dnevnik'
+b'DocType: Sales Invoice',b'Time Sheet List',b'\xc4\x8casovnica'
+b'DocType: Employee',b'You can enter any date manually',b'Lahko jih vnesete nobenega datuma'
+b'DocType: Healthcare Settings',b'Result Printed',b'Rezultat natisnjen'
+b'DocType: Asset Category Account',b'Depreciation Expense Account',b'Amortizacija ra\xc4\x8dun'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +233',b'Probationary Period',b'Poskusna doba'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32',b'View {0}',b'Ogled {0}'
+b'DocType: Customer Group',b'Only leaf nodes are allowed in transaction',b'Samo leaf vozli\xc5\xa1\xc4\x8da so dovoljene v transakciji'
+b'DocType: Project',b'Total Costing Amount (via Timesheets)',b'Skupni znesek stro\xc5\xa1kov (prek \xc4\x8dasopisov)'
+b'DocType: Employee Advance',b'Expense Approver',b'Expense odobritelj'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136',b'Row {0}: Advance against Customer must be credit',b'Vrstica {0}: Advance proti naro\xc4\x8dniku mora biti kredit'
+b'DocType: Project',b'Hourly',b'Na uro'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +89',b'Non-Group to Group',b'Non-Group skupini'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58',b'Batch is mandatory in row {0}',b'Serija je obvezna v vrstici {0}'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58',b'Batch is mandatory in row {0}',b'Serija je obvezna v vrstici {0}'
+b'DocType: Purchase Receipt Item Supplied',b'Purchase Receipt Item Supplied',b'Potrdilo o nakupu Postavka Prilo\xc5\xbeena'
+b'apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24',b'To Datetime',b'Da datetime'
+b'apps/erpnext/erpnext/config/selling.py +302',b'Logs for maintaining sms delivery status',b'Dnevniki za ohranjanje statusa dostave sms'
+b'DocType: Accounts Settings',b'Make Payment via Journal Entry',b'Naredite pla\xc4\x8dilo preko Journal Entry'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +223',b'Printed On',b'Tiskano na'
+b'DocType: Item',b'Inspection Required before Delivery',b'In\xc5\xa1pekcijski Zahtevana pred dostavo'
+b'DocType: Item',b'Inspection Required before Purchase',b'In\xc5\xa1pekcijski Zahtevana pred nakupom'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93',b'Pending Activities',b'\xc4\x8cakanju Dejavnosti'
+b'DocType: Patient Appointment',b'Reminded',b'Opomniti'
+b'DocType: Patient',b'PID-',b'PID-'
+b'DocType: Chapter Member',b'Chapter Member',b'\xc4\x8clan poslanke'
+b'DocType: Material Request Plan Item',b'Minimum Order Quantity',b'Najmanj\xc5\xa1a koli\xc4\x8dina naro\xc4\x8dila'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +106',b'Your Organization',b'Va\xc5\xa1a organizacija'
+b'DocType: Fee Component',b'Fees Category',b'pristojbine Kategorija'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +134',b'Please enter relieving date.',b'Vnesite laj\xc5\xa1anje datum.'
+b'apps/erpnext/erpnext/controllers/trends.py +149',b'Amt',b'Amt'
+b'DocType: Supplier Scorecard',b'Notify Employee',b'Obvesti delavca'
+b'DocType: Opportunity',b'Enter name of campaign if source of enquiry is campaign',"b'Vnesite ime ogla\xc5\xa1evalske akcije, \xc4\x8de je vir preiskovalne akcije'"
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38',b'Newspaper Publishers',b'Newspaper Publishers'
+b'apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30',b'Select Fiscal Year',b'Izberite Fiscal Year'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115',b'Expected Delivery Date should be after Sales Order Date',b'Pri\xc4\x8dakovani rok dobave je po datumu prodajnega naro\xc4\x8dila'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42',b'Reorder Level',b'Preureditev Raven'
+b'DocType: Company',b'Chart Of Accounts Template',b'Graf Of predlogo ra\xc4\x8dunov'
+b'DocType: Attendance',b'Attendance Date',b'Udele\xc5\xbeba Datum'
+b'apps/erpnext/erpnext/stock/get_item_details.py +352',b'Item Price updated for {0} in Price List {1}',b'Kos Cena posodabljati za {0} v ceniku {1}'
+b'DocType: Salary Structure',b'Salary breakup based on Earning and Deduction.',b'Pla\xc4\x8da razpadu temelji na zaslu\xc5\xbeek in odbitka.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +128',b'Account with child nodes cannot be converted to ledger',b'Ra\xc4\x8dun z zapirali vozli\xc5\xa1\xc4\x8d ni mogo\xc4\x8de pretvoriti v knjigo terjatev'
+b'DocType: Purchase Invoice Item',b'Accepted Warehouse',b'Accepted Skladi\xc5\xa1\xc4\x8de'
+b'DocType: Bank Reconciliation Detail',b'Posting Date',b'Napotitev Datum'
+b'DocType: Item',b'Valuation Method',b'Metoda vrednotenja'
+b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203',b'Mark Half Day',b'Mark Day Half'
+b'DocType: Sales Invoice',b'Sales Team',b'Sales Team'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +87',b'Duplicate entry',b'Dvojnik vnos'
+b'DocType: Program Enrollment Tool',b'Get Students',b'Get \xc5\xa0tudenti'
+b'DocType: Serial No',b'Under Warranty',b'Pod garancijo'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +516',b'[Error]',b'[Error]'
+b'DocType: Sales Order',b'In Words will be visible once you save the Sales Order.',"b'V besedi bo viden, ko boste shranite Sales Order.'"
+,b'Employee Birthday',b'Zaposleni Rojstni dan'
+b'apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14',b'Please select Completion Date for Completed Repair',b'Izberite datum zaklju\xc4\x8dka za dokon\xc4\x8dano popravilo'
+b'DocType: Student Batch Attendance Tool',b'Student Batch Attendance Tool',b'\xc5\xa0tudent Serija Udele\xc5\xbeba orodje'
+b'apps/erpnext/erpnext/controllers/status_updater.py +213',b'Limit Crossed',b'Limit navzkri\xc5\xbenim'
+b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22',b'Scheduled Upto',b'Na\xc4\x8drtovani Upto'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55',b'Venture Capital',b'Tveganega kapitala'
+b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40',"b""An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.""","b'Akademski izraz s tem &quot;\xc5\xa1tudijskem letu &#39;{0} in&quot; Trajanje Ime&#39; {1} \xc5\xbee obstaja. Prosimo, spremenite te vnose in poskusite znova.'"
+b'DocType: UOM',b'Must be Whole Number',b'Mora biti celo \xc5\xa1tevilo'
+b'DocType: Leave Control Panel',b'New Leaves Allocated (In Days)',b'Nove Listi Dodeljena (v dnevih)'
+b'DocType: Purchase Invoice',b'Invoice Copy',b'ra\xc4\x8dun Kopiraj'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49',b'Serial No {0} does not exist',b'Serijska \xc5\xa1t {0} ne obstaja'
+b'DocType: Sales Invoice Item',b'Customer Warehouse (Optional)',b'Skladi\xc5\xa1\xc4\x8de stranka (po \xc5\xbeelji)'
+b'DocType: Pricing Rule',b'Discount Percentage',b'Popust Odstotek'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51',b'Reserved for sub contracting',b'Rezervirano za podizvajalce'
+b'DocType: Payment Reconciliation Invoice',b'Invoice Number',b'\xc5\xa0tevilka ra\xc4\x8duna'
+b'DocType: Shopping Cart Settings',b'Orders',b'Naro\xc4\x8dila'
+b'DocType: Employee Leave Approver',b'Leave Approver',b'Pustite odobritelju'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285',b'Please select a batch',b'Izberite serijo'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42',b'JournalLib',b'JournalLib'
+b'DocType: Assessment Group',b'Assessment Group Name',b'Ime skupine ocena'
+b'DocType: Manufacturing Settings',b'Material Transferred for Manufacture',b'Material Preneseno za Izdelava'
+b'DocType: Landed Cost Item',b'Receipt Document Type',b'Prejem Vrsta dokumenta'
+b'DocType: Daily Work Summary Settings',b'Select Companies',b'izberite podjetja'
+b'DocType: Antibiotic',b'Healthcare',b'Zdravstvo'
+b'DocType: Target Detail',b'Target Detail',b'Ciljna Detail'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +65',b'Single Variant',b'Enotna varianta'
+b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24',b'All Jobs',b'Vsa delovna mesta'
+b'DocType: Sales Order',b'% of materials billed against this Sales Order',b'% materiala zara\xc4\x8dunano po tej naro\xc4\x8dilnici'
+b'DocType: Program Enrollment',b'Mode of Transportation',b'Na\xc4\x8din za promet'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49',b'Period Closing Entry',b'Obdobje Closing Za\xc4\x8detek'
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +72',b'Select Department...',b'Izberite oddelek ...'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38',b'Cost Center with existing transactions can not be converted to group',b'Stro\xc5\xa1kovno Center z obstoje\xc4\x8dimi transakcij ni mogo\xc4\x8de pretvoriti v skupini'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374',b'Amount {0} {1} {2} {3}',b'Znesek {0} {1} {2} {3}'
+b'DocType: Account',b'Depreciation',b'Amortizacija'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +102',b'The number of shares and the share numbers are inconsistent',b'\xc5\xa0tevilo delnic in \xc5\xa1tevilke delnic so neskladne'
+b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49',b'Supplier(s)',b'Dobavitelj (-i)'
+b'DocType: Employee Attendance Tool',b'Employee Attendance Tool',b'Zaposleni Udele\xc5\xbeba Tool'
+b'DocType: Guardian Student',b'Guardian Student',b'Guardian \xc5\xa0tudent'
+b'DocType: Supplier',b'Credit Limit',b'Kreditni limit'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70',b'Avg. Selling Price List Rate',b'Povpr. Prodajna cenik te\xc4\x8daja'
+b'DocType: Salary Component',b'Salary Component',b'pla\xc4\x8da Component'
+b'apps/erpnext/erpnext/accounts/utils.py +495',b'Payment Entries {0} are un-linked',b'Pla\xc4\x8dilni Navedbe {0} un povezane'
+b'DocType: GL Entry',b'Voucher No',b'Voucher ni'
+,b'Lead Owner Efficiency',b'Svinec Lastnik U\xc4\x8dinkovitost'
+,b'Lead Owner Efficiency',b'Svinec Lastnik U\xc4\x8dinkovitost'
+b'DocType: Leave Allocation',b'Leave Allocation',b'Pustite Dodelitev'
+b'DocType: Payment Request',b'Recipient Message And Payment Details',b'Prejemnik sporo\xc4\x8dila in na\xc4\x8din pla\xc4\x8dila'
+b'DocType: Training Event',b'Trainer Email',b'Trainer Email'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550',b'Material Requests {0} created',b'Material Zahteve {0} ustvarjene'
+b'DocType: Restaurant Reservation',b'No of People',b'\xc5\xa0tevilo ljudi'
+b'apps/erpnext/erpnext/config/selling.py +164',b'Template of terms or contract.',b'Predloga izrazov ali pogodbe.'
+b'DocType: Purchase Invoice',b'Address and Contact',b'Naslov in Stik'
+b'DocType: Cheque Print Template',b'Is Account Payable',b'Je ra\xc4\x8duna pla\xc4\x8dljivo'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276',b'Stock cannot be updated against Purchase Receipt {0}',b'Stock ni mogo\xc4\x8de posodobiti proti Nakup prejemu {0}'
+b'DocType: Support Settings',b'Auto close Issue after 7 days',b'Auto blizu Izdaja po 7 dneh'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +71',"b'Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}'","b'Dopusta ni mogo\xc4\x8de dodeliti pred {0}, saj je bilanca dopust \xc5\xbee-carry posredujejo v evidenco dodeljevanja dopust prihodnji {1}'"
+b'apps/erpnext/erpnext/accounts/party.py +317',b'Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s)',b'Opomba: Zaradi / Referen\xc4\x8dni datum presega dovoljene kreditnih stranka dni s {0} dan (s)'
+b'apps/erpnext/erpnext/education/doctype/program/program.js +8',b'Student Applicant',b'\xc5\xa1tudent Prijavitelj'
+b'DocType: Purchase Invoice',b'ORIGINAL FOR RECIPIENT',b'ORIGINAL ZA PREJEMNIKA'
+b'DocType: Asset Category Account',b'Accumulated Depreciation Account',b'Bilan\xc4\x8dni Amortizacija ra\xc4\x8dun'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11',b'This email is autogenerated',b'To e-po\xc5\xa1tno sporo\xc4\x8dilo je samodejno generirano'
+b'DocType: Stock Settings',b'Freeze Stock Entries',b'Freeze Stock Vnosi'
+b'DocType: Program Enrollment',b'Boarding Student',b'Boarding \xc5\xa0tudent'
+b'DocType: Asset',b'Expected Value After Useful Life',b'Pri\xc4\x8dakovana vrednost Po Koristne \xc5\xbeivljenja'
+b'DocType: Item',b'Reorder level based on Warehouse',b'Raven Preureditev temelji na Warehouse'
+b'DocType: Activity Cost',b'Billing Rate',b'Zara\xc4\x8dunavanje Rate'
+,b'Qty to Deliver',b'Koli\xc4\x8dina na Deliver'
+,b'Stock Analytics',b'Analiza zaloge'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +523',b'Operations cannot be left blank',b'Operacije se ne sme ostati prazno'
+b'DocType: Maintenance Visit Purpose',b'Against Document Detail No',b'Proti Podrobnosti dokumenta \xc5\xa1t'
+b'apps/erpnext/erpnext/regional/__init__.py +11',b'Deletion is not permitted for country {0}',b'Brisanje ni dovoljeno za dr\xc5\xbeavo {0}'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +110',b'Party Type is mandatory',b'Vrsta Party je obvezen'
+b'DocType: Quality Inspection',b'Outgoing',b'Odhodni'
+b'DocType: Material Request',b'Requested For',b'Zaprosila za'
+b'DocType: Quotation Item',b'Against Doctype',b'Proti DOCTYPE'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +404',b'{0} {1} is cancelled or closed',b'{0} {1} je preklican ali kon\xc4\x8dan'
+b'DocType: Asset',b'Calculate Depreciation',b'Izra\xc4\x8dunajte amortizacijo'
+b'DocType: Delivery Note',b'Track this Delivery Note against any Project',b'Sledi tej dobavnica proti kateri koli projekt'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +35',b'Net Cash from Investing',b'\xc4\x8cisti denarni tok iz nalo\xc5\xbebenja'
+b'DocType: Work Order',b'Work-in-Progress Warehouse',b'Work-in-Progress Warehouse'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111',b'Asset {0} must be submitted',b'Sredstvo {0} je treba predlo\xc5\xbeiti'
+b'DocType: Fee Schedule Program',b'Total Students',b'Skupaj \xc5\xa1tudenti'
+b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56',b'Attendance Record {0} exists against Student {1}',b'\xc5\xa0ivih {0} obstaja proti \xc5\xa0tudent {1}'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354',b'Reference #{0} dated {1}',b'Referen\xc4\x8dna # {0} dne {1}'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164',b'Depreciation Eliminated due to disposal of assets',b'Amortizacija je izpadlo zaradi odprodaje premo\xc5\xbeenja'
+b'DocType: Member',b'Member',b'\xc4\x8clan'
+b'apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15',b'Manage Addresses',b'Upravljanje naslovov'
+b'DocType: Work Order Item',b'Work Order Item',b'Postavka delovnega naloga'
+b'DocType: Pricing Rule',b'Item Code',b'Oznaka'
+b'DocType: Serial No',b'Warranty / AMC Details',b'Garancija / AMC Podrobnosti'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116',b'Select students manually for the Activity based Group',"b'Izberite \xc5\xa1tudentov ro\xc4\x8dno za skupine dejavnosti, ki temelji'"
+b'DocType: Journal Entry',b'User Remark',b'Uporabnik Pripomba'
+b'DocType: Lead',b'Market Segment',b'Tr\xc5\xbeni segment'
+b'DocType: Agriculture Analysis Criteria',b'Agriculture Manager',b'Kmetijski vodja'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +966',b'Paid Amount cannot be greater than total negative outstanding amount {0}',b'Pla\xc4\x8dani znesek ne sme biti ve\xc4\x8dja od celotnega negativnega nepla\xc4\x8danega zneska {0}'
+b'DocType: Supplier Scorecard Period',b'Variables',b'Spremenljivke'
+b'DocType: Employee Internal Work History',b'Employee Internal Work History',b'Zaposleni Notranji Delo Zgodovina'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +249',b'Closing (Dr)',b'Zapiranje (Dr)'
+b'DocType: Cheque Print Template',b'Cheque Size',b'\xc4\x8cek Velikost'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232',b'Serial No {0} not in stock',b'Serijska \xc5\xa1t {0} ni na zalogi'
+b'apps/erpnext/erpnext/config/selling.py +169',b'Tax template for selling transactions.',b'Dav\xc4\x8dna predlogo za prodajne transakcije.'
+b'DocType: Sales Invoice',b'Write Off Outstanding Amount',b'Napi\xc5\xa1ite Off neporavnanega zneska'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27',b'Account {0} does not match with Company {1}',b'Ra\xc4\x8dun {0} ne ujema z dru\xc5\xbebo {1}'
+b'DocType: Education Settings',b'Current Academic Year',b'Trenutni \xc5\xa1tudijsko leto'
+b'DocType: Stock Settings',b'Default Stock UOM',b'Privzeto Stock UOM'
+b'DocType: Asset',b'Number of Depreciations Booked',b'\xc5\xa0tevilo amortizacije Rezervirano'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +71',b'Qty Total',b'Koli\xc4\x8dina skupaj'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32',b'Against Employee Loan: {0}',b'Proti delavcev doba: {0}'
+b'DocType: Landed Cost Item',b'Receipt Document',b'prejem dokumenta'
+b'DocType: Employee Education',b'School/University',b'\xc5\xa0ola / univerza'
+b'DocType: Payment Request',b'Reference Details',b'Referen\xc4\x8dna Podrobnosti'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +56',b'Expected Value After Useful Life must be less than Gross Purchase Amount',b'Pri\xc4\x8dakovana vrednost Po \xc5\xbdivljenjska doba sme biti manj\xc5\xa1a od bruto zneska nakupa'
+b'DocType: Sales Invoice Item',b'Available Qty at Warehouse',b'Na voljo Koli\xc4\x8dina na Warehouse'
+b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20',b'Billed Amount',b'Zara\xc4\x8dunavajo Znesek'
+b'DocType: Share Transfer',b'(including)',b'(vklju\xc4\x8dno)'
+b'DocType: Asset',b'Double Declining Balance',b'Double Upadanje Balance'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180',b'Closed order cannot be cancelled. Unclose to cancel.',b'Zaprta naro\xc4\x8dila ni mogo\xc4\x8de preklicati. Unclose za preklic.'
+b'DocType: Student Guardian',b'Father',b'o\xc4\x8de'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +627',"b""'Update Stock' cannot be checked for fixed asset sale""","b'&quot;Update Stock&quot;, ni mogo\xc4\x8de preveriti za prodajo osnovnih sredstev'"
+b'DocType: Bank Reconciliation',b'Bank Reconciliation',b'Banka Sprava'
+b'DocType: Attendance',b'On Leave',b'Na dopustu'
+b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7',b'Get Updates',b'Dobite posodobitve'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96',b'{0} {1}: Account {2} does not belong to Company {3}',b'{0} {1}: ra\xc4\x8dun {2} ne pripada dru\xc5\xbebi {3}'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +397',b'Select at least one value from each of the attributes.',b'Izberite vsaj eno vrednost iz vsakega od atributov.'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +166',b'Material Request {0} is cancelled or stopped',b'Material Zahteva {0} je odpovedan ali ustavi'
+b'apps/erpnext/erpnext/config/hr.py +314',b'Leave Management',b'Pustite upravljanje'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +118',b'Group by Account',"b'Skupina, ki jo ra\xc4\x8dun'"
+b'apps/erpnext/erpnext/education/doctype/instructor/instructor.py +21',b'Please select Employee',b'Izberite zaposleni'
+b'DocType: Sales Order',b'Fully Delivered',b'Popolnoma Delivered'
+b'DocType: Lead',b'Lower Income',b'Ni\xc5\xbeji od dobi\xc4\x8dka'
+b'DocType: Restaurant Order Entry',b'Current Order',b'Trenutni naro\xc4\x8dilo'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +196',b'Source and target warehouse cannot be same for row {0}',b'Vir in cilj skladi\xc5\xa1\xc4\x8de ne more biti enaka za vrstico {0}'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +243',"b'Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry'","b'Razlika ra\xc4\x8duna mora biti tip Asset / Liability ra\xc4\x8dun, saj je ta Stock Sprava je Entry Otvoritev'"
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107',b'Disbursed Amount cannot be greater than Loan Amount {0}',b'Pla\xc4\x8danega zneska ne sme biti ve\xc4\x8dja od zneska kredita {0}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +176',b'Go to Programs',b'Pojdite v programe'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +205',b'Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2}',"b'Vrstica {0} # Razdeljena koli\xc4\x8dina {1} ne sme biti ve\xc4\x8dja od koli\xc4\x8dine, za katero je vlo\xc5\xbeena zahtevka {2}'"
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89',b'Purchase Order number required for Item {0}',b'Naro\xc4\x8dilnica zahtevanega \xc5\xa1tevila za postavko {0}'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18',"b""'From Date' must be after 'To Date'""","b""'Od datuma' mora biti za 'Do datuma '"""
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39',b'Cannot change status as student {0} is linked with student application {1}',"b'status \xc5\xa1tudenta, ne more spremeniti {0} je povezana z uporabo \xc5\xa1tudentskega {1}'"
+b'DocType: Asset',b'Fully Depreciated',b'celoti amortizirana'
+b'DocType: Item Barcode',b'UPC-A',b'UPC-A'
+,b'Stock Projected Qty',b'Stock Predvidena Koli\xc4\x8dina'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +444',b'Customer {0} does not belong to project {1}',"b'Stranka {0} ne pripada, da projekt {1}'"
+b'DocType: Employee Attendance Tool',b'Marked Attendance HTML',b'Markirana Udele\xc5\xbeba HTML'
+b'apps/erpnext/erpnext/utilities/activation.py +73',"b'Quotations are proposals, bids you have sent to your customers'","b'Citati so predlogi, ponudbe, ki ste jih poslali svojim strankam'"
+b'DocType: Sales Invoice',"b""Customer's Purchase Order""",b'Stranke Naro\xc4\x8dilo'
+b'DocType: Consultation',b'Patient',b'Bolnik'
+b'apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47',b'Bypass credit check at Sales Order ',b'Bypass preverjanje kredita na prodajnem naro\xc4\x8dilu'
+b'DocType: Land Unit',b'Check if it is a hydroponic unit',"b'Preverite, ali gre za hidroponi\xc4\x8dno enoto'"
+b'apps/erpnext/erpnext/config/stock.py +109',b'Serial No and Batch',b'Serijska \xc5\xa1tevilka in serije'
+b'DocType: Warranty Claim',b'From Company',b'Od dru\xc5\xbebe'
+b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +52',b'Sum of Scores of Assessment Criteria needs to be {0}.',b'Vsota ocen ocenjevalnih meril mora biti {0}.'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +77',b'Please set Number of Depreciations Booked',"b'Prosim, nastavite \xc5\xa0tevilo amortizacije Rezervirano'"
+b'DocType: Supplier Scorecard Period',b'Calculations',b'Izra\xc4\x8duni'
+b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +86',b'Value or Qty',b'Vrednost ali Kol'
+b'DocType: Payment Terms Template',b'Payment Terms',b'Pla\xc4\x8dilni pogoji'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +449',b'Productions Orders cannot be raised for:',b'Produkcije Naro\xc4\x8dila ni mogo\xc4\x8de pove\xc4\x8dati za:'
+b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Minute',b'Minute'
+b'DocType: Purchase Invoice',b'Purchase Taxes and Charges',b'Nakup davki in dajatve'
+b'DocType: Chapter',b'Meetup Embed HTML',b'Meetup Vstavi HTML'
+b'apps/erpnext/erpnext/utilities/user_progress.py +121',b'Go to Suppliers',b'Pojdi na dobavitelje'
+,b'Qty to Receive',b'Koli\xc4\x8dina za prejemanje'
+b'DocType: Leave Block List',b'Leave Block List Allowed',b'Pustite Block Seznam Dovoljeno'
+b'DocType: Grading Scale Interval',b'Grading Scale Interval',b'Ocenjevalna lestvica Interval'
+b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49',b'Expense Claim for Vehicle Log {0}',b'Expense Zahtevek za vozila Prijavi {0}'
+b'DocType: Sales Invoice Item',b'Discount (%) on Price List Rate with Margin',b'Popust (%) na Cena iz cenika Oceni z mejo'
+b'DocType: Sales Invoice Item',b'Discount (%) on Price List Rate with Margin',b'Popust (%) na Cena iz cenika Oceni z mejo'
+b'apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59',b'All Warehouses',b'Vse Skladi\xc5\xa1\xc4\x8da'
+b'DocType: Sales Partner',b'Retailer',b'Retailer'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115',b'Credit To account must be a Balance Sheet account',b'Credit Za ra\xc4\x8dunu mora biti bilanca ra\xc4\x8duna'
+b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +118',b'All Supplier Types',b'Vse vrste Dobavitelj'
+b'DocType: Donor',b'Donor',b'Darovalec'
+b'DocType: Global Defaults',b'Disable In Words',"b'Onemogo\xc4\x8di ""z besedami""'"
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +60',b'Item Code is mandatory because Item is not automatically numbered',"b'Oznaka je obvezna, ker se postavka samodejno ni o\xc5\xa1tevil\xc4\x8den'"
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98',b'Quotation {0} not of type {1}',b'Ponudba {0} ni tipa {1}'
+b'DocType: Maintenance Schedule Item',b'Maintenance Schedule Item',b'Vzdr\xc5\xbeevanje Urnik Postavka'
+b'DocType: Sales Order',b'%  Delivered',b'% Dostavljeno'
+b'apps/erpnext/erpnext/education/doctype/fees/fees.js +105',b'Please set the Email ID for the Student to send the Payment Request',"b'Prosimo, nastavite e-po\xc5\xa1tni ID za \xc5\xa1tudenta, da po\xc5\xa1ljete zahtevek za pla\xc4\x8dilo'"
+b'DocType: Patient',b'Medical History',b'Zdravstvena zgodovina'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157',b'Bank Overdraft Account',b'Ban\xc4\x8dnem ra\xc4\x8dunu ra\xc4\x8duna'
+b'DocType: Patient',b'Patient ID',b'ID bolnika'
+b'DocType: Physician Schedule',b'Schedule Name',b'Ime seznama'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48',b'Make Salary Slip',b'Naredite pla\xc4\x8dilnega lista'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +840',b'Add All Suppliers',b'Dodaj vse dobavitelje'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +94',b'Row #{0}: Allocated Amount cannot be greater than outstanding amount.',b'Vrstica # {0}: Razporejeni vrednosti ne sme biti ve\xc4\x8dja od nepla\xc4\x8danega zneska.'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75',b'Browse BOM',b'Prebrskaj BOM'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155',b'Secured Loans',b'Secured Posojila'
+b'DocType: Purchase Invoice',b'Edit Posting Date and Time',b'Uredi datum in uro vnosa'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101',b'Please set Depreciation related Accounts in Asset Category {0} or Company {1}',"b'Prosim, nastavite ra\xc4\x8dune, povezane Amortizacija v sredstvih kategoriji {0} ali dru\xc5\xbebe {1}'"
+b'DocType: Lab Test Groups',b'Normal Range',b'Normalni obseg'
+b'DocType: Academic Term',b'Academic Year',b'\xc5\xa0tudijsko leto'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72',b'Available Selling',b'Razpolo\xc5\xbeljiva prodaja'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169',b'Opening Balance Equity',b'Otvoritev Balance Equity'
+b'DocType: Lead',b'CRM',b'CRM'
+b'DocType: Purchase Invoice',b'N',b'N'
+b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175',b'Remaining',b'preostala'
+b'DocType: Appraisal',b'Appraisal',b'Cenitev'
+b'DocType: Purchase Invoice',b'GST Details',b'Podrobnosti o GST'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +156',b'Email sent to supplier {0}',b'E-po\xc5\xa1ta poslana dobavitelju {0}'
+b'DocType: Item',b'Default Sales Unit of Measure',b'Privzeta prodajna enota ukrepa'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9',b'Academic Year: ',b'\xc5\xa0tudijsko leto:'
+b'DocType: Opportunity',b'OPTY-',b'OPTY-'
+b'apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19',b'Date is repeated',b'Datum se ponovi'
+b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27',b'Authorized Signatory',b'Poobla\xc5\xa1\xc4\x8deni podpisnik'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +64',b'Create Fees',b'Ustvari pristojbine'
+b'DocType: Project',b'Total Purchase Cost (via Purchase Invoice)',b'Skupaj Nakup Cost (via ra\xc4\x8dunu o nakupu)'
+b'DocType: Training Event',b'Start Time',b'Za\xc4\x8detni \xc4\x8das'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +400',b'Select Quantity',b'Izberite Koli\xc4\x8dina'
+b'DocType: Customs Tariff Number',b'Customs Tariff Number',b'Carinska tarifa \xc5\xa1tevilka'
+b'DocType: Patient Appointment',b'Patient Appointment',b'Imenovanje pacienta'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34',b'Approving Role cannot be same as role the rule is Applicable To',"b'Odobritvi vloge ne more biti enaka kot vloga je pravilo, ki veljajo za'"
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +64',b'Unsubscribe from this Email Digest',b'Odjaviti iz te Email Digest'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +830',b'Get Suppliers By',b'Pridobite dobavitelje po'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +173',b'{0} not found for Item {1}',b'{0} ni najden za postavko {1}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +197',b'Go to Courses',b'Pojdi na predmete'
+b'DocType: Accounts Settings',b'Show Inclusive Tax In Print',b'Prika\xc5\xbei inkluzivni davek v tisku'
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +17',"b'Bank Account, From Date and To Date are Mandatory'","b'Ban\xc4\x8dni ra\xc4\x8dun, od datuma do datuma je obvezen'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28',b'Message Sent',b'Sporo\xc4\x8dilo je bilo poslano'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +98',b'Account with child nodes cannot be set as ledger',b'Ra\xc4\x8dun z zapirali vozli\xc5\xa1\xc4\x8d ni mogo\xc4\x8de nastaviti kot knjigo'
+b'DocType: C-Form',b'II',b'II'
+b'DocType: Sales Invoice',"b""Rate at which Price list currency is converted to customer's base currency""","b'Obrestna mera, po kateri Cenik valuti se pretvorijo v osn stranke'"
+b'DocType: Purchase Invoice Item',b'Net Amount (Company Currency)',b'Neto znesek (dru\xc5\xbeba Valuta)'
+b'DocType: Physician',b'Physician Schedules',b'Urnik zdravnikov'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +215',b'Total advance amount cannot be greater than total sanctioned amount',b'Skupni znesek predpla\xc4\x8dila ne more biti ve\xc4\x8dji od skupnega sankcioniranega zneska'
+b'DocType: Salary Slip',b'Hour Rate',b'Urna postavka'
+b'DocType: Stock Settings',b'Item Naming By',b'Postavka Poimenovanje S'
+b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46',b'Another Period Closing Entry {0} has been made after {1}',b'Drug zaklju\xc4\x8dnem obdobju Za\xc4\x8detek {0} je bil dose\xc5\xbeen po {1}'
+b'DocType: Work Order',b'Material Transferred for Manufacturing',b'Material Preneseno za Manufacturing'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +41',b'Account {0} does not exists',b'Ra\xc4\x8dun {0} ne obstaja'
+b'DocType: Project',b'Project Type',b'Projekt Type'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +153',b'Child Task exists for this Task. You can not delete this Task.',b'Otro\xc5\xa1ka naloga obstaja za to nalogo. Te naloge ne morete izbrisati.'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48',b'DateLet',b'DateLet'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16',b'Either target qty or target amount is mandatory.',b'Bodisi ciljna kol ali ciljna vrednost je obvezna.'
+b'apps/erpnext/erpnext/config/projects.py +56',b'Cost of various activities',b'Stro\xc5\xa1ke razli\xc4\x8dnih dejavnosti'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60',"b'Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}'","b'Nastavitev dogodkov na {0}, saj je zaposlenih pritrjen na spodnji prodaje oseb nima uporabni\xc5\xa1ko {1}'"
+b'DocType: Timesheet',b'Billing Details',b'Podrobnosti o obra\xc4\x8dunavanju'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +163',b'Source and target warehouse must be different',b'Vir in cilj skladi\xc5\xa1\xc4\x8de mora biti druga\xc4\x8den'
+b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +140',b'Payment Failed. Please check your GoCardless Account for more details',b'Pla\xc4\x8dilo ni uspelo. Preverite svoj GoCardless ra\xc4\x8dun za ve\xc4\x8d podrobnosti'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101',b'Not allowed to update stock transactions older than {0}',"b'Ni dovoljeno, da posodobite transakcije zalog starej\xc5\xa1i od {0}'"
+b'DocType: BOM',b'Inspection Required',b'In\xc5\xa1pekcijski Zahtevano'
+b'DocType: Purchase Invoice Item',b'PR Detail',b'PR Detail'
+b'DocType: Driving License Category',b'Class',b'Razred'
+b'DocType: Sales Order',b'Fully Billed',b'Popolnoma zara\xc4\x8dunavajo'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +426',b'Work Order cannot be raised against a Item Template',b'Delovnega reda ni mogo\xc4\x8de dvigniti glede na predlogo postavke'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101',b'Shipping rule only applicable for Buying',b'Pravilo o dostavi velja samo za nakup'
+b'DocType: Vital Signs',b'BMI',b'ITM'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20',b'Cash In Hand',b'Denarna sredstva v blagajni'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137',b'Delivery warehouse required for stock item {0}',b'Dostava skladi\xc5\xa1\xc4\x8de potreben za postavko parka {0}'
+b'DocType: Packing Slip',b'The gross weight of the package. Usually net weight + packaging material weight. (for print)',b'Bruto te\xc5\xbea paketa. Ponavadi neto te\xc5\xbea + embala\xc5\xbea te\xc5\xbee. (za tisk)'
+b'DocType: Assessment Plan',b'Program',b'Program'
+b'DocType: Accounts Settings',b'Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts',b'Uporabniki s to vlogo dovoljeno postaviti na zamrznjene ra\xc4\x8dune in ustvariti / spreminjanje vknji\xc5\xbebe zoper zamrznjenih ra\xc4\x8dunih'
+b'DocType: Serial No',b'Is Cancelled',b'Je Preklicana'
+b'DocType: Student Group',b'Group Based On',"b'Skupina, ki temelji na'"
+b'DocType: Journal Entry',b'Bill Date',b'Bill Datum'
+b'DocType: Healthcare Settings',b'Laboratory SMS Alerts',b'Laboratorijske opozorila SMS'
+b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20',"b'Service Item,Type,frequency and expense amount are required'","b'morajo Service Element, tip, pogostost in odhodki znesek'"
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45',"b'Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:'","b'Tudi \xc4\x8de obstaja ve\xc4\x8d cenovnih Pravila z najvi\xc5\xa1jo prioriteto, se uporabljajo nato naslednji notranje prednostne naloge:'"
+b'DocType: Plant Analysis Criteria',b'Plant Analysis Criteria',b'Kriteriji za analizo rastlin'
+b'DocType: Cheque Print Template',b'Cheque Height',b'\xc4\x8cek Vi\xc5\xa1ina'
+b'DocType: Supplier',b'Supplier Details',b'Dobavitelj Podrobnosti'
+b'DocType: Setup Progress',b'Setup Progress',b'Napredek nastavitve'
+b'DocType: Hub Settings',b'Publish Items to Hub',b'Objavite artikel v Hub'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35',b'From value must be less than to value in row {0}',b'Iz mora biti vrednost manj kot na vrednosti v vrstici {0}'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182',b'Wire Transfer',b'Wire Transfer'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92',b'Check all',b'Preveri vse'
+,b'Issued Items Against Work Order',b'Izdane predmete proti delovnemu nalogu'
+b'DocType: Vehicle Log',b'Invoice Ref',b'Ref na ra\xc4\x8dunu'
+b'DocType: Company',b'Default Income Account',b'Privzeto Prihodki ra\xc4\x8dun'
+b'apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32',b'Customer Group / Customer',b'Skupina kupec / stranka'
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37',b'Unclosed Fiscal Years Profit / Loss (Credit)',b'Nezaprt prora\xc4\x8dunskih let dobi\xc4\x8dek / izguba (Credit)'
+b'DocType: Sales Invoice',b'Time Sheets',b'\xc4\x8das listi'
+b'DocType: Lab Test Template',b'Change In Item',b'Spremeni v postavki'
+b'DocType: Payment Gateway Account',b'Default Payment Request Message',b'Privzeto Sporo\xc4\x8dilo Pla\xc4\x8dilnega Naloga'
+b'DocType: Item Group',b'Check this if you want to show in website',"b'Ozna\xc4\x8dite to, \xc4\x8de \xc5\xbeelite, da ka\xc5\xbeejo na spletni strani'"
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +338',b'Balance ({0})',b'Stanje ({0})'
+b'apps/erpnext/erpnext/config/accounts.py +134',b'Banking and Payments',b'Ban\xc4\x8dni\xc5\xa1tvo in pla\xc4\x8dila'
+,b'Welcome to ERPNext',b'Dobrodo\xc5\xa1li na ERPNext'
+b'apps/erpnext/erpnext/config/learn.py +102',b'Lead to Quotation',b'Privede do Kotacija'
+b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +34',b'Email Reminders will be sent to all parties with email contacts',b'E-po\xc5\xa1ta Opomniki bodo poslani vsem strankam z e-po\xc5\xa1tnimi stiki'
+b'DocType: Project',b'Twice Daily',b'Dvakrat dnevno'
+b'DocType: Patient',b'A Negative',b'Negativno'
+b'apps/erpnext/erpnext/templates/includes/product_list.js +45',b'Nothing more to show.',b'Ni\xc4\x8d ve\xc4\x8d pokazati.'
+b'DocType: Lead',b'From Customer',b'Od kupca'
+b'apps/erpnext/erpnext/demo/setup/setup_data.py +327',b'Calls',b'Poziva'
+b'apps/erpnext/erpnext/utilities/user_progress.py +143',b'A Product',b'Izdelek'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207',b'Batches',b'Paketi'
+b'apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34',b'Make Fee Schedule',b'Naro\xc4\x8dite \xc4\x8dasovni razpored'
+b'DocType: Purchase Order Item Supplied',b'Stock UOM',b'Stock UOM'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233',b'Purchase Order {0} is not submitted',b'Naro\xc4\x8dilnica {0} ni predlo\xc5\xbeila'
+b'DocType: Vital Signs',b'Normal reference range for an adult is 16\xe2\x80\x9320 breaths/minute (RCP 2012)',b'Normalno referen\xc4\x8dno obmo\xc4\x8dje za odraslo osebo je 16-20 vdihov / minut (RCP 2012)'
+b'DocType: Customs Tariff Number',b'Tariff Number',b'tarifna \xc5\xa1tevilka'
+b'DocType: Work Order Item',b'Available Qty at WIP Warehouse',b'Na voljo Koli\xc4\x8dina na WIP Warehouse'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +39',b'Projected',b'Predvidoma'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222',b'Serial No {0} does not belong to Warehouse {1}',b'Serijska \xc5\xa1t {0} ne pripada Warehouse {1}'
+b'apps/erpnext/erpnext/controllers/status_updater.py +177',b'Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0',b'Opomba: Sistem ne bo preveril \xc4\x8dez povzetju in over-rezervacije za postavko {0} kot koli\xc4\x8dina ali znesek je 0'
+b'DocType: Notification Control',b'Quotation Message',b'Kotacija Sporo\xc4\x8dilo'
+b'DocType: Employee Loan',b'Employee Loan Application',b'Zaposlenih Loan Application'
+b'DocType: Issue',b'Opening Date',b'Otvoritev Datum'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +86',b'Please save the patient first',b'Najprej shranite bolnika'
+b'apps/erpnext/erpnext/education/api.py +80',b'Attendance has been marked successfully.',b'Udele\xc5\xbeba je bila uspe\xc5\xa1no ozna\xc4\x8dena.'
+b'DocType: Program Enrollment',b'Public Transport',b'Javni prevoz'
+b'DocType: Soil Texture',b'Silt Composition (%)',b'Siltova sestava (%)'
+b'DocType: Journal Entry',b'Remark',b'Pripomba'
+b'DocType: Healthcare Settings',b'Avoid Confirmation',b'Izogibajte se potrditvi'
+b'DocType: Purchase Receipt Item',b'Rate and Amount',b'Stopnja in znesek'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +176',b'Account Type for {0} must be {1}',b'Vrsta ra\xc4\x8duna za {0} mora biti {1}'
+b'DocType: Healthcare Settings',b'Default income accounts to be used if not set in Physician to book Consultation charges.',"b'Ra\xc4\x8dunov nepla\xc4\x8dil, ki jih je treba uporabiti, \xc4\x8de jih zdravnik ni dolo\xc4\x8dil za knji\xc5\xbeenje stro\xc5\xa1kov posvetovanja.'"
+b'apps/erpnext/erpnext/config/hr.py +55',b'Leaves and Holiday',b'Listi in Holiday'
+b'DocType: Education Settings',b'Current Academic Term',b'Trenutni Academic Term'
+b'DocType: Education Settings',b'Current Academic Term',b'Trenutni Academic Term'
+b'DocType: Sales Order',b'Not Billed',b'Ne zara\xc4\x8dunavajo'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +76',b'Both Warehouse must belong to same Company',b'Oba Skladi\xc5\xa1\xc4\x8de mora pripadati isti dru\xc5\xbebi'
+b'apps/erpnext/erpnext/public/js/templates/contact_list.html +34',b'No contacts added yet.',b'Ni stikov \xc5\xa1e dodal.'
+b'DocType: Purchase Invoice Item',b'Landed Cost Voucher Amount',b'Pristali Stro\xc5\xa1ki bon Znesek'
+,b'Item Balance (Simple)',b'Postavka Balance (Enostavno)'
+b'apps/erpnext/erpnext/config/accounts.py +17',b'Bills raised by Suppliers.',"b'Ra\xc4\x8duni, ki jih dobavitelji postavljeno.'"
+b'DocType: POS Profile',b'Write Off Account',b'Odpi\xc5\xa1ite ra\xc4\x8dun'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215',b'Debit Note Amt',b'Opomin Amt'
+b'apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5',b'Discount Amount',b'Popust Koli\xc4\x8dina'
+b'DocType: Purchase Invoice',b'Return Against Purchase Invoice',b'Vrni proti Ra\xc4\x8dun za nakup'
+b'DocType: Item',b'Warranty Period (in days)',b'Garancijski rok (v dnevih)'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61',b'Failed to set defaults',b'Nastavitev privzetih nastavitev ni uspela'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56',b'Relation with Guardian1',b'Povezava z Guardian1'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +786',b'Please select BOM against item {0}',"b'Prosimo, izberite BOM proti elementu {0}'"
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18',b'Make Invoices',b'Izdelava ra\xc4\x8dunov'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23',b'Net Cash from Operations',b'\xc4\x8cisti denarni tok iz poslovanja'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26',b'Item 4',b'Postavka 4'
+b'DocType: Student Admission',b'Admission End Date',b'Sprejem Kon\xc4\x8dni datum'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30',b'Sub-contracting',b'Podizvajalcem'
+b'DocType: Journal Entry Account',b'Journal Entry Account',b'Journal Entry ra\xc4\x8dun'
+b'apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3',b'Student Group',b'\xc5\xa0tudentska skupina'
+b'DocType: Shopping Cart Settings',b'Quotation Series',b'Zaporedje ponudb'
+b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +57',"b'An item exists with same name ({0}), please change the item group name or rename the item'","b'Element obstaja z istim imenom ({0}), prosimo, spremenite ime postavka skupine ali preimenovanje postavke'"
+b'DocType: Soil Analysis Criteria',b'Soil Analysis Criteria',b'Kriteriji za analizo tal'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2041',b'Please select customer',b'Izberite stranko'
+b'DocType: C-Form',b'I',b'jaz'
+b'DocType: Company',b'Asset Depreciation Cost Center',b'Asset Center Amortizacija Stro\xc5\xa1ki'
+b'DocType: Production Plan Sales Order',b'Sales Order Date',b'Datum Naro\xc4\x8dila Kupca'
+b'DocType: Sales Invoice Item',b'Delivered Qty',b'Delivered Kol'
+b'DocType: Assessment Plan',b'Assessment Plan',b'na\xc4\x8drt ocenjevanja'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90',b'Customer {0} is created.',b'Stranka {0} je ustvarjena.'
+b'DocType: Stock Settings',b'Limit Percent',b'omejitev Odstotek'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82',b' Currently no stock available in any warehouse',b'Trenutno ni na zalogi'
+,b'Payment Period Based On Invoice Date',b'Pla\xc4\x8dilo obdobju na podlagi ra\xc4\x8duna Datum'
+b'DocType: Sample Collection',b'No. of print',b'\xc5\xa0t. Tiskanja'
+b'DocType: Hotel Room Reservation Item',b'Hotel Room Reservation Item',b'Rezervacija za hotelsko sobo'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58',b'Missing Currency Exchange Rates for {0}',b'Manjka Menjalni te\xc4\x8daji za {0}'
+b'DocType: Health Insurance',b'Health Insurance Name',b'Ime zdravstvenega zavarovanja'
+b'DocType: Assessment Plan',b'Examiner',b'Examiner'
+b'DocType: Student',b'Siblings',b'Bratje in sestre'
+b'DocType: Journal Entry',b'Stock Entry',b'Stock Za\xc4\x8detek'
+b'DocType: Payment Entry',b'Payment References',b'Pla\xc4\x8dilni Reference'
+b'DocType: C-Form',b'C-FORM-',b'C-FORM-'
+b'DocType: Vehicle',b'Insurance Details',b'zavarovanje Podrobnosti'
+b'DocType: Account',b'Payable',b'Pla\xc4\x8dljivo'
+b'DocType: Share Balance',b'Share Type',b'Vrsta delnice'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113',b'Please enter Repayment Periods',b'Vnesite roki odpla\xc4\x8devanja'
+b'apps/erpnext/erpnext/shopping_cart/cart.py +378',b'Debtors ({0})',b'Dol\xc5\xbeniki ({0})'
+b'DocType: Pricing Rule',b'Margin',b'Margin'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57',b'New Customers',b'Nove stranke'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74',b'Gross Profit %',b'Bruto dobi\xc4\x8dek %'
+b'DocType: Appraisal Goal',b'Weightage (%)',b'Weightage (%)'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +503',b'Change POS Profile',b'Spremenite profil POS'
+b'DocType: Bank Reconciliation Detail',b'Clearance Date',b'Potrditev Datum'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7',b'Assessment Report',b'Ocenjevalno poro\xc4\x8dilo'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +59',b'Gross Purchase Amount is mandatory',b'Bruto znesek nakupa je obvezna'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +95',b'Company name not same',b'Ime podjetja ni isto'
+b'DocType: Lead',b'Address Desc',b'Naslov opis izdelka'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +113',b'Party is mandatory',b'Party je obvezen'
+b'DocType: Journal Entry',b'JV-',b'JV-'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +712',b'Rows with duplicate due dates in other rows were found: {list}',b'Vrstice s podvojenimi datumi v drugih vrsticah so bile najdene: {list}'
+b'DocType: Topic',b'Topic Name',b'Ime temo'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37',b'Atleast one of the Selling or Buying must be selected',b'Mora biti izbran Atleast eden prodaji ali nakupu'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +290',b'Select an employee to get the employee advance.',"b'Izberite zaposlenega, da zaposleni vnaprej napreduje.'"
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56',b'Please select a valid Date',b'Izberite veljaven datum'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +36',b'Select the nature of your business.',b'Izberite naravo va\xc5\xa1ega podjetja.'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +24',b'Please setup Employee Naming System in Human Resource &gt; HR Settings',"b'Prosimo, nastavite sistem imenovanja zaposlenih v kadrovskem na\xc4\x8drtu&gt; HR Settings'"
+b'DocType: Lab Test Template',"b'Single for results which require only a single input, result UOM and normal value \n<br>\nCompound for results which require multiple input fields with corresponding event names, result UOMs and normal values\n<br>\nDescriptive for tests which have multiple result components and corresponding result entry fields. \n<br>\nGrouped for test templates which are a group of other test templates.\n<br>\nNo Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.'","b'Single za rezultate, ki zahtevajo le en vhod, rezultat UOM in normalno vrednost <br> Sestavina za rezultate, ki zahtevajo ve\xc4\x8d vhodnih polj z ustreznimi imeni dogodkov, rezultati UOM in normalne vrednosti <br> Opisno za teste, ki imajo ve\xc4\x8d sestavin rezultatov in ustrezna polja vnosa rezultatov. <br> Zdru\xc5\xbeene za preskusne predloge, ki so skupina drugih preskusnih predlog. <br> Brez rezultata za preskuse brez rezultatov. Prav tako ni ustvarjen laboratorijski test. npr. Sub testi za skupinske rezultate.'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +86',b'Row #{0}: Duplicate entry in References {1} {2}',b'Vrstica # {0}: Duplikat vnos v Referen\xc4\x8dni {1} {2}'
+b'apps/erpnext/erpnext/config/manufacturing.py +57',b'Where manufacturing operations are carried.',b'Kjer so proizvodni postopki.'
+b'apps/erpnext/erpnext/education/doctype/instructor/instructor.js +18',b'As Examiner',b'Kot preizku\xc5\xa1evalec'
+b'DocType: Appointment Type',b'Default Duration',b'Privzeto trajanje'
+b'DocType: Asset Movement',b'Source Warehouse',b'Vir Skladi\xc5\xa1\xc4\x8de'
+b'DocType: Installation Note',b'Installation Date',b'Datum vgradnje'
+b'apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js +30',b'Share Ledger',b'Dele\xc5\xbe knjige'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +606',b'Row #{0}: Asset {1} does not belong to company {2}',b'Row # {0}: Asset {1} ne pripada dru\xc5\xbebi {2}'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206',b'Sales Invoice {0} created',b'Ustvarjen je ra\xc4\x8dun za prodajo {0}'
+b'DocType: Employee',b'Confirmation Date',b'Datum potrditve'
+b'DocType: C-Form',b'Total Invoiced Amount',b'Skupaj Obra\xc4\x8dunani znesek'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +50',b'Min Qty can not be greater than Max Qty',b'Min Koli\xc4\x8dina ne sme biti ve\xc4\x8dja od Max Kol'
+b'DocType: Soil Texture',b'Silty Clay',b'Silty Clay'
+b'DocType: Account',b'Accumulated Depreciation',b'Bilan\xc4\x8dni Amortizacija'
+b'DocType: Supplier Scorecard Scoring Standing',b'Standing Name',b'Stalno ime'
+b'DocType: Stock Entry',b'Customer or Supplier Details',b'Stranka ali dobavitelj Podrobnosti'
+b'DocType: Employee Loan Application',b'Required by Date',b'Zahtevana Datum'
+b'DocType: Lead',b'Lead Owner',b'Lastnik ponudbe'
+b'DocType: Production Plan',b'Sales Orders Detail',b'Prodajna naro\xc4\x8dila Podrobnosti'
+b'DocType: Bin',b'Requested Quantity',b'Zahtevana koli\xc4\x8dina'
+b'DocType: Patient',b'Marital Status',b'Zakonski stan'
+b'DocType: Stock Settings',b'Auto Material Request',b'Auto Material Zahteva'
+b'DocType: Delivery Note Item',b'Available Batch Qty at From Warehouse',b'Dostopno Serija Koli\xc4\x8dina na IZ SKLADI\xc5\xa0\xc4\x8cA'
+b'DocType: Customer',b'CUST-',b'CUST-'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50',b'Idevise',b'Idevise'
+b'DocType: Salary Slip',b'Gross Pay - Total Deduction - Loan Repayment',b'Bruto pla\xc4\x8da - Skupaj Odbitek - Posojilo Povra\xc4\x8dilo'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +29',b'Current BOM and New BOM can not be same',b'Trenutni BOM in New BOM ne more biti enaka'
+b'apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +47',b'Salary Slip ID',b'Pla\xc4\x8da Slip ID'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +118',b'Date Of Retirement must be greater than Date of Joining',b'Datum upokojitve mora biti ve\xc4\x8dji od datuma pridru\xc5\xbeitve'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +68',b'Multiple Variants',b'Ve\xc4\x8dkratne razli\xc4\x8dice'
+b'DocType: Sales Invoice',b'Against Income Account',b'Proti dohodkov'
+b'apps/erpnext/erpnext/controllers/website_list_for_contact.py +117',b'{0}% Delivered',b'{0}% Dostavljeno'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +107',b'Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).',b'Postavka {0}: \xc5\xbd Kol {1} ne more biti ni\xc5\xbeja od minimalne naro\xc4\x8dila Kol {2} (opredeljeno v to\xc4\x8dki).'
+b'DocType: Monthly Distribution Percentage',b'Monthly Distribution Percentage',b'Mese\xc4\x8dni Distribution Odstotek'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +49',b'Please login as another user.',b'Prijavite se kot drugi uporabnik.'
+b'DocType: Daily Work Summary Group User',b'Daily Work Summary Group User',b'Uporabnik dnevnega dela Povzetek dela'
+b'DocType: Territory',b'Territory Targets',b'Territory cilji'
+b'DocType: Soil Analysis',b'Ca/Mg',b'Ca / Mg'
+b'DocType: Delivery Note',b'Transporter Info',b'Transporter Info'
+b'apps/erpnext/erpnext/accounts/utils.py +502',b'Please set default {0} in Company {1}',"b'Prosim, nastavite privzeto {0} v dru\xc5\xbebi {1}'"
+b'DocType: Cheque Print Template',b'Starting position from top edge',b'Za\xc4\x8detni polo\xc5\xbeaj od zgornjega roba'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +33',b'Same supplier has been entered multiple times',b'Enako dobavitelj je bila vpisana ve\xc4\x8dkrat'
+b'apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152',b'Gross Profit / Loss',b'Kosmati dobi\xc4\x8dek / izguba'
+,b'Warehouse wise Item Balance Age and Value',b'Skladi\xc5\xa1\xc4\x8dno pametno Postavka Balansna doba in vrednost'
+b'DocType: Purchase Order Item Supplied',b'Purchase Order Item Supplied',b'Nakup Sklep Postavka Prilo\xc5\xbeena'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +94',b'Company Name cannot be Company',b'Ime podjetja ne more biti podjetje'
+b'apps/erpnext/erpnext/config/setup.py +27',b'Letter Heads for print templates.',b'Letter Glave za tiskane predloge.'
+b'apps/erpnext/erpnext/config/setup.py +32',b'Titles for print templates e.g. Proforma Invoice.',"b'Naslovi za tiskane predloge, npr predra\xc4\x8dunu.'"
+b'DocType: Program Enrollment',b'Walking',b'Hoditi'
+b'DocType: Student Guardian',b'Student Guardian',b'\xc5\xa1tudent Guardian'
+b'DocType: Member',b'Member Name',b'Ime \xc4\x8dlana'
+b'DocType: Stock Settings',b'Use Naming Series',b'Uporabite Naming Series'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218',b'Valuation type charges can not marked as Inclusive',b'Stro\xc5\xa1ki Tip vrednotenje ni mogo\xc4\x8de ozna\xc4\x8diti kot Inclusive'
+b'DocType: POS Profile',b'Update Stock',b'Posodobi zalogo'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10',b'in the subscription',b'v naro\xc4\x8dnini'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100',b'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.',"b'Druga\xc4\x8dna UOM za artikle bo privedlo do napa\xc4\x8dne (skupno) Neto te\xc5\xbea vrednosti. Prepri\xc4\x8dajte se, da je neto te\xc5\xbea vsake postavke v istem UOM.'"
+b'DocType: Membership',b'Payment Details',b'Podatki o pla\xc4\x8dilu'
+b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39',b'BOM Rate',b'BOM Rate'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +225',"b'Stopped Work Order cannot be cancelled, Unstop it first to cancel'","b'Prenehanja delovnega naro\xc4\x8dila ni mogo\xc4\x8de preklicati, jo najprej izklju\xc4\x8dite'"
+b'DocType: Asset',b'Journal Entry for Scrap',b'Journal Entry za pretep'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83',b'Please pull items from Delivery Note',b'Prosimo povlecite predmete iz dobavnice'
+b'apps/erpnext/erpnext/accounts/utils.py +472',b'Journal Entries {0} are un-linked',b'Revija Vnosi {0} so un-povezani'
+b'apps/erpnext/erpnext/config/crm.py +92',"b'Record of all communications of type email, phone, chat, visit, etc.'","b'Evidenca vseh komunikacij tipa elektronski po\xc5\xa1ti, telefonu, klepet, obisk, itd'"
+b'DocType: Supplier Scorecard Scoring Standing',b'Supplier Scorecard Scoring Standing',b'Ocenjevalno ocenjevalno to\xc4\x8dko dobavitelja'
+b'DocType: Manufacturer',b'Manufacturers used in Items',"b'Proizvajalci, ki se uporabljajo v postavkah'"
+b'apps/erpnext/erpnext/accounts/general_ledger.py +170',b'Please mention Round Off Cost Center in Company',b'Navedite zaokro\xc5\xbeijo stro\xc5\xa1kovno mesto v dru\xc5\xbebi'
+b'DocType: Purchase Invoice',b'Terms',b'Pogoji'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +10',b'Select Days',b'Izberite Dnevi'
+b'DocType: Academic Term',b'Term Name',b'izraz Ime'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +332',b'Credit ({0})',b'Kredit ({0})'
+b'DocType: Buying Settings',b'Purchase Order Required',b'Naro\xc4\x8dilnica obvezno'
+,b'Item-wise Sales History',b'Element-pametno Sales Zgodovina'
+b'DocType: Expense Claim',b'Total Sanctioned Amount',b'Skupaj sankcionirano Znesek'
+b'DocType: Land Unit',b'Land Unit',b'Land enota'
+,b'Purchase Analytics',b'Odkupne Analytics'
+b'DocType: Sales Invoice Item',b'Delivery Note Item',b'Dostava Opomba Postavka'
+b'DocType: Asset Maintenance Log',b'Task',b'Naloga'
+b'DocType: Purchase Taxes and Charges',b'Reference Row #',b'Referen\xc4\x8dna Row #'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76',b'Batch number is mandatory for Item {0}',b'Serijska \xc5\xa1tevilka je obvezna za postavko {0}'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13',b'This is a root sales person and cannot be edited.',b'To je koren prodaje oseba in jih ni mogo\xc4\x8de urejati.'
+b'DocType: Salary Detail',"b""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. ""","b'\xc4\x8ce je izbrana, je vrednost navedena ali izra\xc4\x8dunana pri tem delu ne bo prispevalo k zaslu\xc5\xbeka ali odbitkov. Kljub temu, da je vrednost se lahko sklicujejo na druge sestavne dele, ki se lahko dodajo ali odbitih.'"
+b'DocType: Salary Detail',"b""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. ""","b'\xc4\x8ce je izbrana, je vrednost navedena ali izra\xc4\x8dunana pri tem delu ne bo prispevalo k zaslu\xc5\xbeka ali odbitkov. Kljub temu, da je vrednost se lahko sklicujejo na druge sestavne dele, ki se lahko dodajo ali odbitih.'"
+b'DocType: Asset Settings',b'Number of Days in Fiscal Year',b'\xc5\xa0tevilo dni v poslovnem letu'
+,b'Stock Ledger',b'Stock Ledger'
+b'apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29',b'Rate: {0}',b'Stopnja: {0}'
+b'DocType: Company',b'Exchange Gain / Loss Account',b'Exchange Gain / izida'
+b'apps/erpnext/erpnext/config/hr.py +7',b'Employee and Attendance',b'Zaposlenih in postre\xc5\xbebo'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +93',b'Purpose must be one of {0}',b'Cilj mora biti eden od {0}'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +100',b'Fill the form and save it',b'Izpolnite obrazec in ga shranite'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26',b'Community Forum',b'Forum Skupnost'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52',b'Actual qty in stock',b'Dejanska kol v zalogi'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52',b'Actual qty in stock',b'Dejanska kol v zalogi'
+b'DocType: Homepage',"b'URL for ""All Products""'",b'URL za \xc2\xbbVsi izdelki\xc2\xab'
+b'DocType: Leave Application',b'Leave Balance Before Application',b'Pustite Stanje pred uporabo'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +46',b'Send SMS',b'Po\xc5\xa1lji SMS'
+b'DocType: Supplier Scorecard Criteria',b'Max Score',b'Najvi\xc5\xa1ji rezultat'
+b'DocType: Cheque Print Template',b'Width of amount in word',b'\xc5\xa0irina zneska z besedo'
+b'DocType: Company',b'Default Letter Head',b'Privzeta glava pisma'
+b'DocType: Purchase Order',b'Get Items from Open Material Requests',b'Dobili predmetov iz Odpri Material Pro\xc5\xa1nje'
+b'DocType: Hotel Room Amenity',b'Billable',b'Pla\xc4\x8dljivo'
+b'DocType: Lab Test Template',b'Standard Selling Rate',b'Standardni Prodajni te\xc4\x8daj'
+b'DocType: Account',b'Rate at which this tax is applied',"b'Hitrost, s katero se ta davek'"
+b'DocType: Cash Flow Mapper',b'Section Name',b'Ime oddelka'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +77',b'Reorder Qty',b'Preureditev Kol'
+b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28',b'Current Job Openings',b'Razpisana delovna'
+b'DocType: Company',b'Stock Adjustment Account',b'Ra\xc4\x8dun prilagoditev zaloge'
+b'apps/erpnext/erpnext/public/js/payment/pos_payment.html +17',b'Write Off',b'Odpisati'
+b'DocType: Patient Service Unit',b'Allow Overlap',b'Dovoli prekrivanje'
+b'DocType: Timesheet Detail',b'Operation ID',b'Operacija ID'
+b'DocType: Employee',"b'System User (login) ID. If set, it will become default for all HR forms.'","b'Sistem uporabniku (login) ID. \xc4\x8ce je nastavljeno, bo postala privzeta za vse oblike HR.'"
+b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16',b'{0}: From {1}',b'{0}: Od {1}'
+b'DocType: Task',b'depends_on',b'odvisno od'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +60',b'Queued for updating latest price in all Bill of Materials. It may take a few minutes.',b'Vrstni red za posodobitev najnovej\xc5\xa1e cene v vseh gradivih. Traja lahko nekaj minut.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26',"b""Name of new Account. Note: Please don't create accounts for Customers and Suppliers""","b'Ime novega ra\xc4\x8duna. Opomba: Prosimo, da ne ustvarjajo ra\xc4\x8dunov za kupce in dobavitelje'"
+b'apps/erpnext/erpnext/config/setup.py +37',b'Country wise default Address Templates',b'Dr\xc5\xbeava pametno privzeti naslov Predloge'
+b'DocType: Water Analysis',b'Appearance',b'Videz'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70',b'Avg. Buying Price List Rate',b'Povpr. Nakup cenik seznam'
+b'DocType: Sales Order Item',b'Supplier delivers to Customer',b'Dobavitelj zagotavlja naro\xc4\x8dniku'
+b'apps/erpnext/erpnext/config/non_profit.py +23',b'Member information.',b'Podatki o \xc4\x8dlanih.'
+b'apps/erpnext/erpnext/utilities/bot.py +34',b'[{0}](#Form/Item/{0}) is out of stock',b'[{0}] (# Form / Item / {0}) ni na zalogi'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +58',b'Asset Maintenance',b'Vzdr\xc5\xbeevanje sredstev'
+,b'Sales Payment Summary',b'Povzetek prodaje pla\xc4\x8dila'
+b'DocType: Restaurant',b'Restaurant',b'Restavracija'
+b'apps/erpnext/erpnext/accounts/party.py +320',b'Due / Reference Date cannot be after {0}',b'Zaradi / Referen\xc4\x8dni datum ne more biti po {0}'
+b'apps/erpnext/erpnext/config/setup.py +51',b'Data Import and Export',b'Uvoz in izvoz podatkov'
+b'DocType: Patient',b'Account Details',b'podrobnosti ra\xc4\x8duna'
+b'DocType: Crop',b'Materials Required',b'Potrebni materiali'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76',b'No students Found',b'Najdeno \xc5\xa1tudenti'
+b'DocType: Medical Department',b'Medical Department',b'Medicinski oddelek'
+b'DocType: Supplier Scorecard Scoring Criteria',b'Supplier Scorecard Scoring Criteria',b'Merila ocenjevanja rezultatov ocenjevanja dobavitelja'
+b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55',b'Invoice Posting Date',b'Ra\xc4\x8dun Napotitev Datum'
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25',b'Sell',b'Prodaja'
+b'DocType: Purchase Invoice',b'Rounded Total',b'Zaokro\xc5\xbeeno skupaj'
+b'DocType: Product Bundle',b'List items that form the package.',"b'Seznam predmetov, ki tvorijo paket.'"
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +39',b'Not permitted. Please disable the Test Template',"b'Ni dovoljeno. Prosimo, onemogo\xc4\x8dite preskusno predlogo'"
+b'apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26',b'Percentage Allocation should be equal to 100%',b'Odstotek dodelitve mora biti enaka 100%'
+b'DocType: Crop Cycle',b'Linked Land Unit',b'Povezana zemlji\xc5\xa1ka enota'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584',b'Please select Posting Date before selecting Party',b'Izberite datum objave pred izbiro stranko'
+b'DocType: Program Enrollment',b'School House',b'\xc5\xa1ola House'
+b'DocType: Serial No',b'Out of AMC',b'Od AMC'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +82',b'Number of Depreciations Booked cannot be greater than Total Number of Depreciations',b'\xc5\xa0tevilo amortizacije naro\xc4\x8dene ne sme biti ve\xc4\x8dja od skupnega \xc5\xa1t amortizacije'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47',b'Make Maintenance Visit',b'Naredite Maintenance obisk'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +215',b'Please contact to the user who have Sales Master Manager {0} role',"b'Prosimo, obrnite se na uporabnika, ki imajo Sales Master Manager {0} vlogo'"
+b'DocType: Company',b'Default Cash Account',b'Privzeti gotovinski ra\xc4\x8dun'
+b'apps/erpnext/erpnext/config/accounts.py +62',b'Company (not Customer or Supplier) master.',b'Company (ne stranka ali dobavitelj) gospodar.'
+b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6',b'This is based on the attendance of this Student',b'Ta temelji na prisotnosti tega \xc5\xa0tudent'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178',b'No Students in',b'Ni \xc5\xa0tudenti'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +179',b'Add more items or open full form',b'Dodajte ve\xc4\x8d predmetov ali odprto popolno obliko'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212',b'Delivery Notes {0} must be cancelled before cancelling this Sales Order',b'Dobavnic {0} je treba preklicati pred preklicem te Sales Order'
+b'apps/erpnext/erpnext/utilities/user_progress.py +259',b'Go to Users',b'Pojdi na uporabnike'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85',b'Paid amount + Write Off Amount can not be greater than Grand Total',b'Pla\xc4\x8dan znesek + odpis Znesek ne sme biti ve\xc4\x8dja od Grand Skupaj'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78',b'{0} is not a valid Batch Number for Item {1}',b'{0} ni veljavna \xc5\xa1tevilka serije za postavko {1}'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +130',b'Note: There is not enough leave balance for Leave Type {0}',b'Opomba: Ni dovolj bilanca dopust za dopust tipa {0}'
+b'apps/erpnext/erpnext/regional/india/utils.py +16',b'Invalid GSTIN or Enter NA for Unregistered',b'Neveljavna GSTIN ali Enter NA za Neregistrirani'
+b'DocType: Training Event',b'Seminar',b'seminar'
+b'DocType: Program Enrollment Fee',b'Program Enrollment Fee',b'Program Vpis Fee'
+b'DocType: Item',b'Supplier Items',b'Dobavitelj Items'
+b'DocType: Opportunity',b'Opportunity Type',b'Prilo\xc5\xbenost Type'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16',b'New Company',b'Novo podjetje'
+b'apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17',b'Transactions can only be deleted by the creator of the Company',b'Transakcije se lahko izbri\xc5\xa1e le s ustvarjalca dru\xc5\xbebe'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +21',b'Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.',b'Nepravilno \xc5\xa1tevilo General Ledger Entries na\xc5\xa1el. Morda ste izbrali napa\xc4\x8den ra\xc4\x8dun v transakciji.'
+b'DocType: Employee',b'Prefered Contact Email',b'Prednostna Kontaktni e-naslov'
+b'DocType: Cheque Print Template',b'Cheque Width',b'\xc4\x8cek \xc5\xa0irina'
+b'DocType: Selling Settings',b'Validate Selling Price for Item against Purchase Rate or Valuation Rate',b'Potrdite prodajna cena za postavko proti Nakup mero ali vrednotenja'
+b'DocType: Fee Schedule',b'Fee Schedule',b'Razpored Fee'
+b'DocType: Hub Settings',b'Publish Availability',b'Objavite Razpolo\xc5\xbeljivost'
+b'DocType: Company',b'Create Chart Of Accounts Based On',"b'Ustvariti kontni okvir, ki temelji na'"
+b'apps/erpnext/erpnext/projects/doctype/task/task.js +91',b'Cannot convert it to non-group. Child Tasks exist.',b'Ne morete ga pretvoriti v ne-skupino. Otro\xc5\xa1ke naloge obstajajo.'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +112',b'Date of Birth cannot be greater than today.',"b'Datum rojstva ne more biti ve\xc4\x8dji, od dana\xc5\xa1njega.'"
+,b'Stock Ageing',b'Staranje zaloge'
+b'apps/erpnext/erpnext/education/doctype/student/student.py +40',b'Student {0} exist against student applicant {1}',b'\xc5\xa0tudent {0} obstaja proti \xc5\xa1tudentskega prijavitelja {1}'
+b'DocType: Purchase Invoice',b'Rounding Adjustment (Company Currency)',b'Prilagajanje zaokro\xc5\xbeevanja (valuta podjetja)'
+b'apps/erpnext/erpnext/projects/doctype/task/task.js +39',b'Timesheet',b'Evidenca prisotnosti'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +243',b'Batch: ',b'Serija:'
+b'DocType: Volunteer',b'Afternoon',b'Popoldne'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +258',"b""{0} '{1}' is disabled""",b'{0} {1} &quot;je onemogo\xc4\x8dena'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13',b'Set as Open',b'Nastavi kot Odpri'
+b'DocType: Cheque Print Template',b'Scanned Cheque',b'skeniranih \xc4\x8cek'
+b'DocType: Notification Control',b'Send automatic emails to Contacts on Submitting transactions.',b'Po\xc5\xa1lji samodejne elektronske po\xc5\xa1te v Contacts o posredovanju transakcij.'
+b'DocType: Timesheet',b'Total Billable Amount',b'Skupaj Odgovorni Znesek'
+b'DocType: Customer',b'Credit Limit and Payment Terms',b'Kreditno omejitev in pla\xc4\x8dilni pogoji'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20',b'Item 3',b'Postavka 3'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6',b'Order Entry',b'Vnos naro\xc4\x8dila'
+b'DocType: Purchase Order',b'Customer Contact Email',b'Customer Contact Email'
+b'DocType: Warranty Claim',b'Item and Warranty Details',b'To\xc4\x8dka in Garancija Podrobnosti'
+b'DocType: Chapter',b'Chapter Members',b'\xc4\x8clanice poglavja'
+b'DocType: Sales Team',b'Contribution (%)',b'Prispevek (%)'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +102',"b""Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified""","b'Opomba: Za\xc4\x8detek Pla\xc4\x8dilo se ne bodo ustvarili, saj &quot;gotovinski ali ban\xc4\x8dni ra\xc4\x8dun&quot; ni bil podan'"
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +70',b'Project {0} already exists',b'Projekt {0} \xc5\xbee obstaja'
+b'DocType: Medical Department',b'Nursing User',b'Uporabnik zdravstvene nege'
+b'DocType: Plant Analysis',b'Plant Analysis Criterias',b'Kriteriji za analizo rastlin'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239',b'Responsibilities',b'Odgovornosti'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125',b'Validity period of this quotation has ended.',b'Obdobje veljavnosti te ponudbe se je kon\xc4\x8dalo.'
+b'DocType: Expense Claim Account',b'Expense Claim Account',b'Expense Zahtevek ra\xc4\x8duna'
+b'DocType: Accounts Settings',b'Allow Stale Exchange Rates',b'Dovoli te\xc4\x8dajne menjalne te\xc4\x8daje'
+b'DocType: Sales Person',b'Sales Person Name',b'Prodaja Oseba Name'
+b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54',b'Please enter atleast 1 invoice in the table',b'Vnesite atleast 1 ra\xc4\x8dun v tabeli'
+b'apps/erpnext/erpnext/utilities/user_progress.py +247',b'Add Users',b'Dodaj uporabnike'
+b'DocType: POS Item Group',b'Item Group',b'Element Group'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16',b'Student Group: ',b'\xc5\xa0tudentska skupina:'
+b'DocType: Item',b'Safety Stock',b'Varnostna zaloga'
+b'DocType: Healthcare Settings',b'Healthcare Settings',b'Nastavitve zdravstva'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +54',b'Progress % for a task cannot be more than 100.',"b'Napredek% za nalogo, ne more biti ve\xc4\x8d kot 100.'"
+b'DocType: Stock Reconciliation Item',b'Before reconciliation',b'Pred uskladitvijo'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12',b'To {0}',b'Za {0}'
+b'DocType: Purchase Invoice',b'Taxes and Charges Added (Company Currency)',b'Davki in dajatve na dodano vrednost (Company Valuta)'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +476',b'Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable',b'Postavka Dav\xc4\x8dna Row {0} morajo upo\xc5\xa1tevati vrste davka ali prihodek ali odhodek ali Obdav\xc4\x8dljivi'
+b'DocType: Sales Order',b'Partly Billed',b'Delno zara\xc4\x8dunavajo'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +43',b'Item {0} must be a Fixed Asset Item',b'To\xc4\x8dka {0} mora biti osnovno sredstvo postavka'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +372',b'Make Variants',b'Make Variants'
+b'DocType: Item',b'Default BOM',b'Privzeto BOM'
+b'DocType: Project',b'Total Billed Amount (via Sales Invoices)',b'Skupni fakturirani znesek (prek prodajnih ra\xc4\x8dunov)'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +118',b'Debit Note Amount',b'Opomin Znesek'
+b'DocType: Project Update',b'Not Updated',b'Ni posodobljeno'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +106',"b'There are inconsistencies between the rate, no of shares and the amount calculated'","b'Obstajajo neskladja med stopnjo, brez delnic in izra\xc4\x8dunanim zneskom'"
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +89',b'Please re-type company name to confirm',"b'Prosimo, ponovno tip firma za potrditev'"
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +216',b'Total Outstanding Amt',b'Skupaj Izjemna Amt'
+b'DocType: Journal Entry',b'Printing Settings',b'Nastavitve tiskanja'
+b'DocType: Employee Advance',b'Advance Account',b'Predpla\xc4\x8dni\xc5\xa1ki ra\xc4\x8dun'
+b'DocType: Job Offer',b'Job Offer Terms',b'Pogoji ponudb za delo'
+b'DocType: Sales Invoice',b'Include Payment (POS)',b'Vklju\xc4\x8dujejo pla\xc4\x8dilo (POS)'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292',b'Total Debit must be equal to Total Credit. The difference is {0}',b'Skupaj obremenitve mora biti enaka celotnemu kreditnemu. Razlika je {0}'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11',b'Automotive',b'Avtomobilizem'
+b'DocType: Vehicle',b'Insurance Company',b'Zavarovalnica'
+b'DocType: Asset Category Account',b'Fixed Asset Account',b'Fiksna ra\xc4\x8dun premo\xc5\xbeenja'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414',b'Variable',b'spremenljivka'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47',b'From Delivery Note',b'Od dobavnica'
+b'DocType: Chapter',b'Members',b'\xc4\x8clani'
+b'DocType: Student',b'Student Email Address',b'\xc5\xa0tudent e-po\xc5\xa1tni naslov'
+b'DocType: Item',b'Hub Warehouse',b'Vozli\xc5\xa1\xc4\x8dno skladi\xc5\xa1\xc4\x8de'
+b'DocType: Assessment Plan',b'From Time',b'Od \xc4\x8dasa'
+b'DocType: Hotel Settings',b'Hotel Settings',b'Hotelske nastavitve'
+b'apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12',b'In Stock: ',b'Na zalogi:'
+b'DocType: Notification Control',b'Custom Message',b'Sporo\xc4\x8dilo po meri'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33',b'Investment Banking',b'Investicijsko ban\xc4\x8dni\xc5\xa1tvo'
+b'DocType: Purchase Invoice',b'input',b'vnos'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79',b'Cash or Bank Account is mandatory for making payment entry',b'Gotovina ali ban\xc4\x8dnega ra\xc4\x8duna je obvezen za izdelavo vnos pla\xc4\x8dila'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54',b'Student Address',b'\xc5\xa1tudent Naslov'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54',b'Student Address',b'\xc5\xa1tudent Naslov'
+b'DocType: Purchase Invoice',b'Price List Exchange Rate',b'Cenik Exchange Rate'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +251',b'Account Number {0} already used in account {1}',b'\xc5\xa0tevilka ra\xc4\x8duna {0} je \xc5\xbee uporabljena v ra\xc4\x8dunu {1}'
+b'DocType: GoCardless Mandate',b'Mandate',b'Mandat'
+b'DocType: POS Profile',b'POS Profile Name',b'Ime profila profila POS'
+b'DocType: Hotel Room Reservation',b'Booked',b'Rezervirano'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45',b'CompAuxLib',b'CompAuxLib'
+b'DocType: Purchase Invoice Item',b'Rate',b'Vrednost'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104',b'Intern',b'Intern'
+b'DocType: Delivery Stop',b'Address Name',b'naslov Ime'
+b'DocType: Stock Entry',b'From BOM',b'Od BOM'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +639',b'Splitting {0} units of {1}',b'Razdelitev {0} enot {1}'
+b'DocType: Assessment Code',b'Assessment Code',b'Koda ocena'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73',b'Basic',b'Osnovni'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94',b'Stock transactions before {0} are frozen',b'Zaloga transakcije pred {0} so zamrznjeni'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219',"b""Please click on 'Generate Schedule'""","b'Prosimo, kliknite na &quot;ustvarjajo Seznamu&quot;'"
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122',b'Reference No is mandatory if you entered Reference Date',"b'Referen\xc4\x8dna \xc5\xa1tevilka je obvezna, \xc4\x8de ste vnesli Referen\xc4\x8dni datum'"
+b'DocType: Bank Reconciliation Detail',b'Payment Document',b'pla\xc4\x8dilo dokumentov'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37',b'Error evaluating the criteria formula',b'Napaka pri ocenjevanju formule za merila'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +115',b'Date of Joining must be greater than Date of Birth',b'Datum pridru\xc5\xbeitva mora biti ve\xc4\x8dji od datuma rojstva'
+b'DocType: Salary Slip',b'Salary Structure',b'Struktura Pla\xc4\x8de'
+b'DocType: Account',b'Bank',b'Banka'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9',b'Airline',b'Airline'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +853',b'Issue Material',b'Vpra\xc5\xa1anje Material'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3',b'An error occured while creating recurring',b'Pri ustvarjanju ponavljajo\xc4\x8de se napake'
+b'DocType: Material Request Item',b'For Warehouse',b'Za Skladi\xc5\xa1\xc4\x8de'
+b'DocType: Employee',b'Offer Date',b'Ponudba Datum'
+b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33',b'Quotations',b'Ponudbe'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +735',b'You are in offline mode. You will not be able to reload until you have network.',"b'Ste v na\xc4\x8dinu brez povezave. Ne boste mogli nalo\xc5\xbeiti, dokler imate omre\xc5\xbeje.'"
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47',b'No Student Groups created.',b'ustvaril nobene skupine \xc5\xa1tudentov.'
+b'DocType: Purchase Invoice Item',b'Serial No',b'Zaporedna \xc5\xa1tevilka'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119',b'Monthly Repayment Amount cannot be greater than Loan Amount',b'Mese\xc4\x8dni Povra\xc4\x8dilo Znesek ne sme biti ve\xc4\x8dja od zneska kredita'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143',b'Please enter Maintaince Details first',"b'Prosimo, da najprej vnesete Maintaince Podrobnosti'"
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56',b'Row #{0}: Expected Delivery Date cannot be before Purchase Order Date',b'Vrstica # {0}: Pri\xc4\x8dakovani datum dostave ne sme biti pred datumom naro\xc4\x8dila'
+b'DocType: Purchase Invoice',b'Print Language',b'Jezik tiskanja'
+b'DocType: Salary Slip',b'Total Working Hours',b'Skupaj Delovni \xc4\x8das'
+b'DocType: Sales Invoice',b'Customer PO Details',b'Podrobnosti kupca PO'
+b'DocType: Subscription',b'Next Schedule Date',b'Naslednji datum na\xc4\x8drta'
+b'DocType: Stock Entry',b'Including items for sub assemblies',"b'Vklju\xc4\x8dno s postavkami, za sklope'"
+b'DocType: Opening Invoice Creation Tool Item',b'Temporary Opening Account',b'Za\xc4\x8dasni odpiranje ra\xc4\x8duna'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1964',b'Enter value must be positive',b'Vnesite vrednost mora biti pozitivna'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +446',b'All Territories',b'Vse Territories'
+b'apps/erpnext/erpnext/projects/doctype/task/task_tree.js +49',b'Add Multiple Tasks',b'Dodaj ve\xc4\x8d nalog'
+b'DocType: Purchase Invoice',b'Items',b'Predmeti'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34',b'Student is already enrolled.',b'\xc5\xa0tudent je \xc5\xbee vpisan.'
+b'DocType: Fiscal Year',b'Year Name',b'Leto Name'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +241',b'There are more holidays than working days this month.',b'Obstaja ve\xc4\x8d prazniki od delovnih dneh tega meseca.'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +78',b'PDC/LC Ref',b'PDC / LC Ref'
+b'DocType: Product Bundle Item',b'Product Bundle Item',b'Izdelek Bundle Postavka'
+b'DocType: Sales Partner',b'Sales Partner Name',b'Prodaja Partner Name'
+b'apps/erpnext/erpnext/hooks.py +136',b'Request for Quotations',b'Zahteva za Citati'
+b'DocType: Payment Reconciliation',b'Maximum Invoice Amount',b'Najve\xc4\x8dja Znesek ra\xc4\x8duna'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50',b'Montantdevise',b'Montantdevise'
+b'apps/erpnext/erpnext/healthcare/setup.py +210',b'Haematology',b'Hematologija'
+b'DocType: Normal Test Items',b'Normal Test Items',b'Normalni preskusni elementi'
+b'DocType: Student Language',b'Student Language',b'\xc5\xa1tudent jezik'
+b'apps/erpnext/erpnext/config/selling.py +23',b'Customers',b'Stranke'
+b'DocType: Cash Flow Mapping',b'Is Working Capital',b'Je delovni kapital'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24',b'Order/Quot %',b'Naro\xc4\x8dilo / quot%'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24',b'Order/Quot %',b'Naro\xc4\x8dilo / quot%'
+b'apps/erpnext/erpnext/config/healthcare.py +25',b'Record Patient Vitals',b'Zapi\xc5\xa1ite bolnike vitale'
+b'DocType: Fee Schedule',b'Institution',b'ustanova'
+b'DocType: Asset',b'Partially Depreciated',b'delno amortiziranih'
+b'DocType: Issue',b'Opening Time',b'Otvoritev \xc4\x8das'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +89',b'From and To dates required',b'Od in Do datumov zahtevanih'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46',b'Securities & Commodity Exchanges',b'Vrednostnih papirjev in blagovne borze'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +689',"b""Default Unit of Measure for Variant '{0}' must be same as in Template '{1}'""",b'Privzeto mersko enoto za Variant &#39;{0}&#39; mora biti enaka kot v predlogo &#39;{1}&#39;'
+b'DocType: Shipping Rule',b'Calculate Based On',b'Izra\xc4\x8dun temelji na'
+b'DocType: Delivery Note Item',b'From Warehouse',b'Iz skladi\xc5\xa1\xc4\x8da'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59',b'No employees for the mentioned criteria',b'Za omenjena merila ni zaposlenih'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +955',b'No Items with Bill of Materials to Manufacture',b'Ni Postavke z Bill materialov za Izdelava'
+b'DocType: Hotel Settings',b'Default Customer',b'Privzeta stranka'
+b'DocType: Assessment Plan',b'Supervisor Name',b'Ime nadzornik'
+b'DocType: Healthcare Settings',b'Do not confirm if appointment is created for the same day',"b'Ne potrdite, \xc4\x8de je sestanek ustvarjen za isti dan'"
+b'DocType: Program Enrollment Course',b'Program Enrollment Course',b'Program Vpis te\xc4\x8daj'
+b'DocType: Program Enrollment Course',b'Program Enrollment Course',b'Program Vpis te\xc4\x8daj'
+b'DocType: Purchase Taxes and Charges',b'Valuation and Total',b'Vrednotenje in Total'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11',b'Scorecards',b'Oglednice'
+b'DocType: Tax Rule',b'Shipping City',b'Dostava Mesto'
+b'DocType: Notification Control',b'Customize the Notification',b'Prilagodite Obvestilo'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24',b'Cash Flow from Operations',b'Denarni tok iz poslovanja'
+b'DocType: Purchase Invoice',b'Shipping Rule',b'Pravilo za dostavo'
+b'DocType: Patient Relation',b'Spouse',b'Zakonec'
+b'DocType: Lab Test Groups',b'Add Test',b'Dodaj test'
+b'DocType: Manufacturer',b'Limited to 12 characters',b'Omejena na 12 znakov'
+b'DocType: Journal Entry',b'Print Heading',b'Glava postavk'
+b'apps/erpnext/erpnext/config/stock.py +146',b'Delivery Trip service tours to customers.',b'Dostava Trip potovanja slu\xc5\xbebe za stranke.'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57',b'Total cannot be zero',b'Skupaj ne more biti ni\xc4\x8d'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16',"b""'Days Since Last Order' must be greater than or equal to zero""","b'""Dnevi od zadnjega naro\xc4\x8dila"" morajo biti ve\xc4\x8dji ali enak ni\xc4\x8d'"
+b'DocType: Plant Analysis Criteria',b'Maximum Permissible Value',b'Najvi\xc5\xa1ja dovoljena vrednost'
+b'DocType: Journal Entry Account',b'Employee Advance',b'Napredek zaposlenih'
+b'DocType: Payroll Entry',b'Payroll Frequency',b'izpla\xc4\x8dane Frequency'
+b'DocType: Lab Test Template',b'Sensitivity',b'Ob\xc4\x8dutljivost'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +941',b'Raw Material',b'Surovina'
+b'DocType: Leave Application',b'Follow via Email',b'Sledite preko e-maila'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55',b'Plants and Machineries',b'Rastline in stroje'
+b'DocType: Purchase Taxes and Charges',b'Tax Amount After Discount Amount',b'Dav\xc4\x8dna Znesek Po Popust Znesek'
+b'DocType: Daily Work Summary Settings',b'Daily Work Summary Settings',b'Dnevni Nastavitve Delo Povzetek'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +447',b'Please enter Reqd by Date',b'Vnesite Reqd po datumu'
+b'DocType: Payment Entry',b'Internal Transfer',b'Interni prenos'
+b'DocType: Asset Maintenance',b'Maintenance Tasks',b'Vzdr\xc5\xbeevalna opravila'
+b'apps/erpnext/erpnext/setup/doctype/territory/territory.py +19',b'Either target qty or target amount is mandatory',b'Bodisi ciljna kol ali ciljna vrednost je obvezna'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366',b'Please select Posting Date first',"b'Prosimo, izberite datumom knji\xc5\xbeenja najprej'"
+b'apps/erpnext/erpnext/public/js/account_tree_grid.js +209',b'Opening Date should be before Closing Date',b'Pri\xc4\x8detek mora biti pred Zapiranje Datum'
+b'DocType: Leave Control Panel',b'Carry Forward',b'Carry Forward'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30',b'Cost Center with existing transactions can not be converted to ledger',b'Stro\xc5\xa1kovno Center z obstoje\xc4\x8dimi transakcij ni mogo\xc4\x8de pretvoriti v knjigo terjatev'
+b'DocType: Department',b'Days for which Holidays are blocked for this department.',"b'Dni, za katere so Holidays blokirana za ta oddelek.'"
+b'DocType: GoCardless Mandate',b'ERPNext Integrations',b'Integracije ERPNext'
+b'DocType: Crop Cycle',b'Detected Disease',b'Detektirana bolezen'
+,b'Produced',b'Proizvedena'
+b'DocType: Item',b'Item Code for Suppliers',b'Oznaka za dobavitelje'
+b'DocType: Issue',b'Raised By (Email)',b'Postavljeno Z (e-naslov)'
+b'DocType: Training Event',b'Trainer Name',b'Ime Trainer'
+b'DocType: Mode of Payment',b'General',b'Splo\xc5\xa1no'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28',b'Last Communication',b'Zadnje sporo\xc4\x8dilo'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28',b'Last Communication',b'Zadnje sporo\xc4\x8dilo'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372',"b""Cannot deduct when category is for 'Valuation' or 'Valuation and Total'""","b'Ne more odbiti, \xc4\x8de je kategorija za &quot;vrednotenje&quot; ali &quot;Vrednotenje in Total&quot;'"
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +234',b'Serial Nos Required for Serialized Item {0}',b'Serijska \xc5\xa1t Zahtevano za zaporednimi postavki {0}'
+b'apps/erpnext/erpnext/config/accounts.py +144',b'Match Payments with Invoices',b'Match pla\xc4\x8dila z ra\xc4\x8dunov'
+b'DocType: Journal Entry',b'Bank Entry',b'Banka Za\xc4\x8detek'
+b'DocType: Authorization Rule',b'Applicable To (Designation)',b'Ki se uporabljajo za (Oznaka)'
+,b'Profitability Analysis',b'Analiza dobi\xc4\x8dkonosnosti'
+b'DocType: Fees',b'Student Email',b'Student Email'
+b'DocType: Supplier',b'Prevent POs',b'Prepre\xc4\x8devanje PO'
+b'DocType: Patient',"b'Allergies, Medical and Surgical History'","b'Alergije, medicinska in kirur\xc5\xa1ka zgodovina'"
+b'apps/erpnext/erpnext/templates/generators/item.html +77',b'Add to Cart',b'Dodaj v vozi\xc4\x8dek'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28',b'Group By',b'Skupina S'
+b'DocType: Guardian',b'Interests',b'Zanima'
+b'apps/erpnext/erpnext/config/accounts.py +298',b'Enable / disable currencies.',b'Omogo\xc4\x8di / onemogo\xc4\x8di valute.'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +105',b'Dr {0} on Half day Leave on {1}',b'Dr {0} na poldnevni dan pustite {1}'
+b'DocType: Production Plan',b'Get Material Request',b'Get Zahteva material'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111',b'Postal Expenses',b'Po\xc5\xa1tni stro\xc5\xa1ki'
+b'apps/erpnext/erpnext/controllers/trends.py +19',b'Total(Amt)',b'Skupaj (Amt)'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26',b'Entertainment & Leisure',b'Zabava &amp; prosti \xc4\x8das'
+,b'Item Variant Details',b'Podrobnosti o elementu Variante'
+b'DocType: Quality Inspection',b'Item Serial No',b'Postavka Zaporedna \xc5\xa1tevilka'
+b'apps/erpnext/erpnext/utilities/activation.py +135',b'Create Employee Records',b'Ustvari zaposlencev zapisov'
+b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Present',b'Skupaj Present'
+b'apps/erpnext/erpnext/config/accounts.py +105',b'Accounting Statements',b'ra\xc4\x8dunovodski izkazi'
+b'DocType: Drug Prescription',b'Hour',b'Ura'
+b'DocType: Restaurant Order Entry',b'Last Sales Invoice',b'Zadnji ra\xc4\x8dun za prodajo'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +788',b'Please select Qty against item {0}',b'Izberite koli\xc4\x8dino proti elementu {0}'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29',b'New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt',b'Nova serijska \xc5\xa1tevilka ne more imeti skladi\xc5\xa1\xc4\x8de. Skladi\xc5\xa1\xc4\x8de mora nastaviti borze vstopu ali Potrdilo o nakupu'
+b'DocType: Lead',b'Lead Type',b'Tip ponudbe'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +114',b'You are not authorized to approve leaves on Block Dates',b'Niste poobla\xc5\xa1\xc4\x8deni za odobritev liste na Block termini'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +394',b'All these items have already been invoiced',b'Vsi ti artikli so \xc5\xbee bili obra\xc4\x8dunani'
+b'DocType: Company',b'Monthly Sales Target',b'Mese\xc4\x8dni prodajni cilj'
+b'apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37',b'Can be approved by {0}',b'Mogo\xc4\x8de odobriti {0}'
+b'DocType: Hotel Room',b'Hotel Room Type',b'Tip sobe hotela'
+b'DocType: Item',b'Default Material Request Type',b'Privzeto Material Vrsta Zahteva'
+b'DocType: Supplier Scorecard',b'Evaluation Period',b'Ocenjevalno obdobje'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13',b'Unknown',b'Neznan'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +954',b'Work Order not created',b'Delovni nalog ni bil ustvarjen'
+b'DocType: Shipping Rule',b'Shipping Rule Conditions',b'Pogoji dostavnega pravila'
+b'DocType: Purchase Invoice',b'Export Type',b'Izvozna vrsta'
+b'DocType: Salary Slip Loan',b'Salary Slip Loan',b'Posojilo za pla\xc4\x8dilo'
+b'DocType: BOM Update Tool',b'The new BOM after replacement',b'Novi BOM po zamenjavi'
+,b'Point of Sale',b'Prodajno mesto'
+b'DocType: Payment Entry',b'Received Amount',b'prejela znesek'
+b'DocType: Patient',b'Widow',b'Vdova'
+b'DocType: GST Settings',b'GSTIN Email Sent On',"b'GSTIN e-po\xc5\xa1ti,'"
+b'DocType: Program Enrollment',b'Pick/Drop by Guardian',b'Pick / zni\xc5\xbeala za Guardian'
+b'DocType: Crop',b'Planting UOM',b'Sajenje UOM'
+b'DocType: Account',b'Tax',b'Dav\xc4\x8dna'
+b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45',b'Not Marked',b'ne Ozna\xc4\x8deno'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1',b'Opening Invoices Summary',b'Povzetek povzetka ra\xc4\x8dunov'
+b'DocType: Education Settings',b'Education Manager',b'Vodja izobra\xc5\xbeevanja'
+b'DocType: Crop Cycle',b'The minimum length between each plant in the field for optimum growth',b'Najmanj\xc5\xa1a dol\xc5\xbeina med posameznimi rastlinami na polju za optimalno rast'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152',"b'Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry'",b'Zdru\xc5\xbeena To\xc4\x8dka {0} ni mogo\xc4\x8de posodobiti uporabo zaloga spravi namesto uporabiti zaloga Entry'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152',"b'Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry'",b'Zdru\xc5\xbeena To\xc4\x8dka {0} ni mogo\xc4\x8de posodobiti uporabo zaloga spravi namesto uporabiti zaloga Entry'
+b'DocType: Quality Inspection',b'Report Date',b'Poro\xc4\x8dilo Datum'
+b'DocType: Student',b'Middle Name',b'Srednje ime'
+b'DocType: C-Form',b'Invoices',b'Ra\xc4\x8duni'
+b'DocType: Water Analysis',b'Type of Sample',b'Vrsta vzorca'
+b'DocType: Batch',b'Source Document Name',b'Vir Ime dokumenta'
+b'DocType: Batch',b'Source Document Name',b'Vir Ime dokumenta'
+b'DocType: Production Plan',b'Get Raw Materials For Production',b'Pridobite surovine za proizvodnjo'
+b'DocType: Job Opening',b'Job Title',b'Job Naslov'
+b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84',"b'{0} indicates that {1} will not provide a quotation, but all items \\\n\t\t\t\t\thave been quoted. Updating the RFQ quote status.'","b'{0} ozna\xc4\x8duje, da {1} ne bo podal ponudbe, ampak cene vseh postavk so navedene. Posodabljanje statusa ponudb RFQ.'"
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1026',b'Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.',b'Najve\xc4\x8dji vzorci - {0} so bili \xc5\xbee shranjeni za serijo {1} in element {2} v seriji {3}.'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +125',b'Please Set Supplier Type in Buying Settings.',b'V nastavitvah nakupa izberite dobavitelja.'
+b'DocType: Manufacturing Settings',b'Update BOM Cost Automatically',b'Posodobi BOM stro\xc5\xa1kov samodejno'
+b'DocType: Lab Test',b'Test Name',b'Ime preskusa'
+b'apps/erpnext/erpnext/utilities/activation.py +99',b'Create Users',b'Ustvari uporabnike'
+b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Gram',b'gram'
+b'DocType: Supplier Scorecard',b'Per Month',b'Na mesec'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +433',b'Quantity to Manufacture must be greater than 0.',b'Koli\xc4\x8dina na Izdelava mora biti ve\xc4\x8dja od 0.'
+b'DocType: Asset Settings',b'Calculate Prorated Depreciation Schedule Based on Fiscal Year',b'Izra\xc4\x8dunajte proporcionalno amortizacijsko shemo na podlagi dav\xc4\x8dnega leta'
+b'apps/erpnext/erpnext/config/maintenance.py +17',b'Visit report for maintenance call.',b'Obi\xc5\xa1\xc4\x8dite poro\xc4\x8dilo za vzdr\xc5\xbeevalna klic.'
+b'DocType: Stock Entry',b'Update Rate and Availability',b'Posodobitev Oceni in razpolo\xc5\xbeljivost'
+b'DocType: Stock Settings',b'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.',"b'Odstotek ste dovoljeno prejemati ali dostaviti bolj proti koli\xc4\x8dine naro\xc4\x8denega. Na primer: \xc4\x8ce ste naro\xc4\x8dili 100 enot. in va\xc5\xa1 dodatek za 10%, potem ste lahko prejeli 110 enot.'"
+b'DocType: POS Customer Group',b'Customer Group',b'Skupina za stranke'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +217',b'Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order # {3}. Please update operation status via Time Logs',b'Vrstica # {0}: Operacija {1} ni kon\xc4\x8dana za {2} \xc5\xa1tevilo kon\xc4\x8dnih izdelkov v delovnem naro\xc4\x8dilu # {3}. Posodobite stanje delovanja prek \xc4\x8dasovnih dnevnikov'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +128',b'New Batch ID (Optional)',b'Nova Serija ID (po \xc5\xbeelji)'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201',b'Expense account is mandatory for item {0}',b'Expense ra\xc4\x8dun je obvezna za postavko {0}'
+b'DocType: BOM',b'Website Description',b'Spletna stran Opis'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +47',b'Net Change in Equity',b'Neto sprememba v kapitalu'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +220',b'Please cancel Purchase Invoice {0} first',b'Prosim za prekinitev ra\xc4\x8dunu o nakupu {0} najprej'
+b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43',"b'Email Address must be unique, already exists for {0}'","b'E-po\xc5\xa1tni naslov mora biti edinstven, \xc5\xbee obstaja za {0}'"
+b'DocType: Serial No',b'AMC Expiry Date',b'AMC preteka Datum'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +880',b'Receipt',b'prejem'
+,b'Sales Register',b'Prodaja Register'
+b'DocType: Daily Work Summary Group',b'Send Emails At',b'Po\xc5\xa1lji e-po\xc5\xa1te na'
+b'DocType: Quotation',b'Quotation Lost Reason',b'Kotacija Lost Razlog'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +381',b'Transaction reference no {0} dated {1}',b'Referen\xc4\x8dna transakcija ni {0} dne {1}'
+b'apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5',b'There is nothing to edit.',b'Ni\xc4\x8d ni za urejanje.'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116',b'Summary for this month and pending activities',b'Povzetek za ta mesec in v teku dejavnosti'
+b'apps/erpnext/erpnext/utilities/user_progress.py +248',"b'Add users to your organization, other than yourself.'","b'Dodajte uporabnike v svojo organizacijo, razen sebe.'"
+b'DocType: Customer Group',b'Customer Group Name',b'Skupina Ime stranke'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +109',b'No Customers yet!',b'Ni \xc5\xa1e nobene stranke!'
+b'apps/erpnext/erpnext/public/js/financial_statements.js +56',b'Cash Flow Statement',b'Izkaz denarnih tokov'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +473',b'No material request created',b'Ni ustvarjeno nobeno materialno zahtevo'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23',b'Loan Amount cannot exceed Maximum Loan Amount of {0}',b'Kredita vrednosti ne sme prese\xc4\x8di najvi\xc5\xa1ji mo\xc5\xbeen kredit znesku {0}'
+b'apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22',b'License',b'licenca'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +491',b'Please remove this Invoice {0} from C-Form {1}',"b'Prosimo, odstranite tej fakturi {0} od C-Form {1}'"
+b'DocType: Leave Control Panel',"b""Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year""","b'Prosimo, izberite Carry Forward, \xc4\x8de \xc5\xbeelite vklju\xc4\x8diti tudi v preteklem poslovnem letu je bilanca prepu\xc5\xa1\xc4\x8da tem fiskalnem letu'"
+b'DocType: GL Entry',b'Against Voucher Type',b'Proti bon Type'
+b'DocType: Physician',b'Phone (R)',b'Telefon (R)'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +56',b'Time slots added',b'Dodane so \xc4\x8dasovne re\xc5\xbee'
+b'DocType: Item',b'Attributes',b'Atributi'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31',b'Enable Template',b'Omogo\xc4\x8di predlogo'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226',b'Please enter Write Off Account',b'Vnesite ra\xc4\x8dun za odpis'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71',b'Last Order Date',b'Zadnja Datum naro\xc4\x8dila'
+b'DocType: Patient',b'B Negative',b'B Negativno'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25',b'Maintenance Status has to be Cancelled or Completed to Submit',"b'Stanje vzdr\xc5\xbeevanja je treba preklicati ali kon\xc4\x8dati, da ga po\xc5\xa1ljete'"
+b'DocType: Hotel Room',b'Hotel Room',b'Hotelska soba'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47',b'Account {0} does not belongs to company {1}',b'Ra\xc4\x8dun {0} ne pripada podjetju {1}'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +884',b'Serial Numbers in row {0} does not match with Delivery Note',b'\xc5\xa0tevilke v vrstici {0} se ne ujema z dobavnice'
+b'DocType: Student',b'Guardian Details',b'Guardian Podrobnosti'
+b'DocType: C-Form',b'C-Form',b'C-Form'
+b'apps/erpnext/erpnext/config/hr.py +18',b'Mark Attendance for multiple employees',b'Mark Udele\xc5\xbeba za ve\xc4\x8d zaposlenih'
+b'DocType: Agriculture Task',b'Start Day',b'Za\xc4\x8dni dan'
+b'DocType: Vehicle',b'Chassis No',b'podvozje ni'
+b'DocType: Payment Request',b'Initiated',b'Za\xc4\x8dela'
+b'DocType: Production Plan Item',b'Planned Start Date',b'Na\xc4\x8drtovani datum za\xc4\x8detka'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +618',b'Please select a BOM',b'Izberite BOM'
+b'DocType: Purchase Invoice',b'Availed ITC Integrated Tax',b'Uporabil integrirani davek ITC'
+b'DocType: Serial No',b'Creation Document Type',b'Creation Document Type'
+b'DocType: Project Task',b'View Timesheet',b'Ogled Timesheet'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54',b'End date must be greater than start date',b'Kon\xc4\x8dni datum mora biti ve\xc4\x8dji od za\xc4\x8detnega datuma'
+b'DocType: Leave Type',b'Is Encash',b'Je vnov\xc4\x8di'
+b'DocType: Leave Allocation',b'New Leaves Allocated',b'Nove Listi Dodeljena'
+b'apps/erpnext/erpnext/controllers/trends.py +269',b'Project-wise data is not available for Quotation',b'Podatki projekt pametno ni na voljo za ponudbo'
+b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30',b'End on',b'Kon\xc4\x8daj naprej'
+b'DocType: Project',b'Expected End Date',b'Pri\xc4\x8dakovani datum zaklju\xc4\x8dka'
+b'DocType: Budget Account',b'Budget Amount',b'prora\xc4\x8dun Znesek'
+b'DocType: Donor',b'Donor Name',b'Ime donatorja'
+b'DocType: Appraisal Template',b'Appraisal Template Title',b'Cenitev Predloga Naslov'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39',"b""From Date {0} for Employee {1} cannot be before employee's joining Date {2}""",b'Od datuma {0} za zaposlenih {1} ne more biti pred povezuje Datum delavca {2}'
+b'apps/erpnext/erpnext/utilities/user_progress_utils.py +29',b'Commercial',b'Commercial'
+b'DocType: Patient',b'Alcohol Current Use',b'Alkoholna trenutna uporaba'
+b'DocType: Student Admission Program',b'Student Admission Program',b'Program sprejema \xc5\xa1tudentov'
+b'DocType: Payment Entry',b'Account Paid To',b'Ra\xc4\x8dun Izpla\xc4\x8da'
+b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24',b'Parent Item {0} must not be a Stock Item',b'Parent Item {0} ne sme biti Stock Postavka'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +466',b'Could not submit any Salary Slip <br>\\\n\t\t\tPossible reasons: <br>\\\n\t\t\t1. Net pay is less than 0. <br>\\\n\t\t\t2. Company Email Address specified in employee master is not valid. <br>',"b'Ni bilo mogo\xc4\x8de predlo\xc5\xbeiti pla\xc4\x8dilnega lista <br> \\ Mo\xc5\xbeni razlogi: <br> \\ 1. Neto pla\xc4\x8dilo je manj\xc5\xa1e od 0. <br> \\ 2. E-po\xc5\xa1tni naslov podjetja, ki je naveden v poveljniku zaposlenega, ni veljaven. <br>'"
+b'apps/erpnext/erpnext/config/selling.py +57',b'All Products or Services.',b'Vse izdelke ali storitve.'
+b'DocType: Expense Claim',b'More Details',b'Ve\xc4\x8d podrobnosti'
+b'DocType: Supplier Quotation',b'Supplier Address',b'Dobavitelj Naslov'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128',b'{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5}',b'{0} prora\xc4\x8dun za ra\xc4\x8dun {1} na {2} {3} je {4}. Bo prekora\xc4\x8den za {5}'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +695',"b""Row {0}# Account must be of type 'Fixed Asset'""",b'Vrstica {0} # ra\xc4\x8duna mora biti tipa &quot;osnovno sredstvo&quot;'
+b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'Out Qty',b'Out Kol'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'and unchcked Disabled in the',b'in unchcked Onemogo\xc4\x8deno v'
+b'apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +41',b'Series is mandatory',b'Serija je obvezna'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28',b'Financial Services',b'Finan\xc4\x8dne storitve'
+b'DocType: Student Sibling',b'Student ID',b'Student ID'
+b'apps/erpnext/erpnext/config/projects.py +51',b'Types of activities for Time Logs',b'Vrste dejavnosti za \xc4\x8cas Dnevniki'
+b'DocType: Opening Invoice Creation Tool',b'Sales',b'Prodaja'
+b'DocType: Stock Entry Detail',b'Basic Amount',b'Osnovni znesek'
+b'DocType: Training Event',b'Exam',b'Izpit'
+b'DocType: Complaint',b'Complaint',b'Prito\xc5\xbeba'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +462',b'Warehouse required for stock Item {0}',b'Skladi\xc5\xa1\xc4\x8de je potrebna za borzo postavki {0}'
+b'DocType: Leave Allocation',b'Unused leaves',b'Neizkori\xc5\xa1\xc4\x8dene listi'
+b'DocType: Patient',b'Alcohol Past Use',b'Pretekla uporaba alkohola'
+b'DocType: Fertilizer Content',b'Fertilizer Content',b'Vsebina gnojil'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +187',b'Cr',b'Cr'
+b'DocType: Project Update',b'Problematic/Stuck',b'Problemati\xc4\x8dno / Stuck'
+b'DocType: Tax Rule',b'Billing State',b'Dr\xc5\xbeava za zara\xc4\x8dunavanje'
+b'DocType: Share Transfer',b'Transfer',b'Prenos'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252',b'Work Order {0} must be cancelled before cancelling this Sales Order',b'Delovni nalog {0} morate preklicati pred preklicem tega prodajnega naloga'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +917',b'Fetch exploded BOM (including sub-assemblies)',b'Fetch eksplodiral BOM (vklju\xc4\x8dno podsklopov)'
+b'DocType: Authorization Rule',b'Applicable To (Employee)',b'Ki se uporabljajo za (zaposlenih)'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +137',b'Due Date is mandatory',b'Datum zapadlosti je obvezno'
+b'apps/erpnext/erpnext/controllers/item_variant.py +82',b'Increment for Attribute {0} cannot be 0',b'Prirastek za Attribute {0} ne more biti 0'
+b'apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19',b'Rooms Booked',b'Sobe Rezervirano'
+b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +57',b'Ends On date cannot be before Next Contact Date.',b'Konec Na datum ne more biti pred naslednjim datumom stika.'
+b'DocType: Journal Entry',b'Pay To / Recd From',b'Pay / Recd Od'
+b'DocType: Naming Series',b'Setup Series',b'Nastavitve zaporedja'
+b'DocType: Payment Reconciliation',b'To Invoice Date',b'\xc4\x8ce \xc5\xbeelite Datum ra\xc4\x8duna'
+b'DocType: Shareholder',b'Contact HTML',b'Kontakt HTML'
+b'apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19',b'Registration fee can not be Zero',b'Prijavnina ne sme biti ni\xc4\x8d'
+b'DocType: Disease',b'Treatment Period',b'Obdobje zdravljenja'
+b'apps/erpnext/erpnext/education/api.py +338',b'Result already Submitted',b'Rezultat \xc5\xbee oddan'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +169',b'Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied',b'Rezervirano skladi\xc5\xa1\xc4\x8de je obvezno za postavko {0} v dobavljenih surovinah'
+,b'Inactive Customers',b'neaktivne stranke'
+b'DocType: Student Admission Program',b'Maximum Age',b'Najvi\xc5\xa1ja starost'
+b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28',b'Please wait 3 days before resending the reminder.',b'Po\xc4\x8dakajte 3 dni pred ponovnim po\xc5\xa1iljanjem opomnika.'
+b'DocType: Landed Cost Voucher',b'LCV',b'LCV'
+b'DocType: Landed Cost Voucher',b'Purchase Receipts',b'Odkupne Prejemki'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29',b'How Pricing Rule is applied?',b'Kako se uporablja cenovno pravilo?'
+b'DocType: Stock Entry',b'Delivery Note No',b'Dostava Opomba Ne'
+b'DocType: Cheque Print Template',b'Message to show',b'Sporo\xc4\x8dilo za prikaz'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +28',b'Retail',b'Maloprodaja'
+b'DocType: Student Attendance',b'Absent',b'Odsoten'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591',b'Product Bundle',b'Bundle izdelek'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38',b'Unable to find score starting at {0}. You need to have standing scores covering 0 to 100',"b'Rezultate ni mogo\xc4\x8de najti od {0}. Imeti morate stoje\xc4\x8de rezultate, ki pokrivajo od 0 do 100'"
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212',b'Row {0}: Invalid reference {1}',b'Vrstica {0}: Neveljavna referen\xc4\x8dna {1}'
+b'DocType: Purchase Taxes and Charges Template',b'Purchase Taxes and Charges Template',b'Nakup davki in dajatve Template'
+b'DocType: Timesheet',b'TS-',b'TS-'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61',b'{0} {1}: Either debit or credit amount is required for {2}',b'{0} {1}: zahtevan je debetni ali kreditni znesek za {2}'
+b'DocType: GL Entry',b'Remarks',b'Opombe'
+b'DocType: Hotel Room Amenity',b'Hotel Room Amenity',b'Hotelska ugodnost'
+b'DocType: Payment Entry',b'Account Paid From',b'Ra\xc4\x8dun se pla\xc4\x8da iz'
+b'DocType: Purchase Order Item Supplied',b'Raw Material Item Code',b'Raw Material Oznaka'
+b'DocType: Task',b'Parent Task',b'Naloga star\xc5\xa1ev'
+b'DocType: Journal Entry',b'Write Off Based On',b'Odpisuje temelji na'
+b'apps/erpnext/erpnext/utilities/activation.py +65',b'Make Lead',b'Naredite Lead'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112',b'Print and Stationery',b'Tiskanje in Pisalne'
+b'DocType: Stock Settings',b'Show Barcode Field',b'Prika\xc5\xbei Barcode Field'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +809',b'Send Supplier Emails',b'Po\xc5\xa1lji Dobavitelj e-po\xc5\xa1te'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +96',"b'Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.'","b'Pla\xc4\x8da je \xc5\xbee pripravljena za obdobje med {0} in {1}, Pusti obdobje uporabe ne more biti med tem \xc4\x8dasovnem obdobju.'"
+b'DocType: Chapter Member',b'Leave Reason',b'Pustite razlog'
+b'DocType: Guardian Interest',b'Guardian Interest',b'Guardian Obresti'
+b'DocType: Volunteer',b'Availability',b'Razpolo\xc5\xbeljivost'
+b'apps/erpnext/erpnext/config/accounts.py +319',b'Setup default values for POS Invoices',b'Nastavitev privzetih vrednosti za ra\xc4\x8dune POS'
+b'apps/erpnext/erpnext/config/hr.py +182',b'Training',b'usposabljanje'
+b'DocType: Project',b'Time to send',b'\xc4\x8cas za po\xc5\xa1iljanje'
+b'DocType: Timesheet',b'Employee Detail',b'Podrobnosti zaposleni'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58',b'Guardian1 Email ID',b'Guardian1 E-ID'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58',b'Guardian1 Email ID',b'Guardian1 E-ID'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68',"b""Next Date's day and Repeat on Day of Month must be equal""","b'Naslednji datum za dan in ponovite na dnevih v mesecu, mora biti enaka'"
+b'DocType: Lab Prescription',b'Test Code',b'Testna koda'
+b'apps/erpnext/erpnext/config/website.py +11',b'Settings for website homepage',b'Nastavitve za spletni strani'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +40',b'RFQs are not allowed for {0} due to a scorecard standing of {1}',b'RFQ-ji niso dovoljeni za {0} zaradi postavke ocene rezultatov {1}'
+b'DocType: Job Offer',b'Awaiting Response',b'\xc4\x8cakanje na odgovor'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60',b'Above',b'Nad'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1466',b'Total Amount {0}',b'Skupni znesek {0}'
+b'apps/erpnext/erpnext/controllers/item_variant.py +306',b'Invalid attribute {0} {1}',b'Neveljaven atribut {0} {1}'
+b'DocType: Supplier',b'Mention if non-standard payable account',b'Omemba \xc4\x8de nestandardni pla\xc4\x8da ra\xc4\x8dun'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +25',"b""Please select the assessment group other than 'All Assessment Groups'""","b'Izberite ocenjevalne skupine, razen &quot;vseh skupin za presojo&quot;'"
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67',b'Row {0}: Cost center is required for an item {1}',b'Vrstica {0}: Za postavko je potreben stro\xc5\xa1kovni center {1}'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43',b'EcritureDate',b'EcritureDate'
+b'DocType: Training Event Employee',b'Optional',b'Neobvezno'
+b'DocType: Salary Slip',b'Earning & Deduction',b'Zaslu\xc5\xbeek &amp; Odbitek'
+b'DocType: Agriculture Analysis Criteria',b'Water Analysis',b'Analiza vode'
+b'DocType: Chapter',b'Region',b'Regija'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38',b'Optional. This setting will be used to filter in various transactions.',b'Neobvezno. Ta nastavitev bo uporabljena za filtriranje v razli\xc4\x8dnih poslih.'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +110',b'Negative Valuation Rate is not allowed',b'Negativno Oceni Vrednotenje ni dovoljeno'
+b'DocType: Holiday List',b'Weekly Off',b'Tedenski Off'
+b'apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7',b'Reload Linked Analysis',b'Ponovno nalo\xc5\xbei povezano analizo'
+b'DocType: Fiscal Year',"b'For e.g. 2012, 2012-13'","b'Za primer leta 2012, 2012-13'"
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96',b'Provisional Profit / Loss (Credit)',b'Za\xc4\x8dasna dobi\xc4\x8dek / izguba (Credit)'
+b'DocType: Sales Invoice',b'Return Against Sales Invoice',b'Vrni proti prodajne fakture'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32',b'Item 5',b'Postavka 5'
+b'DocType: Serial No',b'Creation Time',b'\xc4\x8cas ustvarjanja'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62',b'Total Revenue',b'Skupni prihodki'
+b'DocType: Patient',b'Other Risk Factors',b'Drugi dejavniki tveganja'
+b'DocType: Sales Invoice',b'Product Bundle Help',b'Izdelek Bundle Pomo\xc4\x8d'
+,b'Monthly Attendance Sheet',b'Mese\xc4\x8dni Udele\xc5\xbeba Sheet'
+b'apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py +15',b'No record found',b'Nobenega zapisa najdenih'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140',b'Cost of Scrapped Asset',b'Stro\xc5\xa1ki izlo\xc4\x8deni sredstvi'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +236',b'{0} {1}: Cost Center is mandatory for Item {2}',b'{0} {1}: Stro\xc5\xa1kovno mesto je zahtevano za postavko {2}'
+b'DocType: Vehicle',b'Policy No',b'Pravilnik \xc5\xa1t'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +686',b'Get Items from Product Bundle',b'Dobili predmetov iz Bundle izdelkov'
+b'DocType: Asset',b'Straight Line',b'Ravna \xc4\x8drta'
+b'DocType: Project User',b'Project User',b'projekt Uporabnik'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +72',b'Split',b'Split'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +72',b'Split',b'Split'
+b'DocType: GL Entry',b'Is Advance',b'Je Advance'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21',b'Attendance From Date and Attendance To Date is mandatory',b'Udele\xc5\xbeba Od datuma in udele\xc5\xbeba na Datum je obvezna'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +156',"b""Please enter 'Is Subcontracted' as Yes or No""","b'Prosimo, vpi\xc5\xa1ite &quot;Je v podizvajanje&quot;, kot DA ali NE'"
+b'DocType: Item',b'Default Purchase Unit of Measure',b'Privzeta nabavna enota ukrepa'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29',b'Last Communication Date',b'Zadnje Sporo\xc4\x8dilo Datum'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29',b'Last Communication Date',b'Zadnje Sporo\xc4\x8dilo Datum'
+b'DocType: Sales Team',b'Contact No.',b'Kontakt \xc5\xa1t.'
+b'DocType: Bank Reconciliation',b'Payment Entries',b'Pla\xc4\x8dilni vnosi'
+b'DocType: Land Unit',b'Land Unit Details',b'Podrobnosti o kopenskih enotah'
+b'DocType: Land Unit',b'Latitude',b'Zemljepisna \xc5\xa1irina'
+b'DocType: Work Order',b'Scrap Warehouse',b'ostanki Skladi\xc5\xa1\xc4\x8de'
+b'DocType: Work Order',b'Check if material transfer entry is not required',"b'Preverite, ali je vpis prenosa materiala ni potrebno'"
+b'DocType: Work Order',b'Check if material transfer entry is not required',"b'Preverite, ali je vpis prenosa materiala ni potrebno'"
+b'DocType: Program Enrollment Tool',b'Get Students From',b'Dobili \xc5\xa1tudenti iz'
+b'apps/erpnext/erpnext/config/learn.py +263',b'Publish Items on Website',b'Objavite elementov na spletni strani'
+b'apps/erpnext/erpnext/utilities/activation.py +126',b'Group your students in batches',b'Skupina u\xc4\x8denci v serijah'
+b'DocType: Authorization Rule',b'Authorization Rule',b'Dovoljenje Pravilo'
+b'DocType: POS Profile',b'Offline POS Section',b'Brezpla\xc4\x8den oddelek POS'
+b'DocType: Sales Invoice',b'Terms and Conditions Details',b'Pogoji in Podrobnosti'
+b'apps/erpnext/erpnext/templates/generators/item.html +100',b'Specifications',b'Tehni\xc4\x8dni podatki'
+b'DocType: Sales Taxes and Charges Template',b'Sales Taxes and Charges Template',b'Prodajne Davki in dajatve predloge'
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68',b'Total (Credit)',b'Skupaj (Credit)'
+b'DocType: Repayment Schedule',b'Payment Date',b'Dan pla\xc4\x8dila'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +122',b'New Batch Qty',b'Nova Serija Kol'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +122',b'New Batch Qty',b'Nova Serija Kol'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10',b'Apparel & Accessories',b'Obla\xc4\x8dila in dodatki'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91',b'Could not solve weighted score function. Make sure the formula is valid.',"b'Funkcije ute\xc5\xbeenih rezultatov ni bilo mogo\xc4\x8de re\xc5\xa1iti. Prepri\xc4\x8dajte se, da formula velja.'"
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67',b'Number of Order',b'\xc5\xa0tevilo reda'
+b'DocType: Item Group',b'HTML / Banner that will show on the top of product list.',"b'HTML pasica, ki se bo prikazala na vrhu seznama izdelkov.'"
+b'DocType: Shipping Rule',b'Specify conditions to calculate shipping amount',b'Navedite pogoje za izra\xc4\x8dun zneska ladijskega'
+b'DocType: Program Enrollment',"b""Institute's Bus""",b'In\xc5\xa1titutski avtobus'
+b'DocType: Accounts Settings',b'Role Allowed to Set Frozen Accounts & Edit Frozen Entries',"b'Vloga dovoliti, da dolo\xc4\x8dijo zamrznjenih ra\xc4\x8dunih in uredi Zamrznjen Entries'"
+b'DocType: Supplier Scorecard Scoring Variable',b'Path',b'Pot'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28',b'Cannot convert Cost Center to ledger as it has child nodes',"b'Ni mogo\xc4\x8de pretvoriti v stro\xc5\xa1kovni center za knjigo, saj ima otrok vozli\xc5\xa1\xc4\x8d'"
+b'DocType: Production Plan',b'Total Planned Qty',b'Skupno na\xc4\x8drtovano \xc5\xa1tevilo'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68',b'Opening Value',b'Otvoritev Vrednost'
+b'DocType: Salary Detail',b'Formula',b'Formula'
+b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47',b'Serial #',b'Serial #'
+b'DocType: Lab Test Template',b'Lab Test Template',b'Lab Test Template'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +181',b'Sales Account',b'Prodajni ra\xc4\x8dun'
+b'DocType: Purchase Invoice Item',b'Total Weight',b'Totalna te\xc5\xbea'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94',b'Commission on Sales',b'Komisija za prodajo'
+b'DocType: Job Offer Term',b'Value / Description',b'Vrednost / Opis'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +630',"b'Row #{0}: Asset {1} cannot be submitted, it is already {2}'","b'Row # {0}: Asset {1} ni mogo\xc4\x8de predlo\xc5\xbeiti, je \xc5\xbee {2}'"
+b'DocType: Tax Rule',b'Billing Country',b'Zara\xc4\x8dunavanje Dr\xc5\xbeava'
+b'DocType: Purchase Order Item',b'Expected Delivery Date',b'Pri\xc4\x8dakuje Dostava Datum'
+b'DocType: Restaurant Order Entry',b'Restaurant Order Entry',b'Vnos naro\xc4\x8dila restavracij'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +134',b'Debit and Credit not equal for {0} #{1}. Difference is {2}.',b'Debetnih in kreditnih ni enaka za {0} # {1}. Razlika je {2}.'
+b'DocType: Asset Maintenance Task',b'Assign To Name',b'Dodeli imenu'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98',b'Entertainment Expenses',b'Zabava Stro\xc5\xa1ki'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +98',b'Make Material Request',b'Naredite Zahteva material'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20',b'Open Item {0}',b'Odprti To\xc4\x8dka {0}'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222',b'Sales Invoice {0} must be cancelled before cancelling this Sales Order',b'Ra\xc4\x8dun {0} je potrebno preklicati pred preklicom tega prodajnega naro\xc4\x8dila'
+b'DocType: Consultation',b'Age',b'Starost'
+b'DocType: Sales Invoice Timesheet',b'Billing Amount',b'Zara\xc4\x8dunavanje Znesek'
+b'DocType: Cash Flow Mapping',b'Select Maximum Of 1',b'Izberite najve\xc4\x8d 1'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84',b'Invalid quantity specified for item {0}. Quantity should be greater than 0.',"b'Neveljavna koli\xc4\x8dina, dolo\xc4\x8dena za postavko {0}. Koli\xc4\x8dina mora biti ve\xc4\x8dja od 0.'"
+b'DocType: Company',b'Default Employee Advance Account',b'Privzeti ra\xc4\x8dun zaposlenega'
+b'apps/erpnext/erpnext/config/hr.py +60',b'Applications for leave.',b'Vloge za dopust.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +164',b'Account with existing transaction can not be deleted',b'Ra\xc4\x8dun z obstoje\xc4\x8dim poslom ni mogo\xc4\x8de izbrisati'
+b'DocType: Vehicle',b'Last Carbon Check',b'Zadnja Carbon Check'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102',b'Legal Expenses',b'Pravni stro\xc5\xa1ki'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140',b'Please select quantity on row ',b'Izberite koli\xc4\x8dino na vrsti'
+b'apps/erpnext/erpnext/config/accounts.py +277',b'Make Opening Sales and Purchase Invoices',b'Izdelava ra\xc4\x8dunov za prodajo in nakup'
+b'DocType: Purchase Invoice',b'Posting Time',b'Ura vnosa'
+b'DocType: Timesheet',b'% Amount Billed',b'% Zara\xc4\x8dunani znesek'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118',b'Telephone Expenses',b'Telefonske Stro\xc5\xa1ki'
+b'DocType: Sales Partner',b'Logo',b'Logo'
+b'DocType: Naming Series',b'Check this if you want to force the user to select a series before saving. There will be no default if you check this.',"b'Ozna\xc4\x8dite to, \xc4\x8de \xc5\xbeelite, da prisili uporabnika, da izberete vrsto pred shranjevanjem. Tam ne bo privzeto, \xc4\x8de to preverite.'"
+b'apps/erpnext/erpnext/stock/get_item_details.py +131',b'No Item with Serial No {0}',b'Ne Postavka s serijsko \xc5\xa1t {0}'
+b'DocType: Email Digest',b'Open Notifications',b'Odprte Obvestila'
+b'DocType: Payment Entry',b'Difference Amount (Company Currency)',b'Razlika Znesek (dru\xc5\xbeba Valuta)'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79',b'Direct Expenses',b'Neposredni stro\xc5\xa1ki'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60',b'New Customer Revenue',b'New Customer Prihodki'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119',b'Travel Expenses',b'Potni stro\xc5\xa1ki'
+b'DocType: Maintenance Visit',b'Breakdown',b'Zlomiti se'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50',b'Add custom field Subscription in the doctype {0}',b'Dodajanje po meri naro\xc4\x8denega polja v doctype {0}'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +820',b'Account: {0} with currency: {1} can not be selected',b'Ra\xc4\x8dun: {0} z valuti: ne more biti izbran {1}'
+b'DocType: Purchase Receipt Item',b'Sample Quantity',b'Koli\xc4\x8dina vzorca'
+b'DocType: Manufacturing Settings',"b'Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.'",b'Na podlagi najnovej\xc5\xa1ega razmerja cene / cene cenika / zadnje stopnje nakupa surovin samodejno posodobite stro\xc5\xa1ke BOM prek na\xc4\x8drtovalca.'
+b'DocType: Bank Reconciliation Detail',b'Cheque Date',b'\xc4\x8cek Datum'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +50',b'Account {0}: Parent account {1} does not belong to company: {2}',b'Ra\xc4\x8dun {0}: Mati\xc4\x8dni ra\xc4\x8dun {1} ne pripada podjetju: {2}'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +106',b'Successfully deleted all transactions related to this company!',b'Uspe\xc5\xa1no izbrisana vse transakcije v zvezi s to dru\xc5\xbebo!'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27',b'As on Date',b'Kot na datum'
+b'DocType: Appraisal',b'HR',b'\xc4\x8clove\xc5\xa1ki viri'
+b'DocType: Program Enrollment',b'Enrollment Date',b'Datum v\xc4\x8dlanitve'
+b'DocType: Healthcare Settings',b'Out Patient SMS Alerts',b'Out Patient SMS Opozorila'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100',b'Probation',b'Poskusno delo'
+b'apps/erpnext/erpnext/config/hr.py +115',b'Salary Components',b'komponente pla\xc4\x8de'
+b'DocType: Program Enrollment Tool',b'New Academic Year',b'Novo \xc5\xa1tudijsko leto'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +811',b'Return / Credit Note',b'Nazaj / dobropis'
+b'DocType: Stock Settings',b'Auto insert Price List rate if missing',b'Auto insert stopnja Cenik \xc4\x8de manjka'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +117',b'Total Paid Amount',b'Skupaj Pla\xc4\x8dan znesek'
+b'DocType: GST Settings',b'B2C Limit',b'Omejitev B2C'
+b'DocType: Work Order Item',b'Transferred Qty',b'Prenese Kol'
+b'apps/erpnext/erpnext/config/learn.py +11',b'Navigating',b'Krmarjenje'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188',b'Planning',b'Na\xc4\x8drtovanje'
+b'DocType: Share Balance',b'Issued',b'Izdala'
+b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14',b'Student Activity',b'\xc5\xa1tudent dejavnost'
+b'apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80',b'Supplier Id',b'Dobavitelj Id'
+b'DocType: Payment Request',b'Payment Gateway Details',b'Pla\xc4\x8dilo Gateway Podrobnosti'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +276',b'Quantity should be greater than 0',b'Koli\xc4\x8dina mora biti ve\xc4\x8dja od 0'
+b'DocType: Journal Entry',b'Cash Entry',b'Cash Za\xc4\x8detek'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17',"b""Child nodes can be only created under 'Group' type nodes""",b'Otro\xc5\xa1ki vozli\xc5\xa1\xc4\x8da lahko ustvari samo na podlagi tipa vozli\xc5\xa1\xc4\x8da &quot;skupina&quot;'
+b'DocType: Leave Application',b'Half Day Date',b'Poldnevni datum'
+b'DocType: Academic Year',b'Academic Year Name',b'Ime \xc5\xa1tudijsko leto'
+b'DocType: Sales Partner',b'Contact Desc',b'Kontakt opis izdelka'
+b'apps/erpnext/erpnext/config/hr.py +65',"b'Type of leaves like casual, sick etc.'","b'Vrsta listov kot prilo\xc5\xbenostno, bolni itd'"
+b'DocType: Email Digest',b'Send regular summary reports via Email.',b'Po\xc5\xa1lji redna zbirna poro\xc4\x8dila preko e-maila.'
+b'DocType: Payment Entry',b'PE-',b'PE-'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +282',b'Please set default account in Expense Claim Type {0}',"b'Prosim, nastavite privzetega ra\xc4\x8duna v Tip Expense Terjatve {0}'"
+b'DocType: Assessment Result',b'Student Name',b'Student Ime'
+b'DocType: Brand',b'Item Manager',b'Element Manager'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143',b'Payroll Payable',b'Pla\xc4\x8de pla\xc4\x8dljivo'
+b'DocType: Buying Settings',b'Default Supplier Type',b'Privzeta Dobavitelj Type'
+b'DocType: Plant Analysis',b'Collection Datetime',b'Zbirka Datetime'
+b'DocType: Work Order',b'Total Operating Cost',b'Skupni operativni stro\xc5\xa1ki'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171',b'Note: Item {0} entered multiple times',b'Opomba: To\xc4\x8dka {0} vpisana ve\xc4\x8dkrat'
+b'apps/erpnext/erpnext/config/selling.py +41',b'All Contacts.',b'Vsi stiki.'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +71',b'Company Abbreviation',b'Kratica podjetja'
+b'apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +47',b'User {0} does not exist',b'Uporabnik {0} ne obstaja'
+b'DocType: Payment Term',b'Day(s) after invoice date',b'Dan (dan) po datumu ra\xc4\x8duna'
+b'DocType: Payment Schedule',b'Payment Schedule',b'Urnik pla\xc4\x8dila'
+b'DocType: Subscription',b'SUB-',b'SUB-'
+b'DocType: Item Attribute Value',b'Abbreviation',b'Kratica'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +195',b'Payment Entry already exists',b'Pla\xc4\x8dilo vnos \xc5\xbee obstaja'
+b'apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36',b'Not authroized since {0} exceeds limits',"b'Ne authroized saj je {0}, presega meje'"
+b'apps/erpnext/erpnext/config/hr.py +110',b'Salary template master.',b'Pla\xc4\x8da predlogo gospodar.'
+b'apps/erpnext/erpnext/healthcare/setup.py +241',b'Pathology',b'Patologija'
+b'DocType: Restaurant Order Entry',b'Restaurant Table',b'Restavracija Tabela'
+b'DocType: Hotel Room',b'Hotel Manager',b'Hotel Manager'
+b'DocType: Leave Type',b'Max Days Leave Allowed',b'Max dni dopusta Dovoljeno'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63',b'Set Tax Rule for shopping cart',b'Nastavite Dav\xc4\x8dna pravilo za nakupovalno ko\xc5\xa1arico'
+b'DocType: Purchase Invoice',b'Taxes and Charges Added',b'Davki in dajatve Dodano'
+,b'Sales Funnel',b'Prodaja toka'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +49',b'Abbreviation is mandatory',b'Kratica je obvezna'
+b'DocType: Project',b'Task Progress',b'naloga Progress'
+b'apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7',b'Cart',b'Ko\xc5\xa1arica'
+,b'Qty to Transfer',b'Koli\xc4\x8dina Prenos'
+b'apps/erpnext/erpnext/config/selling.py +13',b'Quotes to Leads or Customers.',b'Ponudbe za interesente ali stranke.'
+b'DocType: Stock Settings',b'Role Allowed to edit frozen stock',b'Vloga Dovoljeno urediti zamrznjeno zalog'
+,b'Territory Target Variance Item Group-Wise',b'Ozemlje Ciljna Varianca Postavka Group-Wise'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143',b'All Customer Groups',b'Vse skupine strank'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114',b'Accumulated Monthly',b'Bilan\xc4\x8dni Mese\xc4\x8dni'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +781',b'{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.',b'{0} je obvezen. Mogo\xc4\x8de zapis Menjalnega te\xc4\x8daja ni ustvarjen za {1} v {2}.'
+b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +44',b'Tax Template is mandatory.',b'Dav\xc4\x8dna Predloga je obvezna.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +44',b'Account {0}: Parent account {1} does not exist',b'Ra\xc4\x8dun {0}: Mati\xc4\x8dni ra\xc4\x8dun {1} ne obstaja'
+b'DocType: Purchase Invoice Item',b'Price List Rate (Company Currency)',b'Cenik Rate (dru\xc5\xbeba Valuta)'
+b'DocType: Products Settings',b'Products Settings',b'Nastavitve izdelki'
+,b'Item Price Stock',b'Cena artikla'
+b'DocType: Lab Prescription',b'Test Created',b'Ustvarjeno testiranje'
+b'DocType: Healthcare Settings',b'Custom Signature in Print',b'Podpis po meri v tisku'
+b'DocType: Account',b'Temporary',b'Za\xc4\x8dasna'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +107',b'Customer LPO No.',b'Stranka LPO \xc5\xa1t.'
+b'DocType: Program',b'Courses',b'Te\xc4\x8daji'
+b'DocType: Monthly Distribution Percentage',b'Percentage Allocation',b'Odstotek dodelitve'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128',b'Secretary',b'Sekretar'
+b'DocType: Global Defaults',"b""If disable, 'In Words' field will not be visible in any transaction""","b'\xc4\x8ce onemogo\xc4\x8diti, &quot;z besedami&quot; polja ne bo vidna v vsakem poslu'"
+b'DocType: Serial No',b'Distinct unit of an Item',b'Lo\xc4\x8dena enota Postavka'
+b'DocType: Supplier Scorecard Criteria',b'Criteria Name',b'Ime merila'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1295',b'Please set Company',b'Nastavite Company'
+b'DocType: Pricing Rule',b'Buying',b'Nabava'
+b'apps/erpnext/erpnext/config/agriculture.py +24',b'Diseases & Fertilizers',b'Bolezni in gnojila'
+b'DocType: HR Settings',b'Employee Records to be created by',"b'Zapisi zaposlenih, ki ga povzro\xc4\x8dajo'"
+b'DocType: Patient',b'AB Negative',b'AB Negativno'
+b'DocType: Sample Collection',b'SMPL-',b'SMPL-'
+b'DocType: POS Profile',b'Apply Discount On',b'Uporabi popust na'
+b'DocType: Member',b'Membership Type',b'Vrsta \xc4\x8dlanstva'
+,b'Reqd By Date',b'Reqd po Datum'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140',b'Creditors',b'Upniki'
+b'DocType: Assessment Plan',b'Assessment Name',b'Ime ocena'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +94',b'Show PDC in Print',b'Prika\xc5\xbeite PDC v tisku'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +97',b'Row # {0}: Serial No is mandatory',b'Vrstica # {0}: Zaporedna \xc5\xa1tevilka je obvezna'
+b'DocType: Purchase Taxes and Charges',b'Item Wise Tax Detail',b'Postavka Wise Dav\xc4\x8dna Detail'
+b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13',b'Job Offer',b'Zaposlitvena ponudba'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +71',b'Institute Abbreviation',b'Kratica in\xc5\xa1tituta'
+,b'Item-wise Price List Rate',b'Element-pametno Cenik Rate'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1082',b'Supplier Quotation',b'Dobavitelj za predra\xc4\x8dun'
+b'DocType: Quotation',b'In Words will be visible once you save the Quotation.',"b'V besedi bo viden, ko boste prihranili citata.'"
+b'apps/erpnext/erpnext/utilities/transaction_base.py +164',b'Quantity ({0}) cannot be a fraction in row {1}',b'Koli\xc4\x8dina ({0}) ne more biti komponenta v vrstici {1}'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +164',b'Quantity ({0}) cannot be a fraction in row {1}',b'Koli\xc4\x8dina ({0}) ne more biti komponenta v vrstici {1}'
+b'DocType: Consultation',b'C-',b'C-'
+b'DocType: Attendance',b'ATT-',b'ATT-'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +492',b'Barcode {0} already used in Item {1}',b'Barcode {0} \xc5\xbee uporabljajo v postavki {1}'
+b'apps/erpnext/erpnext/config/selling.py +86',b'Rules for adding shipping costs.',b'Pravila za dodajanje stro\xc5\xa1kov dostave.'
+b'DocType: Hotel Room',b'Extra Bed Capacity',b'Zmogljivost dodatnega le\xc5\xbei\xc5\xa1\xc4\x8da'
+b'DocType: Item',b'Opening Stock',b'Za\xc4\x8detna zaloga'
+b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20',b'Customer is required',b'Je potrebno kupca'
+b'DocType: Lab Test',b'Result Date',b'Datum oddaje'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +77',b'PDC/LC Date',b'PDC / LC Datum'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20',b'{0} is mandatory for Return',b'{0} je obvezen za povra\xc4\x8dilo'
+b'DocType: Purchase Order',b'To Receive',b'Prejeti'
+b'apps/erpnext/erpnext/utilities/user_progress.py +252',b'user@example.com',b'user@example.com'
+b'DocType: Asset',b'Asset Owner',b'Lastnik sredstev'
+b'DocType: Employee',b'Personal Email',b'Osebna Email'
+b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57',b'Total Variance',b'Skupne variance'
+b'DocType: Accounts Settings',"b'If enabled, the system will post accounting entries for inventory automatically.'","b'\xc4\x8ce je omogo\xc4\x8deno, bo sistem objavili ra\xc4\x8dunovodske vnose za popis samodejno.'"
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15',b'Brokerage',b'Posredni\xc5\xa1tvo'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +195',b'Attendance for employee {0} is already marked for this day',b'Udele\xc5\xbeba na zaposlenega {0} je \xc5\xbee ozna\xc4\x8den za ta dan'
+b'DocType: Work Order Operation',"b""in Minutes\nUpdated via 'Time Log'""",b'v minutah Posodobljeno preko &quot;\xc4\x8cas Logu&quot;'
+b'DocType: Customer',b'From Lead',b'Iz ponudbe'
+b'apps/erpnext/erpnext/config/manufacturing.py +13',b'Orders released for production.',b'Naro\xc4\x8dila sprosti za proizvodnjo.'
+b'apps/erpnext/erpnext/public/js/account_tree_grid.js +65',b'Select Fiscal Year...',b'Izberite poslovno leto ...'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +567',b'POS Profile required to make POS Entry',"b'POS Profil zahteva, da POS Entry'"
+b'DocType: Program Enrollment Tool',b'Enroll Students',b'v\xc4\x8dlanite \xc5\xa0tudenti'
+b'DocType: Lab Test',b'Approved Date',b'Odobren datum'
+b'apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21',b'Standard Selling',b'Standardna Prodaja'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +165',b'Atleast one warehouse is mandatory',b'Atleast eno skladi\xc5\xa1\xc4\x8de je obvezna'
+b'DocType: Serial No',b'Out of Warranty',b'Iz garancije'
+b'DocType: BOM Update Tool',b'Replace',b'Zamenjaj'
+b'apps/erpnext/erpnext/templates/includes/product_list.js +42',b'No products found.',b'Ni izdelkov.'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360',b'{0} against Sales Invoice {1}',b'{0} za Ra\xc4\x8dun {1}'
+b'DocType: Antibiotic',b'Laboratory User',b'Laboratorijski uporabnik'
+b'DocType: Sales Invoice',b'SINV-',b'SINV-'
+b'DocType: Request for Quotation Item',b'Project Name',b'Ime projekta'
+b'DocType: Customer',b'Mention if non-standard receivable account',b'Omemba \xc4\x8de nestandardno terjatve ra\xc4\x8dun'
+b'DocType: Journal Entry Account',b'If Income or Expense',b'\xc4\x8ce prihodek ali odhodek'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +288',b'Select interest income account in employee loan {0}',b'Izberite ra\xc4\x8dun obrestnih prihodkov v posojilu zaposlenih {0}'
+b'DocType: Work Order',b'Required Items',b'Zahtevani To\xc4\x8dke'
+b'DocType: Stock Ledger Entry',b'Stock Value Difference',b'Stock Value Razlika'
+b'apps/erpnext/erpnext/config/learn.py +229',b'Human Resource',b'\xc4\x8clove\xc5\xa1ki vir'
+b'DocType: Payment Reconciliation Payment',b'Payment Reconciliation Payment',b'Pla\xc4\x8dilo Sprava Pla\xc4\x8dilo'
+b'DocType: Disease',b'Treatment Task',b'Naloga zdravljenja'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38',b'Tax Assets',b'Dav\xc4\x8dni Sredstva'
+b'DocType: BOM Item',b'BOM No',b'BOM Ne'
+b'DocType: Instructor',b'INS/',b'INS /'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +160',b'Journal Entry {0} does not have account {1} or already matched against other voucher',b'Journal Entry {0} nima ra\xc4\x8duna {1} ali \xc5\xbee primerjali z drugimi kupon'
+b'DocType: Item',b'Moving Average',b'Moving Average'
+b'DocType: BOM Update Tool',b'The BOM which will be replaced',b'BOM ki bo nadomestila'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46',b'Electronic Equipments',b'elektronske naprave'
+b'DocType: Asset',b'Maintenance Required',b'Potrebno vzdr\xc5\xbeevanje'
+b'DocType: Account',b'Debit',b'Debet'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49',b'Leaves must be allocated in multiples of 0.5',b'Listi morajo biti dodeljen v ve\xc4\x8dkratnikih 0.5'
+b'DocType: Work Order',b'Operation Cost',b'Delovanje Stro\xc5\xa1ki'
+b'apps/erpnext/erpnext/config/hr.py +29',b'Upload attendance from a .csv file',b'Nalo\xc5\xbei udele\xc5\xbebo iz .csv datoteke'
+b'apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45',b'Outstanding Amt',b'Izjemna Amt'
+b'DocType: Sales Person',b'Set targets Item Group-wise for this Sales Person.',b'Dolo\xc4\x8diti cilje Postavka Group-pametno za te prodaje oseba.'
+b'DocType: Stock Settings',b'Freeze Stocks Older Than [Days]',b'Freeze Zaloge Older Than [dni]'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +600',b'Row #{0}: Asset is mandatory for fixed asset purchase/sale',b'Row # {0}: Sredstvo je obvezna za osnovno sredstvo nakupu / prodaji'
+b'DocType: Asset Maintenance Team',b'Maintenance Team Name',b'Ime ekipe za vzdr\xc5\xbeevanje'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42',"b'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.'","b'\xc4\x8ce dva ali ve\xc4\x8d Cenik Pravilnik ugotovila na podlagi zgoraj navedenih pogojev, se uporablja Prioriteta. Prednostno je \xc5\xa1tevilo med 0 do 20, medtem ko privzeta vrednost ni\xc4\x8d (prazno). Vi\xc5\xa1ja \xc5\xa1tevilka pomeni, da bo prednost, \xc4\x8de obstaja ve\xc4\x8d cenovnih Pravila z enakimi pogoji.'"
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +197',"b""Customer is mandatory if 'Opportunity From' is selected as Customer""","b'Stranka je obvezna, \xc4\x8de je \xc2\xbbMo\xc5\xbenost od\xc2\xab izbrana kot naro\xc4\x8dnik'"
+b'apps/erpnext/erpnext/controllers/trends.py +36',b'Fiscal Year: {0} does not exists',b'Poslovno leto: {0} ne obstaja'
+b'DocType: Currency Exchange',b'To Currency',b'Valutnemu'
+b'DocType: Leave Block List',b'Allow the following users to approve Leave Applications for block days.',"b'Pustimo, da se naslednji uporabniki za odobritev dopusta Aplikacije za blok dni.'"
+b'apps/erpnext/erpnext/config/hr.py +137',b'Types of Expense Claim.',b'Vrste Expense zahtevka.'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +148',b'Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2}',b'stopnjo za zapisu Prodajni {0} ni\xc5\xbeja kot njegovi {1}. Prodajni manj morajo vsebovati vsaj {2}'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +148',b'Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2}',b'stopnjo za zapisu Prodajni {0} ni\xc5\xbeja kot njegovi {1}. Prodajni manj morajo vsebovati vsaj {2}'
+b'DocType: Item',b'Taxes',b'Davki'
+b'DocType: Purchase Invoice',b'capital goods',b'investicijsko blago'
+b'DocType: Purchase Invoice Item',b'Weight Per Unit',b'Te\xc5\xbea na enoto'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344',b'Paid and Not Delivered',b'Pla\xc4\x8dana in ni podal'
+b'DocType: Project',b'Default Cost Center',b'Privzet Stro\xc5\xa1kovni Center'
+b'DocType: Bank Guarantee',b'End Date',b'Kon\xc4\x8dni datum'
+b'apps/erpnext/erpnext/config/stock.py +7',b'Stock Transactions',b'Zaloga Transakcije'
+b'DocType: Budget',b'Budget Accounts',b'Prora\xc4\x8dun ra\xc4\x8duni'
+b'DocType: Employee',b'Internal Work History',b'Notranji Delo Zgodovina'
+b'DocType: Depreciation Schedule',b'Accumulated Depreciation Amount',b'Bilan\xc4\x8dni Amortizacija Znesek'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42',b'Private Equity',b'Private Equity'
+b'DocType: Supplier Scorecard Variable',b'Supplier Scorecard Variable',b'Spremenljivka Scorecard spremenljivke'
+b'DocType: Employee Loan',b'Fully Disbursed',b'celoti izpla\xc4\x8dano'
+b'DocType: Employee Advance',b'Due Advance Amount',b'Znesek vnaprej vnaprej'
+b'DocType: Maintenance Visit',b'Customer Feedback',b'Customer Feedback'
+b'DocType: Account',b'Expense',b'Expense'
+b'apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +54',b'Score cannot be greater than Maximum Score',b'Rezultat ne sme biti ve\xc4\x8dja od najvi\xc5\xa1jo oceno'
+b'apps/erpnext/erpnext/utilities/user_progress.py +129',b'Customers and Suppliers',b'Kupci in dobavitelji'
+b'DocType: Item Attribute',b'From Range',b'Od Obmo\xc4\x8dje'
+b'DocType: BOM',b'Set rate of sub-assembly item based on BOM',b'Nastavite koli\xc4\x8dino predmeta sestavljanja na podlagi BOM'
+b'DocType: Hotel Room Reservation',b'Invoiced',b'Fakturirani'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98',b'Syntax error in formula or condition: {0}',b'Skladenjska napaka v formuli ali stanje: {0}'
+b'DocType: Daily Work Summary Settings Company',b'Daily Work Summary Settings Company',b'Daily Delo Povzetek Nastavitve Company'
+b'apps/erpnext/erpnext/stock/utils.py +125',b'Item {0} ignored since it is not a stock item',"b'Postavka {0} prezrta, ker ne gre za element parka'"
+b'DocType: Appraisal',b'APRSL',b'APRSL'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23',"b'To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.'","b'Da ne uporabljajo Cenovno pravilo v posameznem poslu, bi morali vsi, ki se uporabljajo pravila za oblikovanje cen so onemogo\xc4\x8deni.'"
+b'DocType: Payment Term',b'Day(s) after the end of the invoice month',b'Dan (e) po koncu ra\xc4\x8duna na mesec'
+b'DocType: Assessment Group',b'Parent Assessment Group',b'Skupina Ocena Parent'
+b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27',b'Jobs',b'Jobs'
+,b'Sales Order Trends',b'Sales Order Trendi'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51',"b""The 'From Package No.' field must neither be empty nor it's value less than 1.""",b'&quot;Od paketa \xc5\xa1t.&quot; polje ne sme biti prazno niti je vrednost manj\xc5\xa1a od 1.'
+b'DocType: Employee',b'Held On',b'Datum'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +36',b'Production Item',b'Proizvodnja Postavka'
+,b'Employee Information',b'Informacije zaposleni'
+b'DocType: Stock Entry Detail',b'Additional Cost',b'Dodatne Stro\xc5\xa1ki'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +48',"b'Can not filter based on Voucher No, if grouped by Voucher'","b'Filter ne more temeljiti na kupona \xc5\xa1t, \xc4\x8de je zdru\xc5\xbeena s Voucher'"
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +918',b'Make Supplier Quotation',b'Naredite Dobavitelj predra\xc4\x8dun'
+b'DocType: Quality Inspection',b'Incoming',b'Dohodni'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +70',b'Default tax templates for sales and purchase are created.',b'Ustvari so privzete dav\xc4\x8dne predloge za prodajo in nakup.'
+b'apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +57',b'Assessment Result record {0} already exists.',b'Ocenjevanje Rezultat zapisa {0} \xc5\xbee obstaja.'
+b'DocType: BOM',b'Materials Required (Exploded)',b'Potreben materiali (eksplodirala)'
+b'apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60',"b""Please set Company filter blank if Group By is 'Company'""","b'Nastavite Podjetje filtriranje prazno, \xc4\x8de skupina Z je &quot;Podjetje&quot;'"
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66',b'Posting Date cannot be future date',b'Napotitev datum ne more biti prihodnji datum'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +102',b'Row # {0}: Serial No {1} does not match with {2} {3}',b'Vrstica # {0}: Serijska \xc5\xa1t {1} ne ujema z {2} {3}'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10',b'for generating the recurring',b'za generiranje ponavljajo\xc4\x8dih se'
+b'DocType: Stock Entry',b'Target Warehouse Address',b'Naslov tar\xc4\x8de skladi\xc5\xa1\xc4\x8da'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86',b'Casual Leave',b'Casual Zapusti'
+b'DocType: Agriculture Task',b'End Day',b'Konec dneva'
+b'DocType: Batch',b'Batch ID',b'Serija ID'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380',b'Note: {0}',b'Opomba: {0}'
+,b'Delivery Note Trends',b'Dobavnica Trendi'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112',"b""This Week's Summary""",b'Povzetek Ta teden je'
+b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22',b'In Stock Qty',b'Na zalogi Koli\xc4\x8dina'
+b'DocType: Delivery Trip',b'Calculate Estimated Arrival Times',b'Izra\xc4\x8dunajte predvideni \xc4\x8das prihoda'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +113',b'Account: {0} can only be updated via Stock Transactions',b'Ra\xc4\x8dun: {0} se lahko posodobi samo preko delni\xc5\xa1kih poslov'
+b'DocType: Student Group Creation Tool',b'Get Courses',b'Get Te\xc4\x8daji'
+b'DocType: GL Entry',b'Party',b'Zabava'
+b'DocType: Healthcare Settings',b'Patient Name',b'Ime bolnika'
+b'DocType: Variant Field',b'Variant Field',b'Razli\xc4\x8dno polje'
+b'DocType: Sales Order',b'Delivery Date',b'Datum dostave'
+b'DocType: Opportunity',b'Opportunity Date',b'Prilo\xc5\xbenost Datum'
+b'DocType: Employee',b'Health Insurance Provider',b'Ponudnik zdravstvenega zavarovanja'
+b'DocType: Purchase Receipt',b'Return Against Purchase Receipt',b'Vrni Proti Potrdilo o nakupu'
+b'DocType: Water Analysis',b'Person Responsible',b'Odgovorna oseba'
+b'DocType: Request for Quotation Item',b'Request for Quotation Item',b'Zahteva za ponudbo to\xc4\x8dki'
+b'DocType: Purchase Order',b'To Bill',b'Billu'
+b'DocType: Material Request',b'% Ordered',b'% Naro\xc4\x8deno'
+b'DocType: Education Settings',"b'For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.'","b'Za \xc5\xa0tudentske skupine temelji igri\xc5\xa1\xc4\x8de, bo te\xc4\x8daj se potrdi za vsakega \xc5\xa1tudenta od vpisanih Te\xc4\x8daji v programu vpis.'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103',b'Piecework',b'Akord'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70',b'Avg. Buying Rate',b'Avg. Odkup te\xc4\x8daj'
+b'DocType: Share Balance',b'From No',b'Od \xc5\xa1t'
+b'DocType: Task',b'Actual Time (in Hours)',b'Dejanski \xc4\x8das (v urah)'
+b'DocType: Employee',b'History In Company',b'Zgodovina v dru\xc5\xbebi'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +270',b'New Message from {sender}',b'Novo sporo\xc4\x8dilo od {po\xc5\xa1iljatelja}'
+b'DocType: Customer',b'Customer Primary Address',b'Primarni naslov stranke'
+b'apps/erpnext/erpnext/config/learn.py +107',b'Newsletters',b'Glasila'
+b'DocType: Drug Prescription',b'Description/Strength',b'Opis / mo\xc4\x8d'
+b'DocType: Share Balance',b'Is Company',b'Je podjetje'
+b'DocType: Stock Ledger Entry',b'Stock Ledger Entry',b'Stock Ledger Entry'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83',b'Same item has been entered multiple times',b'Enako postavka je bila vpisana ve\xc4\x8dkrat'
+b'DocType: Department',b'Leave Block List',b'Pustite Block List'
+b'DocType: Purchase Invoice',b'Tax ID',b'Dav\xc4\x8dna \xc5\xa1tevilka'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192',b'Item {0} is not setup for Serial Nos. Column must be blank',b'Postavka {0} ni setup za Serijska \xc5\xa1t. Kolona mora biti prazno'
+b'DocType: Accounts Settings',b'Accounts Settings',b'Ra\xc4\x8duni Nastavitve'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11',b'Approve',b'odobri'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +69',"b'Malformatted address for {0}, please fix to continue.'","b'Malformatiran naslov za {0}, popravite, da nadaljujete.'"
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28',"b'Number of new Account, it will be included in the account name as a prefix'",b'\xc5\xa0tevilka novega ra\xc4\x8duna bo vklju\xc4\x8dena v ime ra\xc4\x8duna kot predpono'
+b'DocType: Maintenance Team Member',b'Team Member',b'\xc4\x8clan ekipe'
+b'apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151',b'No Result to submit',b'Ni zadetka'
+b'DocType: Customer',b'Sales Partner and Commission',b'Prodaja Partner in Komisija'
+b'DocType: Employee Loan',b'Rate of Interest (%) / Year',b'Obrestna mera (%) / leto'
+,b'Project Quantity',b'projekt Koli\xc4\x8dina'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79',"b""Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'""","b'Skupno {0} za vse postavke je ni\xc4\x8d, morda bi morali spremeniti &quot;Razdeli stro\xc5\xa1kov na osnovi&quot;'"
+b'DocType: Opportunity',b'To Discuss',b'Razpravljati'
+b'apps/erpnext/erpnext/stock/stock_ledger.py +377',b'{0} units of {1} needed in {2} to complete this transaction.',b'{0} enot {1} potrebnih v {2} za dokon\xc4\x8danje te transakcije.'
+b'DocType: Loan Type',b'Rate of Interest (%) Yearly',b'Obrestna mera (%) Letna'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71',b'Temporary Accounts',b'Za\xc4\x8dasni ra\xc4\x8duni'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207',b'Black',b'\xc4\x8crna'
+b'DocType: BOM Explosion Item',b'BOM Explosion Item',b'BOM Eksplozija Postavka'
+b'DocType: Shareholder',b'Contact List',b'Seznam kontaktov'
+b'DocType: Account',b'Auditor',b'Revizor'
+b'DocType: Project',b'Frequency To Collect Progress',b'Frekvenca za zbiranje napredka'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +132',b'{0} items produced',b'{0} postavke proizvedene'
+b'apps/erpnext/erpnext/utilities/user_progress.py +58',b'Learn More',b'Nau\xc4\x8di se ve\xc4\x8d'
+b'DocType: Cheque Print Template',b'Distance from top edge',b'Oddaljenost od zgornjega roba'
+b'apps/erpnext/erpnext/stock/get_item_details.py +367',b'Price List {0} is disabled or does not exist',b'Cenik {0} je onemogo\xc4\x8dena ali pa ne obstaja'
+b'DocType: Purchase Invoice',b'Return',b'Return'
+b'DocType: Pricing Rule',b'Disable',b'Onemogo\xc4\x8di'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +180',b'Mode of payment is required to make a payment',"b'Na\xc4\x8din pla\xc4\x8dila je potrebno, da bi pla\xc4\x8dilo'"
+b'DocType: Project Task',b'Pending Review',b'Dokler Pregled'
+b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14',"b'Edit in full page for more options like assets, serial nos, batches etc.'","b'Uredite na celotni strani za ve\xc4\x8d mo\xc5\xbenosti, kot so sredstva, serijski nosi, serije itd.'"
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10',b'Appointments and Consultations',b'Imenovanja in posvetovanja'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41',b'{0} - {1} is not enrolled in the Batch {2}',b'{0} - {1} ni vpisan v serijo {2}'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113',"b'Asset {0} cannot be scrapped, as it is already {1}'","b'Sredstvo {0} ne more biti izlo\xc4\x8deni, saj je \xc5\xbee {1}'"
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +77',b'Cheques Required',b'Potrebna je preverjanja'
+b'DocType: Task',b'Total Expense Claim (via Expense Claim)',b'Total Expense zahtevek (preko Expense zahtevka)'
+b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177',b'Mark Absent',b'Mark Odsoten'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40',b'Failed to setup company',b'Podjetje za nastavitev ni uspelo'
+b'DocType: Asset Repair',b'Asset Repair',b'Popravilo sredstev'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +143',b'Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2}',b'Vrstica {0}: Valuta BOM # {1} mora biti enaka izbrani valuti {2}'
+b'DocType: Journal Entry Account',b'Exchange Rate',b'Menjalni te\xc4\x8daj'
+b'DocType: Patient',b'Additional information regarding the patient',b'Dodatne informacije o bolniku'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +585',b'Sales Order {0} is not submitted',b'Naro\xc4\x8dilo {0} ni predlo\xc5\xbeeno'
+b'DocType: Homepage',b'Tag Line',b'tag Line'
+b'DocType: Fee Component',b'Fee Component',b'Fee Component'
+b'apps/erpnext/erpnext/config/hr.py +204',b'Fleet Management',b'Fleet management'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1080',b'Add items from',b'Dodaj artikle iz'
+b'apps/erpnext/erpnext/config/agriculture.py +7',b'Crops & Lands',b'Rastline in zemlji\xc5\xa1\xc4\x8da'
+b'DocType: Cheque Print Template',b'Regular',b'redno'
+b'DocType: Fertilizer',b'Density (if liquid)',b'Gostota (\xc4\x8de je teko\xc4\x8da)'
+b'apps/erpnext/erpnext/education/doctype/course/course.py +20',b'Total Weightage of all Assessment Criteria must be 100%',b'Skupaj weightage vseh ocenjevalnih meril mora biti 100%'
+b'DocType: Purchase Order Item',b'Last Purchase Rate',b'Zadnja Purchase Rate'
+b'DocType: Account',b'Asset',b'Asset'
+b'DocType: Project Task',b'Task ID',b'Naloga ID'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84',b'Stock cannot exist for Item {0} since has variants',"b'Stock ne more obstajati za postavko {0}, saj ima variant'"
+b'DocType: Lab Test',b'Mobile',b'Mobile'
+,b'Sales Person-wise Transaction Summary',b'Prodaja Oseba pametno Transakcijski Povzetek'
+b'DocType: Training Event',b'Contact Number',b'Kontaktna \xc5\xa1tevilka'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +73',b'Warehouse {0} does not exist',b'Skladi\xc5\xa1\xc4\x8de {0} ne obstaja'
+b'DocType: Monthly Distribution',b'Monthly Distribution Percentages',b'Mese\xc4\x8dni Distribucijski Odstotki'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +110',b'The selected item cannot have Batch',b'Izbrana postavka ne more imeti Batch'
+b'DocType: Delivery Note',b'% of materials delivered against this Delivery Note',b'% materiala dobavljeno po tej dobavnici'
+b'DocType: Asset Maintenance Log',b'Has Certificate',b'Ima certifikat'
+b'DocType: Project',b'Customer Details',b'Podrobnosti strank'
+b'DocType: Asset',b'Check if Asset requires Preventive Maintenance or Calibration',"b'Preverite, ali sredstva potrebujejo preventivno vzdr\xc5\xbeevanje ali kalibracijo'"
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +87',b'Company Abbreviation cannot have more than 5 characters',b'Kratica podjetja ne sme imeti ve\xc4\x8d kot 5 znakov'
+b'DocType: Employee',b'Reports to',b'Poro\xc4\x8dila'
+,b'Unpaid Expense Claim',b'Nepla\xc4\x8dana Expense zahtevek'
+b'DocType: Payment Entry',b'Paid Amount',b'Znesek Pla\xc4\x8dila'
+b'apps/erpnext/erpnext/utilities/user_progress.py +158',b'Explore Sales Cycle',b'Razi\xc5\xa1\xc4\x8dite prodajne cikle'
+b'DocType: Assessment Plan',b'Supervisor',b'nadzornik'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +869',b'Retention Stock Entry',b'Vstop v zaloge'
+,b'Available Stock for Packing Items',b'Zaloga za embalirane izdelke'
+b'DocType: Item Variant',b'Item Variant',b'Postavka Variant'
+,b'Work Order Stock Report',b'Poro\xc4\x8dilo o delovni nalogi'
+b'DocType: Assessment Result Tool',b'Assessment Result Tool',b'Ocena Rezultat orodje'
+b'apps/erpnext/erpnext/education/doctype/instructor/instructor.js +24',b'As Supervisor',b'Kot nadzornik'
+b'DocType: BOM Scrap Item',b'BOM Scrap Item',b'BOM Odpadno Item'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +895',b'Submitted orders can not be deleted',b'Predlo\xc5\xbeene naro\xc4\x8dila ni mogo\xc4\x8de izbrisati'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +114',"b""Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'""","b'Stanje na ra\xc4\x8dunu je \xc5\xbee ""bremenitev"", ni dovoljeno nastaviti ""Stanje mora biti"" kot ""kredit""'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118',b'Quality Management',b'Upravljanje kakovosti'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +41',b'Item {0} has been disabled',b'To\xc4\x8dka {0} je bila onemogo\xc4\x8dena'
+b'DocType: Project',b'Total Billable Amount (via Timesheets)',b'Skupni znesek zneska (prek \xc4\x8dasopisov)'
+b'DocType: Agriculture Task',b'Previous Business Day',b'Prej\xc5\xa1nji delovni dan'
+b'DocType: Employee Loan',b'Repay Fixed Amount per Period',b'Povrne fiksni znesek na obdobje'
+b'DocType: Employee',b'Health Insurance No',b'Zdravstveno zavarovanje \xc5\xa1t'
+b'apps/erpnext/erpnext/buying/utils.py +47',b'Please enter quantity for Item {0}',b'Vnesite koli\xc4\x8dino za postavko {0}'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215',b'Credit Note Amt',b'Credit Opomba Amt'
+b'DocType: Employee External Work History',b'Employee External Work History',b'Delavec Zunanji Delo Zgodovina'
+b'DocType: Opening Invoice Creation Tool',b'Purchase',b'Nakup'
+b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'Balance Qty',b'Balance Kol'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20',b'Goals cannot be empty',b'Cilji ne morejo biti prazna'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +15',b'Enrolling students',b'Vpis \xc5\xa1tudentov'
+b'DocType: Item Group',b'Parent Item Group',b'Parent Item Group'
+b'DocType: Appointment Type',b'Appointment Type',b'Vrsta imenovanja'
+b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21',b'{0} for {1}',b'{0} za {1}'
+b'DocType: Healthcare Settings',b'Valid number of days',b'Veljavno \xc5\xa1tevilo dni'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +39',b'Cost Centers',b'Stro\xc5\xa1kovna mesta'
+b'DocType: Land Unit',b'Linked Plant Analysis',b'Analiza povezanih naprav'
+b'DocType: Purchase Receipt',"b""Rate at which supplier's currency is converted to company's base currency""","b'Obrestna mera, po kateri dobavitelj je valuti, se pretvori v osnovni valuti dru\xc5\xbebe'"
+b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36',b'Row #{0}: Timings conflicts with row {1}',b'Vrstica # {0}: \xc4\x8dase v nasprotju z vrsto {1}'
+b'DocType: Purchase Invoice Item',b'Allow Zero Valuation Rate',b'Dovoli ni\xc4\x8delni stopnji vrednotenja'
+b'DocType: Purchase Invoice Item',b'Allow Zero Valuation Rate',b'Dovoli ni\xc4\x8delni stopnji vrednotenja'
+b'DocType: Training Event Employee',b'Invited',b'povabljen'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +178',b'Multiple active Salary Structures found for employee {0} for the given dates',b'Ve\xc4\x8d aktivne strukture pla\xc4\x8d iskanja za zaposlenega {0} za datumoma'
+b'apps/erpnext/erpnext/config/accounts.py +308',b'Setup Gateway accounts.',b'Gateway ra\xc4\x8dune.'
+b'DocType: Employee',b'Employment Type',b'Vrsta zaposlovanje'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42',b'Fixed Assets',b'Osnovna sredstva'
+b'DocType: Payment Entry',b'Set Exchange Gain / Loss',b'Set Exchange dobi\xc4\x8dek / izguba'
+,b'GST Purchase Register',b'DDV Nakup Registracija'
+,b'Cash Flow',b'Denarni tok'
+b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25',b'Combined invoice portion must equal 100%',b'Kombinirani del na ra\xc4\x8dunu mora biti enak 100%'
+b'DocType: Item Group',b'Default Expense Account',b'Privzeto Expense ra\xc4\x8dun'
+b'DocType: GST Account',b'CGST Account',b'Ra\xc4\x8dun CGST'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53',b'Student Email ID',b'\xc5\xa0tudent Email ID'
+b'DocType: Employee',b'Notice (days)',b'Obvestilo (dni)'
+b'DocType: Tax Rule',b'Sales Tax Template',b'Sales Tax Predloga'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2510',b'Select items to save the invoice',"b'Izberite predmete, da shranite ra\xc4\x8dun'"
+b'DocType: Employee',b'Encashment Date',b'Vnov\xc4\x8devanje Datum'
+b'DocType: Training Event',b'Internet',b'internet'
+b'DocType: Special Test Template',b'Special Test Template',b'Posebna preskusna predloga'
+b'DocType: Account',b'Stock Adjustment',b'Prilagoditev zaloge'
+b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34',b'Default Activity Cost exists for Activity Type - {0}',b'Obstaja Stro\xc5\xa1ki Privzeta aktivnost za vrsto dejavnosti - {0}'
+b'DocType: Work Order',b'Planned Operating Cost',b'Na\xc4\x8drtovana operacijski stro\xc5\xa1kov'
+b'DocType: Academic Term',b'Term Start Date',b'Izraz Datum za\xc4\x8detka'
+b'apps/erpnext/erpnext/config/accounts.py +471',b'List of all share transactions',b'Seznam vseh dele\xc5\xbeev transakcij'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18',b'Opp Count',b'Opp \xc5\xa0tetje'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18',b'Opp Count',b'Opp \xc5\xa0tetje'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +244',b'Please find attached {0} #{1}',b'V prilogi vam po\xc5\xa1iljamo {0} # {1}'
+b'apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52',b'Average Rate',b'Povpre\xc4\x8dna hitrost'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +728',b'Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total',b'Skupni znesek pla\xc4\x8dila v urniku pla\xc4\x8dil mora biti enak znesku zaokro\xc5\xbeeno / zaokro\xc5\xbeeno'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34',b'Bank Statement balance as per General Ledger',b'Banka Izjava ravnote\xc5\xbeje kot na glavno knjigo'
+b'DocType: Job Applicant',b'Applicant Name',b'Predlagatelj Ime'
+b'DocType: Authorization Rule',b'Customer / Item Name',b'Stranka / Item Name'
+b'DocType: Buying Settings',"b'If enabled, last purchase details of items will not be fetched from previous purchase order or purchase receipt'","b'\xc4\x8ce je omogo\xc4\x8deno, zadnji podatki o nakupu predmetov ne bodo pridobljeni iz prej\xc5\xa1njega naro\xc4\x8dila ali potrdila o nakupu'"
+b'DocType: Product Bundle',"b'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**. \n\nThe package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".\n\nFor 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.\n\nNote: BOM = Bill of Materials'","b'Agregat skupina ** Items ** v drugo ** postavki **. To je uporabno, \xc4\x8de ste zdru\xc5\xbeevanje neka ** Items ** v paketu in jo vzdr\xc5\xbeevati zalogo pakiranih ** Items ** in ne agregat ** item **. Paket ** Item ** bodo imeli &quot;Je Stock Postavka&quot; kot &quot;ne&quot; in &quot;Je Sales Item&quot;, kot je &quot;Yes&quot;. Na primer: \xc4\x8ce prodajate Prenosniki in nahrbtniki lo\xc4\x8deno in imajo posebno ceno, \xc4\x8de kupec kupi tako, potem bo Laptop + nahrbtnik nov Bundle Izdelek to\xc4\x8dka. Opomba: BOM = Bill of Materials'"
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42',b'Serial No is mandatory for Item {0}',b'Zaporedna \xc5\xa1tevilka je obvezna za postavko {0}'
+b'DocType: Item Variant Attribute',b'Attribute',b'Lastnost'
+b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43',b'Please specify from/to range',"b'Prosimo, navedite iz / v razponu'"
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28',b'Opening {0} Invoice created',b'Odpiranje {0} Ustvarjen ra\xc4\x8dun'
+b'DocType: Serial No',b'Under AMC',b'Pod AMC'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55',b'Item valuation rate is recalculated considering landed cost voucher amount',b'Stopnja vrednotenje sredstev se prera\xc4\x8duna razmi\xc5\xa1lja pristali stro\xc5\xa1kovno vrednost kupona'
+b'apps/erpnext/erpnext/config/selling.py +153',b'Default settings for selling transactions.',b'Privzete nastavitve za prodajne transakcije.'
+b'DocType: Guardian',b'Guardian Of ',b'Guardian Of'
+b'DocType: Grading Scale Interval',b'Threshold',b'prag'
+b'DocType: BOM Update Tool',b'Current BOM',b'Trenutni BOM'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +32',b'Balance (Dr - Cr)',b'Ravnote\xc5\xbeje (Dr - Cr)'
+b'apps/erpnext/erpnext/public/js/utils.js +55',b'Add Serial No',b'Dodaj Serijska \xc5\xa1t'
+b'DocType: Work Order Item',b'Available Qty at Source Warehouse',b'Na voljo Koli\xc4\x8dina na Vir Warehouse'
+b'apps/erpnext/erpnext/config/support.py +22',b'Warranty',b'garancija'
+b'DocType: Purchase Invoice',b'Debit Note Issued',b'Opomin Izdano'
+b'DocType: Work Order',b'Warehouses',b'Skladi\xc5\xa1\xc4\x8da'
+b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18',b'{0} asset cannot be transferred',b'{0} sredstev ni mogo\xc4\x8de prenesti'
+b'DocType: Hotel Room Pricing',b'Hotel Room Pricing',b'Cene hotelske sobe'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +80',b'This Item is a Variant of {0} (Template).',b'Ta element je razli\xc4\x8dica {0} (predloga).'
+b'DocType: Workstation',b'per hour',b'na uro'
+b'apps/erpnext/erpnext/config/buying.py +7',b'Purchasing',b'Purchasing'
+b'DocType: Announcement',b'Announcement',b'Obvestilo'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +84',b'Customer LPO',b'Stranka LPO'
+b'DocType: Education Settings',"b'For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.'",b'Za \xc5\xa0tudentske skupine temelji Serija bo \xc5\xa1tudent Serija biti potrjena za vse u\xc4\x8dence od programa vpis.'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +50',b'Warehouse can not be deleted as stock ledger entry exists for this warehouse.',"b'Skladi\xc5\xa1\xc4\x8de ni mogo\xc4\x8de \xc4\x8drtati, saj obstaja vnos stock knjiga za to skladi\xc5\xa1\xc4\x8de.'"
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +25',b'Distribution',b'Porazdelitev'
+b'DocType: Expense Claim Advance',b'Expense Claim Advance',b'Advance Claim Advance'
+b'DocType: Lab Test',b'Report Preference',b'Prednost poro\xc4\x8dila'
+b'apps/erpnext/erpnext/config/non_profit.py +43',b'Volunteer information.',b'Informacije o prostovoljcih.'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133',b'Project Manager',b'Project Manager'
+,b'Quoted Item Comparison',b'Citirano To\xc4\x8dka Primerjava'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34',b'Overlap in scoring between {0} and {1}',b'Prekrivanje v dosegu med {0} in {1}'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114',b'Dispatch',b'Dispatch'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +74',b'Max discount allowed for item: {0} is {1}%',b'Max popust dovoljena za postavko: {0} je {1}%'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176',b'Net Asset value as on',"b'\xc4\x8cista vrednost sredstev, kot je na'"
+b'DocType: Crop',b'Produce',b'Produkt'
+b'DocType: Hotel Settings',b'Default Taxes and Charges',b'Privzete Davki in dajatve'
+b'DocType: Account',b'Receivable',b'Terjatev'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308',b'Row #{0}: Not allowed to change Supplier as Purchase Order already exists',b'Vrstica # {0}: ni dovoljeno spreminjati Dobavitelj kot Naro\xc4\x8dilo \xc5\xbee obstaja'
+b'DocType: Accounts Settings',b'Role that is allowed to submit transactions that exceed credit limits set.',"b'Vloga, ki jo je dovoljeno vlo\xc5\xbeiti transakcije, ki presegajo omejitve posojil zastavili.'"
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +989',b'Select Items to Manufacture',b'Izberite artikel v Izdelava'
+b'DocType: Delivery Stop',b'Delivery Stop',b'Dostava Stop'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +963',"b'Master data syncing, it might take some time'","b'Master podatkov sinhronizacijo, lahko traja nekaj \xc4\x8dasa'"
+b'DocType: Item',b'Material Issue',b'Material Issue'
+b'DocType: Employee Education',b'Qualification',b'Kvalifikacije'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +42',b'View Salary Slips',b'Oglejte si \xc4\x8dlanke o pla\xc4\x8dah'
+b'DocType: Item Price',b'Item Price',b'Item Cena'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48',b'Soap & Detergent',b'Soap &amp; Detergent'
+b'DocType: BOM',b'Show Items',b'prika\xc5\xbei To\xc4\x8dke'
+b'apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30',b'From Time cannot be greater than To Time.',b'Od \xc4\x8dasa ne sme biti ve\xc4\x8dja od do \xc4\x8dasa.'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +92',b'Do you want to notify all the customers by email?',b'Ali \xc5\xbeelite obvestiti vse stranke po elektronski po\xc5\xa1ti?'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36',b'Motion Picture & Video',b'Motion Picture &amp; Video'
+b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5',b'Ordered',b'Naro\xc4\x8deno'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51',b'Resume',b'Nadaljuj'
+b'DocType: Salary Detail',b'Component',b'Komponenta'
+b'DocType: Assessment Criteria',b'Assessment Criteria Group',b'Skupina Merila ocenjevanja'
+b'DocType: Healthcare Settings',b'Patient Name By',b'Ime bolnika z'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +72',b'Opening Accumulated Depreciation must be less than equal to {0}',b'Odpiranje nabrano amortizacijo sme biti manj\xc5\xa1a od enako {0}'
+b'DocType: Warehouse',b'Warehouse Name',b'Skladi\xc5\xa1\xc4\x8de Name'
+b'DocType: Naming Series',b'Select Transaction',b'Izberite Transaction'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30',b'Please enter Approving Role or Approving User',b'Vnesite Odobritev vloge ali Potrditev uporabnika'
+b'DocType: Journal Entry',b'Write Off Entry',b'Napi\xc5\xa1ite Off Entry'
+b'DocType: BOM',b'Rate Of Materials Based On',b'Oceni materialov na osnovi'
+b'apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21',b'Support Analtyics',b'Podpora Analtyics'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102',b'Uncheck all',b'Odzna\xc4\x8di vse'
+b'DocType: POS Profile',b'Terms and Conditions',b'Pravila in pogoji'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49',b'To Date should be within the Fiscal Year. Assuming To Date = {0}',"b'Do datuma mora biti v poslovnem letu. Ob predpostavki, da \xc5\xbeelite Datum = {0}'"
+b'DocType: Employee',"b'Here you can maintain height, weight, allergies, medical concerns etc'","b'Tukaj lahko hranite vi\xc5\xa1ino, te\xc5\xbeo, alergije, zdravstvene pomisleke in podobno'"
+b'DocType: Leave Block List',b'Applies to Company',b'Velja za podjetja'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +231',b'Cannot cancel because submitted Stock Entry {0} exists',"b'Ni mogo\xc4\x8de preklicati, ker je predlo\xc5\xbeila Stock Za\xc4\x8detek {0} obstaja'"
+b'DocType: Employee Loan',b'Disbursement Date',b'izpla\xc4\x8dilo Datum'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80',"b""'Recipients' not specified""",b'&quot;Prejemniki&quot; niso navedeni'
+b'DocType: BOM Update Tool',b'Update latest price in all BOMs',b'Posodobi najnovej\xc5\xa1o ceno v vseh BOM'
+b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +23',b'Medical Record',b'Medicinski zapis'
+b'DocType: Vehicle',b'Vehicle',b'vozila'
+b'DocType: Purchase Invoice',b'In Words',b'V besedi'
+b'apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15',b'{0} must be submitted',b'{0} je treba vlo\xc5\xbeiti'
+b'DocType: POS Profile',b'Item Groups',b'postavka Skupine'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +221',"b""Today is {0}'s birthday!""",b'Danes je {0} &#39;s rojstni dan!'
+b'DocType: Sales Order Item',b'For Production',b'Za proizvodnjo'
+b'DocType: Payment Request',b'payment_url',b'payment_url'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +186',b'Please add a Temporary Opening account in Chart of Accounts',"b'Prosimo, dodajte ra\xc4\x8dun za za\xc4\x8dasno odpiranje v kontnem okvirju'"
+b'DocType: Customer',b'Customer Primary Contact',b'Primarni kontakt s strankami'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +154',b'Period Closing Journal',b'\xc4\x8casovno zaklju\xc4\x8dni \xc4\x8dasopis'
+b'DocType: Project Task',b'View Task',b'Ogled Task'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22',b'Opp/Lead %',b'OPP / svinec%'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22',b'Opp/Lead %',b'OPP / svinec%'
+b'DocType: Material Request',b'MREQ-',b'MREQ-'
+b'DocType: Payment Schedule',b'Invoice Portion',b'Dele\xc5\xbe ra\xc4\x8duna'
+,b'Asset Depreciations and Balances',b'Premo\xc5\xbeenjem amortizacije in Stanja'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +370',b'Amount {0} {1} transferred from {2} to {3}',b'Znesek {0} {1} je preselil iz {2} na {3}'
+b'DocType: Sales Invoice',b'Get Advances Received',b'Get prejeti predujmi'
+b'DocType: Email Digest',b'Add/Remove Recipients',b'Dodaj / Odstrani prejemnike'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19',"b""To set this Fiscal Year as Default, click on 'Set as Default'""","b'\xc4\x8ce \xc5\xbeelite nastaviti to poslovno leto kot privzeto, kliknite na &quot;Set as Default&quot;'"
+b'DocType: Production Plan',b'Include Subcontracted Items',b'Vklju\xc4\x8dite predmete s podizvajalci'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +220',b'Join',b'pridru\xc5\xbei se'
+b'apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21',b'Shortage Qty',b'Pomanjkanje Kol'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +672',b'Cannot change Variant properties after stock transction. You will have to make a new Item to do this.',b'Lastnosti variant ni mogo\xc4\x8de spremeniti po pretovarjanju zalog. Za to morate narediti novo postavko.'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +714',b'Item variant {0} exists with same attributes',b'Obstaja postavka varianta {0} z enakimi atributi'
+b'DocType: Employee Loan',b'Repay from Salary',b'Popla\xc4\x8dilo iz Pla\xc4\x8da'
+b'DocType: Leave Application',b'LAP/',b'LAP /'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +360',b'Requesting payment against {0} {1} for amount {2}',b'Zahteva pla\xc4\x8dilo pred {0} {1} za znesek {2}'
+b'DocType: Salary Slip',b'Salary Slip',b'Pla\xc4\x8da listek'
+b'DocType: Lead',b'Lost Quotation',b'Izgubljeno Kotacija'
+b'apps/erpnext/erpnext/utilities/user_progress.py +221',b'Student Batches',b'\xc5\xa0tudentski paketi'
+b'DocType: Pricing Rule',b'Margin Rate or Amount',b'Razlika v stopnji ali koli\xc4\x8dini'
+b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48',"b""'To Date' is required""","b'""Do datuma"" je obvezno polje'"
+b'DocType: Packing Slip',"b'Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.'","b'Ustvarjajo dobavnic, da paketi dostavi. Uporablja se za uradno \xc5\xa1tevilko paketa, vsebino paketa in njegovo te\xc5\xbeo.'"
+b'DocType: Sales Invoice Item',b'Sales Order Item',b'Artikel naro\xc4\x8dila'
+b'DocType: Salary Slip',b'Payment Days',b'Pla\xc4\x8dilni dnevi'
+b'DocType: Stock Settings',b'Convert Item Description to Clean HTML',b'Preoblikovati postavko Opis za \xc4\x8di\xc5\xa1\xc4\x8denje HTML'
+b'DocType: Patient',b'Dormant',b'mirujo\xc4\x8dih'
+b'DocType: Salary Slip',b'Total Interest Amount',b'Skupni znesek obresti'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +124',b'Warehouses with child nodes cannot be converted to ledger',b'Skladi\xc5\xa1\xc4\x8da z otrok vozli\xc5\xa1\xc4\x8da ni mogo\xc4\x8de pretvoriti v knjigo terjatev'
+b'DocType: BOM',b'Manage cost of operations',b'Upravljati stro\xc5\xa1ke poslovanja'
+b'DocType: Accounts Settings',b'Stale Days',b'Stale dni'
+b'DocType: Notification Control',"b'When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.'","b'Ko kateri koli od pregledanih transakcij &quot;Objavil&quot;, e-pop-up samodejno odpre, da po\xc5\xa1ljete e-po\xc5\xa1to s pripadajo\xc4\x8dim &quot;stik&quot; v tem poslu, s poslom, kot prilogo. Uporabnik lahko ali pa ne po\xc5\xa1ljete e-po\xc5\xa1to.'"
+b'apps/erpnext/erpnext/config/setup.py +14',b'Global Settings',b'Globalni Nastavitve'
+b'DocType: Crop',b'Row Spacing UOM',b'Razmik vrstic UOM'
+b'DocType: Assessment Result Detail',b'Assessment Result Detail',b'Ocena Rezultat Podrobnosti'
+b'DocType: Employee Education',b'Employee Education',b'Izobra\xc5\xbeevanje delavec'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53',b'Duplicate item group found in the item group table',b'Dvojnik postavka skupina je na\xc5\xa1la v tabeli to\xc4\x8dka skupine'
+b'DocType: Land Unit',b'Parent Land Unit',b'Mati\xc4\x8dna enota'
+b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1113',b'It is needed to fetch Item Details.',"b'To je potrebno, da prinese Element Podrobnosti.'"
+b'DocType: Fertilizer',b'Fertilizer Name',b'Ime gnojila'
+b'DocType: Salary Slip',b'Net Pay',b'Neto pla\xc4\x8da'
+b'DocType: Cash Flow Mapping Accounts',b'Account',b'Ra\xc4\x8dun'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217',b'Serial No {0} has already been received',b'Serijska \xc5\xa1t {0} je \xc5\xbee prejela'
+,b'Requested Items To Be Transferred',b'Zahtevane blago prena\xc5\xa1a'
+b'DocType: Expense Claim',b'Vehicle Log',b'vozilo Log'
+b'DocType: Vital Signs',b'Presence of a fever (temp &gt; 38.5 \xc2\xb0C/101.3 \xc2\xb0F or sustained temp &gt; 38 \xc2\xb0C/100.4 \xc2\xb0F)',"b'Prisotnost vro\xc4\x8dine (temp&gt; 38,5 \xc2\xb0 C / 101,3 \xc2\xb0 F ali trajne temp&gt; 38 \xc2\xb0 C / 100,4 \xc2\xb0 F)'"
+b'DocType: Customer',b'Sales Team Details',b'Sales Team Podrobnosti'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1352',b'Delete permanently?',b'Izbri\xc5\xa1i trajno?'
+b'DocType: Expense Claim',b'Total Claimed Amount',b'Skupaj zahtevani znesek'
+b'apps/erpnext/erpnext/config/crm.py +17',b'Potential opportunities for selling.',b'Potencialne mo\xc5\xbenosti za prodajo.'
+b'DocType: Shareholder',b'Folio no.',b'Folio \xc5\xa1t.'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +246',b'Invalid {0}',b'Neveljavna {0}'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90',b'Sick Leave',b'Bolni\xc5\xa1ki dopust'
+b'DocType: Email Digest',b'Email Digest',b'Email Digest'
+b'DocType: Delivery Note',b'Billing Address Name',b'Zara\xc4\x8dunavanje Naslov Name'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22',b'Department Stores',b'Veleblagovnice'
+,b'Item Delivery Date',b'Datum dobave artikla'
+b'DocType: Production Plan',b'Material Requested',b'Zahtevani material'
+b'DocType: Warehouse',b'PIN',b'PIN'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +116',"b""Error '{0}' occured. Arguments {1}.""",b'Pri\xc5\xa1lo je do napake &#39;{0}&#39;. Argumenti {1}.'
+b'DocType: Bin',b'Reserved Qty for sub contract',b'Rezervirano Kol za podizvajalsko pogodbo'
+b'DocType: Patient Service Unit',b'Patinet Service Unit',b'Patinet servisna enota'
+b'DocType: Sales Invoice',b'Base Change Amount (Company Currency)',b'Osnovna Sprememba Znesek (dru\xc5\xbeba Valuta)'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304',b'No accounting entries for the following warehouses',b'Ni vknji\xc5\xbebe za naslednjih skladi\xc5\xa1\xc4\x8dih'
+b'apps/erpnext/erpnext/projects/doctype/project/project.js +95',b'Save the document first.',b'Shranite dokument na prvem mestu.'
+b'apps/erpnext/erpnext/shopping_cart/cart.py +74',b'Only {0} in stock for item {1}',b'Samo za {0} na zalogi za predmet {1}'
+b'DocType: Account',b'Chargeable',b'Obra\xc4\x8duna'
+b'DocType: Company',b'Change Abbreviation',b'Spremeni kratico'
+b'apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py +66',b'Pay {0} {1}',b'Pla\xc4\x8dajte {0} {1}'
+b'DocType: Expense Claim Detail',b'Expense Date',b'Expense Datum'
+b'DocType: Item',b'Max Discount (%)',b'Max Popust (%)'
+b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30',b'Credit Days cannot be a negative number',b'Kreditni dnevi ne smejo biti negativni'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70',b'Last Order Amount',b'Zadnja naro\xc4\x8dite Znesek'
+b'DocType: Cash Flow Mapper',b'e.g Adjustments for:',b'npr. prilagoditve za:'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +275',"b' {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item'","b'{0} Ohrani Vzorec temelji na seriji, preverite ali Ima \xc5\xa1tevilko serije, da ohranite vzorec serije'"
+b'DocType: Task',b'Is Milestone',b'je Milestone'
+b'DocType: Delivery Stop',b'Email Sent To',b'E-po\xc5\xa1ta poslana'
+b'DocType: Budget',b'Warn',b'Opozori'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81',b'Are you sure you want to unregister?',"b'Ali ste prepri\xc4\x8dani, da se \xc5\xbeelite odjaviti?'"
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +797',b'All items have already been transferred for this Work Order.',b'Vsi elementi so bili \xc5\xbee preneseni za ta delovni nalog.'
+b'DocType: Appraisal',"b'Any other remarks, noteworthy effort that should go in the records.'","b'Kakr\xc5\xa1ne koli druge pripombe, omembe vredna napora, da bi moral iti v evidencah.'"
+b'DocType: Asset Maintenance',b'Manufacturing User',b'Proizvodnja Uporabnik'
+b'DocType: Purchase Invoice',b'Raw Materials Supplied',"b'Surovin, dobavljenih'"
+b'DocType: C-Form',b'Series',b'Zaporedje'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +282',b'Currency of the price list {0} must be {1} or {2}',b'Valuta cenika {0} mora biti {1} ali {2}'
+b'DocType: Appraisal',b'Appraisal Template',b'Cenitev Predloga'
+b'DocType: Soil Texture',b'Ternary Plot',b'Ternary plot'
+b'DocType: Item Group',b'Item Classification',b'Postavka Razvrstitev'
+b'DocType: Driver',b'License Number',b'\xc5\xa0tevilka licence'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131',b'Business Development Manager',b'Business Development Manager'
+b'DocType: Maintenance Visit Purpose',b'Maintenance Visit Purpose',b'Vzdr\xc5\xbeevanje Obi\xc5\xa1\xc4\x8dite Namen'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19',b'Invoice Patient Registration',b'Registracija ra\xc4\x8duna pacientov'
+b'DocType: Crop',b'Period',b'Obdobje'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +27',b'General Ledger',b'Glavna knjiga'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33',b'Employee {0} on Leave on {1}',b'Zaposlenih {0} v odhod {1}'
+b'apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10',b'View Leads',b'Poglej ponudbe'
+b'DocType: Program Enrollment Tool',b'New Program',b'Nov program'
+b'DocType: Item Attribute Value',b'Attribute Value',b'Vrednosti atributa'
+,b'Itemwise Recommended Reorder Level',b'Itemwise Priporo\xc4\x8dena Preureditev Raven'
+b'DocType: Salary Detail',b'Salary Detail',b'pla\xc4\x8da Podrobnosti'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1070',b'Please select {0} first',"b'Prosimo, izberite {0} najprej'"
+b'DocType: Appointment Type',b'Physician',b'Zdravnik'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +872',b'Batch {0} of Item {1} has expired.',b'Serija {0} od Postavka {1} je potekla.'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11',b'Consultations',b'Posvetovanja'
+b'DocType: Sales Invoice',b'Commission',b'Komisija'
+b'apps/erpnext/erpnext/config/manufacturing.py +27',b'Time Sheet for manufacturing.',b'\xc4\x8cas List za proizvodnjo.'
+b'apps/erpnext/erpnext/templates/pages/cart.html +37',b'Subtotal',b'Vmesni se\xc5\xa1tevek'
+b'apps/erpnext/erpnext/config/erpnext_integrations.py +18',b'GoCardless SEPA Mandate',b'GoCardless Mandat SEPA'
+b'DocType: Physician',b'Charges',b'Dajatve'
+b'DocType: Production Plan',b'Get Items For Work Order',b'Pridobite predmete za delovni red'
+b'DocType: Salary Detail',b'Default Amount',b'Privzeti znesek'
+b'DocType: Lab Test Template',b'Descriptive',b'Opisno'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +95',b'Warehouse not found in the system',b'Skladi\xc5\xa1\xc4\x8de ni mogo\xc4\x8de najti v sistemu'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115',"b""This Month's Summary""",b'Povzetek tega meseca je'
+b'DocType: Quality Inspection Reading',b'Quality Inspection Reading',b'Kakovost In\xc5\xa1pekcijski Reading'
+b'apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25',b'`Freeze Stocks Older Than` should be smaller than %d days.',b'`Zamrzni zaloge starej\xc5\xa1e od` mora biti manj\xc5\xa1a od %d dni.'
+b'DocType: Tax Rule',b'Purchase Tax Template',b'Nakup Dav\xc4\x8dna Template'
+b'apps/erpnext/erpnext/utilities/user_progress.py +48',"b""Set a sales goal you'd like to achieve for your company.""","b'Dolo\xc4\x8dite prodajni cilj, ki ga \xc5\xbeelite dose\xc4\x8di za va\xc5\xa1e podjetje.'"
+,b'Project wise Stock Tracking',b'Projekt pametno Stock Tracking'
+b'DocType: GST HSN Code',b'Regional',b'regionalno'
+b'apps/erpnext/erpnext/config/healthcare.py +40',b'Laboratory',b'Laboratorij'
+b'DocType: Stock Entry Detail',b'Actual Qty (at source/target)',b'Dejanska Koli\xc4\x8dina (pri viru / cilju)'
+b'DocType: Item Customer Detail',b'Ref Code',b'Ref Code'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75',b'Customer Group is Required in POS Profile',b'Skupina strank je potrebna v profilu POS'
+b'apps/erpnext/erpnext/config/hr.py +12',b'Employee records.',b'Evidence zaposlenih.'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +98',b'Please set Next Depreciation Date',"b'Prosim, nastavite Naslednja Amortizacija Datum'"
+b'DocType: HR Settings',b'Payroll Settings',b'Nastavitve pla\xc4\x8de'
+b'apps/erpnext/erpnext/config/accounts.py +146',b'Match non-linked Invoices and Payments.',b'Match nepovezane ra\xc4\x8dunov in pla\xc4\x8dil.'
+b'DocType: POS Settings',b'POS Settings',b'POS nastavitve'
+b'apps/erpnext/erpnext/templates/pages/cart.html +16',b'Place Order',b'Naro\xc4\x8diti'
+b'DocType: Email Digest',b'New Purchase Orders',b'Nova naro\xc4\x8dila'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24',b'Root cannot have a parent cost center',b'Root ne more imeti mati\xc4\x8dna stro\xc5\xa1kovno mesto v'
+b'apps/erpnext/erpnext/public/js/stock_analytics.js +54',b'Select Brand...',b'Izberi znamko ...'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +32',b'Non Profit (beta)',b'Neprofitna (beta)'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18',b'Training Events/Results',b'Usposabljanje Dogodki / Rezultati'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152',b'Accumulated Depreciation as on',"b'Nabrano amortizacijo, na'"
+b'DocType: Sales Invoice',b'C-Form Applicable',"b'C-obliki, ki velja'"
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +438',b'Operation Time must be greater than 0 for Operation {0}',"b'Delovanje \xc4\x8cas mora biti ve\xc4\x8dja od 0, za obratovanje {0}'"
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +107',b'Warehouse is mandatory',b'Skladi\xc5\xa1\xc4\x8de je obvezna'
+b'DocType: Shareholder',b'Address and Contacts',b'Naslov in kontakti'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67',b'Failed to create website',b'Spletne strani ni bilo mogo\xc4\x8de ustvariti'
+b'DocType: Soil Analysis',b'Mg/K',b'Mg / K'
+b'DocType: UOM Conversion Detail',b'UOM Conversion Detail',b'UOM Conversion Detail'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +924',b'Retention Stock Entry already created or Sample Quantity not provided',"b'Zaprta zaloga, ki je \xc5\xbee bila ustvarjena, ali koli\xc4\x8dina vzorca ni zagotovljena'"
+b'DocType: Program',b'Program Abbreviation',b'Kratica programa'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52',b'Charges are updated in Purchase Receipt against each item',b'Dajatve so posodobljeni v Potrdilo o nakupu ob vsaki postavki'
+b'DocType: Warranty Claim',b'Resolved By',b'Re\xc5\xa1ujejo s'
+b'DocType: Bank Guarantee',b'Start Date',b'Datum za\xc4\x8detka'
+b'apps/erpnext/erpnext/config/hr.py +75',b'Allocate leaves for a period.',b'Dodeli liste za obdobje.'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42',b'Cheques and Deposits incorrectly cleared',b'\xc4\x8ceki in depoziti nepravilno izbil'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +46',b'Account {0}: You can not assign itself as parent account',b'Ra\xc4\x8dun {0}: ne more\xc5\xa1 dodeliti samega sebe kot mati\xc4\x8dni ra\xc4\x8dun'
+b'DocType: Purchase Invoice Item',b'Price List Rate',b'Cenik Rate'
+b'apps/erpnext/erpnext/utilities/activation.py +72',b'Create customer quotes',b'Ustvari ponudbe kupcev'
+b'DocType: Item',"b'Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.'","b'Poka\xc5\xbei &quot;Na zalogi&quot; ali &quot;Ni na zalogi&quot;, ki temelji na zalogi na voljo v tem skladi\xc5\xa1\xc4\x8du.'"
+b'apps/erpnext/erpnext/config/manufacturing.py +38',b'Bill of Materials (BOM)',b'Kosovnica (BOM)'
+b'DocType: Item',b'Average time taken by the supplier to deliver',"b'Povpre\xc4\x8den \xc4\x8das, ki ga dobavitelj dostaviti'"
+b'DocType: Sample Collection',b'Collected By',b'Zbrane z'
+b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +35',b'Assessment Result',b'ocena Rezultat'
+b'DocType: Hotel Room Package',b'Hotel Room Package',b'Paket za hotelske sobe'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13',b'Hours',b'Ur'
+b'DocType: Project',b'Expected Start Date',b'Pri\xc4\x8dakovani datum za\xc4\x8detka'
+b'DocType: Purchase Invoice',b'04-Correction in Invoice',b'04-Popravek na ra\xc4\x8dunu'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +963',b'Work Order already created for all items with BOM',b'Delovni nalog je \xc5\xbee ustvarjen za vse elemente z BOM'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +60',b'Variant Details Report',b'Poro\xc4\x8dilo o variantah'
+b'DocType: Setup Progress Action',b'Setup Progress Action',b'Akcijski program Setup Progress'
+b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +36',b'Buying Price List',b'Nakupni cenik'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49',b'Remove item if charges is not applicable to that item',"b'Odstranite element, \xc4\x8de stro\xc5\xa1ki ne nana\xc5\xa1a na to postavko'"
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21',b'Please select Maintenance Status as Completed or remove Completion Date',b'Izberite stanje vzdr\xc5\xbeevanja kot dokon\xc4\x8dano ali odstranite datum zaklju\xc4\x8dka'
+b'DocType: Supplier',b'Default Payment Terms Template',b'Predloga za privzete pla\xc4\x8dilne pogoje'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34',b'Transaction currency must be same as Payment Gateway currency',b'Transakcijski valuta mora biti enaka kot vpla\xc4\x8dilo valuto'
+b'DocType: Payment Entry',b'Receive',b'Prejeti'
+b'apps/erpnext/erpnext/templates/pages/rfq.html +75',b'Quotations: ',b'Ponudbe:'
+b'DocType: Maintenance Visit',b'Fully Completed',b'V celoti kon\xc4\x8dana'
+b'apps/erpnext/erpnext/projects/doctype/project/project_list.js +6',b'{0}% Complete',b'{0}% kon\xc4\x8dano'
+b'DocType: Employee',b'Educational Qualification',b'Izobra\xc5\xbeevalni Kvalifikacije'
+b'DocType: Workstation',b'Operating Costs',b'Obratovalni stro\xc5\xa1ki'
+b'DocType: Budget',b'Action if Accumulated Monthly Budget Exceeded',"b'Ukrep, \xc4\x8de skupna mese\xc4\x8dna Prora\xc4\x8dun Prekora\xc4\x8ditev'"
+b'DocType: Subscription',b'Submit on creation',b'Predlo\xc5\xbei na ustvarjanje'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +483',b'Currency for {0} must be {1}',b'Valuta za {0} mora biti {1}'
+b'DocType: Asset',b'Disposal Date',b'odstranjevanje Datum'
+b'DocType: Daily Work Summary Settings',"b'Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.'","b'E-po\xc5\xa1ta bo poslana vsem aktivnih zaposlenih v dru\xc5\xbebi na dolo\xc4\x8deni uri, \xc4\x8de nimajo po\xc4\x8ditnic. Povzetek odgovorov bo poslano ob polno\xc4\x8di.'"
+b'DocType: Employee Leave Approver',b'Employee Leave Approver',b'Zaposleni Leave odobritelj'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +510',b'Row {0}: An Reorder entry already exists for this warehouse {1}',b'Vrstica {0}: Vpis Preureditev \xc5\xbee obstaja za to skladi\xc5\xa1\xc4\x8de {1}'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99',"b'Cannot declare as lost, because Quotation has been made.'","b'Ne more razglasiti kot izgubljena, ker je bil predra\xc4\x8dun postavil.'"
+b'apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16',b'Training Feedback',b'Predlogi za usposabljanje'
+b'DocType: Supplier Scorecard Criteria',b'Supplier Scorecard Criteria',b'Merila ocenjevalnih meril za dobavitelje'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149',b'Please select Start Date and End Date for Item {0}',"b'Prosimo, izberite Start in kon\xc4\x8dni datum za postavko {0}'"
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55',b'Course is mandatory in row {0}',b'Seveda je obvezna v vrsti {0}'
+b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16',b'To date cannot be before from date',b'Do danes ne more biti pred od datuma'
+b'DocType: Supplier Quotation Item',b'Prevdoc DocType',b'Prevdoc DOCTYPE'
+b'DocType: Cash Flow Mapper',b'Section Footer',b'Noga odseka'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +304',b'Add / Edit Prices',b'Dodaj / Uredi Cene'
+b'DocType: Batch',b'Parent Batch',b'nadrejena Serija'
+b'DocType: Batch',b'Parent Batch',b'nadrejena Serija'
+b'DocType: Cheque Print Template',b'Cheque Print Template',b'\xc4\x8cek Print Predloga'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36',b'Chart of Cost Centers',b'Grafikon stro\xc5\xa1kovnih mest'
+b'DocType: Lab Test Template',b'Sample Collection',b'Zbiranje vzorcev'
+,b'Requested Items To Be Ordered',b'Zahtevane Postavke nalo\xc5\xbei'
+b'apps/erpnext/erpnext/public/js/hub/hub_page.js +137',b'My Orders',b'Moja naro\xc4\x8dila'
+b'DocType: Price List',b'Price List Name',b'Cenik Ime'
+b'DocType: BOM',b'Manufacturing',b'Predelovalne dejavnosti'
+,b'Ordered Items To Be Delivered',b'Naro\xc4\x8deno To\xc4\x8dke je treba dostaviti'
+b'DocType: Account',b'Income',b'Prihodki'
+b'DocType: Industry Type',b'Industry Type',b'Industrija Type'
+b'apps/erpnext/erpnext/templates/includes/cart.js +150',b'Something went wrong!',b'Nekaj je \xc5\xa1lo narobe!'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +105',b'Warning: Leave application contains following block dates',b'Opozorilo: Pustite prijava vsebuje naslednje datume blok'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +275',b'Sales Invoice {0} has already been submitted',b'Ra\xc4\x8dun {0} je \xc5\xbee bil predlo\xc5\xbeen'
+b'DocType: Supplier Scorecard Scoring Criteria',b'Score',b'ocena'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25',b'Fiscal Year {0} does not exist',b'Poslovno leto {0} ne obstaja'
+b'DocType: Asset Maintenance Log',b'Completion Date',b'datum dokon\xc4\x8danja'
+b'DocType: Purchase Invoice Item',b'Amount (Company Currency)',b'Znesek (dru\xc5\xbeba Valuta)'
+b'DocType: Agriculture Analysis Criteria',b'Agriculture User',b'Kmetijski uporabnik'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38',b'Valid till date cannot be before transaction date',b'Veljaven do datuma ne more biti pred datumom transakcije'
+b'apps/erpnext/erpnext/stock/stock_ledger.py +381',b'{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.',b'{0} enot {1} potrebnih v {2} na {3} {4} za {5} za dokon\xc4\x8danje te transakcije.'
+b'DocType: Fee Schedule',b'Student Category',b'\xc5\xa1tudent kategorije'
+b'DocType: Announcement',b'Student',b'\xc5\xa1tudent'
+b'apps/erpnext/erpnext/config/hr.py +238',b'Organization unit (department) master.',"b'Organizacijska enota (oddelek), master.'"
+b'DocType: Shipping Rule',b'Shipping Rule Type',b'Vrsta pravilnika o dostavi'
+b'apps/erpnext/erpnext/utilities/user_progress.py +239',b'Go to Rooms',b'Pojdi v sobe'
+b'apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75',b'Please enter message before sending',b'Vnesite sporo\xc4\x8dilo pred po\xc5\xa1iljanjem'
+b'DocType: Purchase Invoice',b'DUPLICATE FOR SUPPLIER',b'DVOJNIK dobavitelja'
+b'DocType: Email Digest',b'Pending Quotations',b'Dokler Citati'
+b'apps/erpnext/erpnext/config/accounts.py +318',b'Point-of-Sale Profile',b'Point-of-Sale profila'
+b'apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +25',b'{0} should be a value between 0 and 100',b'{0} mora biti vrednost med 0 in 100'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +94',b'Next Depreciation Date cannot be before Available-for-use Date',"b'Naslednji amortizacijski datum ne sme biti pred datumom, razpolo\xc5\xbeljivim za uporabo'"
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156',b'Unsecured Loans',b'Nezavarovana posojila'
+b'DocType: Cost Center',b'Cost Center Name',b'Stalo Ime Center'
+b'DocType: Student',b'B+',b'B +'
+b'DocType: HR Settings',b'Max working hours against Timesheet',b'Max delovne ure pred Timesheet'
+b'DocType: Maintenance Schedule Detail',b'Scheduled Date',b'Na\xc4\x8drtovano Datum'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +214',b'Total Paid Amt',b'Total Paid Amt'
+b'DocType: SMS Center',b'Messages greater than 160 characters will be split into multiple messages',"b'Sporo\xc4\x8dila ve\xc4\x8dji od 160 znakov, bo razdeljeno v ve\xc4\x8d sporo\xc4\x8dilih'"
+b'DocType: Purchase Receipt Item',b'Received and Accepted',b'Prejme in potrdi'
+b'DocType: Hub Settings',b'Company and Seller Profile',b'Profil podjetja in prodajalca'
+,b'GST Itemised Sales Register',b'DDV Raz\xc4\x8dlenjeni prodaje Registracija'
+b'DocType: Soil Texture',b'Silt Loam',b'Silt Loam'
+,b'Serial No Service Contract Expiry',b'Zaporedna \xc5\xa1tevilka Service Contract preteka'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299',b'You cannot credit and debit same account at the same time',"b'Ne, ne more\xc5\xa1 kreditnih in debetnih isti ra\xc4\x8dun ob istem \xc4\x8dasu'"
+b'DocType: Vital Signs',"b""Adults' pulse rate is anywhere between 50 and 80 beats per minute.""",b'Stopnja pulza odraslih je med 50 in 80 utripov na minuto.'
+b'DocType: Naming Series',b'Help HTML',b'Pomo\xc4\x8d HTML'
+b'DocType: Student Group Creation Tool',b'Student Group Creation Tool',b'\xc5\xa0tudent orodje za oblikovanje skupine'
+b'DocType: Item',b'Variant Based On',"b'Varianta, ki temelji na'"
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53',b'Total weightage assigned should be 100%. It is {0}',b'Skupaj weightage dodeljena mora biti 100%. To je {0}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +109',b'Your Suppliers',b'Va\xc5\xa1e Dobavitelji'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'Please correct the',b'Prosim popravite'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80',b'Cannot set as Lost as Sales Order is made.',"b'Ni mogo\xc4\x8de nastaviti kot izgubili, kot je narejena Sales Order.'"
+b'DocType: Request for Quotation Item',b'Supplier Part No',b'\xc5\xa0ifra dela dobavitelj'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382',"b""Cannot deduct when category is for 'Valuation' or 'Vaulation and Total'""","b'ne more odbiti, \xc4\x8de je kategorija za &quot;vrednotenje&quot; ali &quot;Vaulation in Total&quot;'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +377',b'Received From',b'Prejela od'
+b'DocType: Lead',b'Converted',b'Pretvorjena'
+b'DocType: Item',b'Has Serial No',b'Ima serijsko \xc5\xa1tevilko'
+b'DocType: Employee',b'Date of Issue',b'Datum izdaje'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222',"b""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}""","b'Kot je na Nastavitve Nakup \xc4\x8de Nakup Reciept Zahtevano == &quot;DA&quot;, nato pa za ustvarjanje ra\xc4\x8dunu o nakupu, uporabnik potreba ustvariti Nakup listek najprej za postavko {0}'"
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167',b'Row #{0}: Set Supplier for item {1}',b'Vrstica # {0}: Nastavite Dobavitelj za postavko {1}'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121',b'Row {0}: Hours value must be greater than zero.',b'Vrstica {0}: Ure vrednost mora biti ve\xc4\x8dja od ni\xc4\x8d.'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +195',b'Website Image {0} attached to Item {1} cannot be found',b'Spletna stran slike {0} pritrjena na postavki {1} ni mogo\xc4\x8de najti'
+b'DocType: Issue',b'Content Type',b'Vrsta vsebine'
+b'DocType: Asset',b'Assets',b'Sredstva'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17',b'Computer',b'Ra\xc4\x8dunalnik'
+b'DocType: Item',b'List this Item in multiple groups on the website.',b'Seznam ta postavka v ve\xc4\x8d skupinah na spletni strani.'
+b'DocType: Payment Term',b'Due Date Based On',b'Datum na podlagi datuma'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +82',b'Please set default customer group and territory in Selling Settings',"b'Prosimo, nastavite privzeto skupino strank in ozemlje v nastavitvah prodaj'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +214',b'{0} {1} does not exist',b'{0} {1} ne obstaja'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323',b'Please check Multi Currency option to allow accounts with other currency',"b'Prosimo, preverite Multi Valuta mo\xc5\xbenost, da se omogo\xc4\x8di ra\xc4\x8dune pri drugi valuti'"
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +88',b'Item: {0} does not exist in the system',b'Postavka: {0} ne obstaja v sistemu'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +106',b'You are not authorized to set Frozen value',b'Nimate dovoljenja za nastavitev Zamrznjena vrednost'
+b'DocType: Payment Reconciliation',b'Get Unreconciled Entries',b'Pridobite neusklajene vnose'
+b'DocType: Payment Reconciliation',b'From Invoice Date',b'Od Datum ra\xc4\x8duna'
+b'DocType: Healthcare Settings',b'Laboratory Settings',b'Laboratorijske nastavitve'
+b'DocType: Patient Appointment',b'Service Unit',b'Servisna enota'
+b'apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97',b'Successfully Set Supplier',b'Uspe\xc5\xa1no nastavite dobavitelja'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75',b'Leave Encashment',b'pustite Vnov\xc4\x8devanje'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +114',b'What does it do?',b'Kaj to naredi?'
+b'DocType: Crop',b'Byproducts',b'Stranski produkti'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +84',b'To Warehouse',b'Za skladi\xc5\xa1\xc4\x8da'
+b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26',b'All Student Admissions',b'Vse \xc5\xa0tudentski Sprejemi'
+,b'Average Commission Rate',b'Povpre\xc4\x8den Komisija Rate'
+b'DocType: Share Balance',b'No of Shares',b'\xc5\xa0tevilo delnic'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +448',"b""'Has Serial No' can not be 'Yes' for non-stock item""","b'""Ima serijsko \xc5\xa1tevilko"" ne more biti \'Da\' za postavko brez zalog'"
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +59',b'Select Status',b'Izberite Stanje'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41',b'Attendance can not be marked for future dates',b'Udele\xc5\xbeba ni mogo\xc4\x8de ozna\xc4\x8diti za prihodnje datume'
+b'DocType: Pricing Rule',b'Pricing Rule Help',b'Cen Pravilo Pomo\xc4\x8d'
+b'DocType: School House',b'House Name',b'Naslov'
+b'DocType: Fee Schedule',b'Total Amount per Student',b'Skupni znesek na \xc5\xa1tudenta'
+b'DocType: Purchase Taxes and Charges',b'Account Head',b'Ra\xc4\x8dun Head'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153',b'Electrical',b'Elektri\xc4\x8dno'
+b'apps/erpnext/erpnext/utilities/activation.py +100',b'Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts',b'Dodajte preostanek organizacije kot uporabnike. Dodate lahko tudi povabi stranke na va\xc5\xa1em portalu jih dodate iz imenika'
+b'DocType: Stock Entry',b'Total Value Difference (Out - In)',b'Skupna vrednost Razlika (Out - IN)'
+b'DocType: Grant Application',b'Requested Amount',b'Zahtevani znesek'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348',b'Row {0}: Exchange Rate is mandatory',b'Vrstica {0}: Menjalni te\xc4\x8daj je obvezen'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27',b'User ID not set for Employee {0}',b'ID uporabnika ni nastavljena za Employee {0}'
+b'DocType: Vehicle',b'Vehicle Value',b'Vrednost vozila'
+b'DocType: Crop Cycle',b'Detected Diseases',b'Detektirane bolezni'
+b'DocType: Stock Entry',b'Default Source Warehouse',b'Privzeto Vir Skladi\xc5\xa1\xc4\x8de'
+b'DocType: Item',b'Customer Code',b'Koda za stranke'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +220',b'Birthday Reminder for {0}',"b'Opomnik za rojstni dan, za {0}'"
+b'DocType: Asset Maintenance Task',b'Last Completion Date',b'Zadnji datum zaklju\xc4\x8dka'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72',b'Days Since Last Order',b'Dni od zadnjega naro\xc4\x8dila'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +365',b'Debit To account must be a Balance Sheet account',b'Bremenitev ra\xc4\x8duna mora biti bilanca ra\xc4\x8duna'
+b'DocType: Buying Settings',b'Naming Series',b'Poimenovanje zaporedja'
+b'DocType: GoCardless Settings',b'GoCardless Settings',b'GoCardless nastavitve'
+b'DocType: Leave Block List',b'Leave Block List Name',b'Pustite Ime Block List'
+b'apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14',b'Insurance Start date should be less than Insurance End date',b'Datum zavarovanje Za\xc4\x8detek sme biti manj\xc5\xa1a od datuma zavarovanje End'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32',b'Stock Assets',b'Zaloga Sredstva'
+b'DocType: Restaurant',b'Active Menu',b'Aktivni meni'
+b'DocType: Target Detail',b'Target Qty',b'Ciljna Kol'
+b'DocType: Shopping Cart Settings',b'Checkout Settings',b'Naro\xc4\x8dilo Nastavitve'
+b'DocType: Student Attendance',b'Present',b'Present'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37',b'Delivery Note {0} must not be submitted',b'Dobavnica {0} ni treba predlo\xc5\xbeiti'
+b'DocType: Notification Control',b'Sales Invoice Message',b'Prodaja Ra\xc4\x8dun Sporo\xc4\x8dilo'
+b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27',b'Closing Account {0} must be of type Liability / Equity',b'Zapiranje ra\xc4\x8dun {0} mora biti tipa odgovornosti / kapital'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +325',b'Salary Slip of employee {0} already created for time sheet {1}',b'Pla\xc4\x8da Slip delavca {0} \xc5\xbee ustvarili za \xc4\x8dasa stanja {1}'
+b'DocType: Vehicle Log',b'Odometer',b'\xc5\xa1tevec kilometrov'
+b'DocType: Production Plan Item',b'Ordered Qty',b'Naro\xc4\x8deno Kol'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +744',b'Item {0} is disabled',b'Postavka {0} je onemogo\xc4\x8dena'
+b'DocType: Stock Settings',b'Stock Frozen Upto',b'Stock Zamrznjena Stanuje'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +930',b'BOM does not contain any stock item',b'BOM ne vsebuje nobenega elementa zaloge'
+b'DocType: Chapter',b'Chapter Head',b'Poglavje glave'
+b'DocType: Payment Term',b'Month(s) after the end of the invoice month',b'Mesec (i) po koncu meseca ra\xc4\x8duna'
+b'apps/erpnext/erpnext/config/projects.py +24',b'Project activity / task.',b'Projektna dejavnost / naloga.'
+b'DocType: Vehicle Log',b'Refuelling Details',b'Oskrba z gorivom Podrobnosti'
+b'apps/erpnext/erpnext/config/hr.py +104',b'Generate Salary Slips',b'Ustvarjajo pla\xc4\x8de kombine\xc5\xbee'
+b'apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +25',b'Lab result datetime cannot be before testing datetime',b'Datetime rezultatov laboratorija ne more biti pred testiranjem datetime'
+b'DocType: POS Profile',b'Allow user to edit Discount',b'Dovoli uporabniku urejanje popusta'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +55',b'Get customers from',b'Pridobite stranke od'
+b'DocType: Purchase Invoice Item',b'Include Exploded Items',b'Vklju\xc4\x8di eksplodirane elemente'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +45',"b'Buying must be checked, if Applicable For is selected as {0}'","b'Odkup je treba preveriti, \xc4\x8de se uporablja za izbrana kot {0}'"
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40',b'Discount must be less than 100',"b'Popust, mora biti manj kot 100'"
+b'DocType: Shipping Rule',b'Restrict to Countries',b'Omeji na dr\xc5\xbeave'
+b'DocType: Purchase Invoice',b'Write Off Amount (Company Currency)',b'Napi\xc5\xa1ite enkratni znesek (dru\xc5\xbeba Valuta)'
+b'DocType: Sales Invoice Timesheet',b'Billing Hours',b'zara\xc4\x8dunavanje storitev ure'
+b'DocType: Project',b'Total Sales Amount (via Sales Order)',b'Skupni znesek prodaje (preko prodajnega naloga)'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +548',b'Default BOM for {0} not found',b'Privzeti BOM za {0} ni bilo mogo\xc4\x8de najti'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +514',b'Row #{0}: Please set reorder quantity',b'Vrstica # {0}: Prosim nastavite naro\xc4\x8dni\xc5\xa1ko koli\xc4\x8dino'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +20',b'Tap items to add them here',"b'Dotaknite predmete, da jih dodate tukaj'"
+b'DocType: Fees',b'Program Enrollment',b'Program Vpis'
+b'DocType: Share Transfer',b'To Folio No',b'V Folio \xc5\xa1t'
+b'DocType: Landed Cost Voucher',b'Landed Cost Voucher',b'Pristali Stro\xc5\xa1ki bon'
+b'apps/erpnext/erpnext/public/js/queries.js +39',b'Please set {0}',"b'Prosim, nastavite {0}'"
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37',b'{0} - {1} is inactive student',b'{0} - {1} neaktiven \xc5\xa1tudent'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37',b'{0} - {1} is inactive student',b'{0} - {1} neaktiven \xc5\xa1tudent'
+b'DocType: Employee',b'Health Details',b'Podrobnosti zdravja'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24',b'To create a Payment Request reference document is required',b'\xc4\x8ce \xc5\xbeelite ustvariti zahtevek za pla\xc4\x8dilo je potrebno referen\xc4\x8dni dokument'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24',b'To create a Payment Request reference document is required',b'\xc4\x8ce \xc5\xbeelite ustvariti zahtevek za pla\xc4\x8dilo je potrebno referen\xc4\x8dni dokument'
+b'DocType: Soil Texture',b'Sandy Clay',b'Sandy Clay'
+b'DocType: Grant Application',b'Assessment  Manager',b'Ocenjevalec'
+b'DocType: Payment Entry',b'Allocate Payment Amount',b'Dodeli znesek pla\xc4\x8dila'
+b'DocType: Employee External Work History',b'Salary',b'Pla\xc4\x8da'
+b'DocType: Serial No',b'Delivery Document Type',b'Dostava Document Type'
+b'DocType: Sales Order',b'Partly Delivered',b'Delno Delivered'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48',b'Item Code &gt; Item Group &gt; Brand',b'Koda postavke&gt; Skupina izdelkov&gt; Blagovna znamka'
+b'DocType: Item Variant Settings',b'Do not update variants on save',b'Ne shranjujte razli\xc4\x8dic pri shranjevanju'
+b'DocType: Email Digest',b'Receivables',b'Terjatve'
+b'DocType: Lead Source',b'Lead Source',b'Vir ponudbe'
+b'DocType: Customer',b'Additional information regarding the customer.',b'Dodatne informacije o kupcu.'
+b'DocType: Quality Inspection Reading',b'Reading 5',b'Branje 5'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +236',"b'{0} {1} is associated with {2}, but Party Account is {3}'","b'{0} {1} je povezan z {2}, vendar je Ra\xc4\x8dun stranke {3}'"
+b'apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7',b'View Lab Tests',b'Oglejte si laboratorijske preiskave'
+b'DocType: Purchase Invoice',b'Y',b'Y'
+b'DocType: Maintenance Visit',b'Maintenance Date',b'Vzdr\xc5\xbeevanje Datum'
+b'DocType: Purchase Invoice Item',b'Rejected Serial No',b'Zavrnjeno Zaporedna \xc5\xa1tevilka'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82',b'Year start date or end date is overlapping with {0}. To avoid please set company',"b'Leto datum za\xc4\x8detka oziroma prenehanja se prekrivajo z {0}. Da bi se izognili prosim, da podjetje'"
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +122',b'Please mention the Lead Name in Lead {0}',"b'Prosimo, navedite vodilno ime v vodniku {0}'"
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156',b'Start date should be less than end date for Item {0}',b'Za\xc4\x8detni datum mora biti manj\xc5\xa1a od kon\xc4\x8dnega datuma za postavko {0}'
+b'DocType: Item',"b'Example: ABCD.#####\nIf 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.'","b'Primer:. ABCD ##### \xc4\x8ce je serija nastavljen in serijska \xc5\xa1tevilka ni navedena v transakcijah, se bo ustvaril nato samodejno serijska \xc5\xa1tevilka, ki temelji na tej seriji. \xc4\x8ce ste si vedno \xc5\xbeeleli izrecno omeniti Serial \xc5\xa1tevilk za to postavko. pustite prazno.'"
+b'DocType: Upload Attendance',b'Upload Attendance',b'Nalo\xc5\xbei Udele\xc5\xbeba'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +579',b'BOM and Manufacturing Quantity are required',b'BOM and Manufacturing Koli\xc4\x8dina so obvezna'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +50',b'Ageing Range 2',b'Staranje Razpon 2'
+b'DocType: SG Creation Tool Course',b'Max Strength',b'Max mo\xc4\x8d'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28',b'Installing presets',b'Namestitev prednastavitev'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +85',b'No Delivery Note selected for Customer {}',b'Za kupca ni izbranega obvestila o dostavi {}'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +25',b'BOM replaced',b'BOM nadomesti'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1052',b'Select Items based on Delivery Date',b'Izberite elemente glede na datum dostave'
+b'DocType: Grant Application',b'Has any past Grant Record',b'Ima dodeljen zapis'
+,b'Sales Analytics',b'Prodajna analitika'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +127',b'Available {0}',b'Na voljo {0}'
+,b'Prospects Engaged But Not Converted',b'Obeti Ukvarjajo pa ne pretvorijo'
+,b'Prospects Engaged But Not Converted',b'Obeti Ukvarjajo pa ne pretvorijo'
+b'DocType: Manufacturing Settings',b'Manufacturing Settings',b'Proizvodne Nastavitve'
+b'apps/erpnext/erpnext/config/setup.py +56',b'Setting up Email',b'Postavitev Email'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57',b'Guardian1 Mobile No',b'Guardian1 Mobile No'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106',b'Please enter default currency in Company Master',b'Vnesite privzeto valuto v podjetju Master'
+b'DocType: Stock Entry Detail',b'Stock Entry Detail',b'Stock Za\xc4\x8detek Detail'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109',b'Daily Reminders',b'Dnevni opomniki'
+b'DocType: Products Settings',b'Home Page is Products',b'Doma\xc4\x8da stran je izdelki'
+,b'Asset Depreciation Ledger',b'Sredstvo Amortizacija Ledger'
+b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +91',b'Tax Rule Conflicts with {0}',b'Dav\xc4\x8dna Pravilo Konflikti z {0}'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25',b'New Account Name',b'Novo ime ra\xc4\x8duna'
+b'DocType: Purchase Invoice Item',b'Raw Materials Supplied Cost',"b'Surovin, dobavljenih Stro\xc5\xa1ki'"
+b'DocType: Selling Settings',b'Settings for Selling Module',b'Nastavitve za modul Prodaja'
+b'DocType: Hotel Room Reservation',b'Hotel Room Reservation',b'Rezervacija hotelske sobe'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115',b'Customer Service',b'Storitev za stranke'
+b'DocType: BOM',b'Thumbnail',b'Thumbnail'
+b'DocType: Item Customer Detail',b'Item Customer Detail',b'Postavka Detail Stranka'
+b'apps/erpnext/erpnext/config/hr.py +50',b'Offer candidate a Job.',b'Ponudba kandidat Job.'
+b'DocType: Notification Control',b'Prompt for Email on Submission of',b'Vpra\xc5\xa1al za e-po\xc5\xa1tni ob predlo\xc5\xbeitvi'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88',b'Total allocated leaves are more than days in the period',b'Skupaj dodeljena listi so ve\xc4\x8d kot dni v obdobju'
+b'DocType: Land Unit',b'Linked Soil Analysis',b'Povezana analiza tal'
+b'DocType: Pricing Rule',b'Percentage',b'odstotek'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70',b'Item {0} must be a stock Item',b'Postavka {0} mora biti stock postavka'
+b'DocType: Manufacturing Settings',b'Default Work In Progress Warehouse',b'Privzeto Delo v skladi\xc5\xa1\xc4\x8du napredku'
+b'apps/erpnext/erpnext/config/accounts.py +288',b'Default settings for accounting transactions.',b'Privzete nastavitve za ra\xc4\x8dunovodske posle.'
+b'DocType: Maintenance Visit',b'MV',b'MV'
+b'DocType: Restaurant',b'Default Tax Template',b'Privzeta dav\xc4\x8dna predloga'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +66',b'{0} Students have been enrolled',b'{0} \xc5\xa0tudenti so bili vpisani'
+b'DocType: Fees',b'Student Details',b'Podrobnosti \xc5\xa1tudenta'
+b'DocType: Purchase Invoice Item',b'Stock Qty',b'Stock Kol'
+b'DocType: Purchase Invoice Item',b'Stock Qty',b'Stock Kol'
+b'DocType: Employee Loan',b'Repayment Period in Months',b'Vra\xc4\x8dilo \xc4\x8cas v mesecih'
+b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26',b'Error: Not a valid id?',b'Napaka: Ni veljaven id?'
+b'DocType: Naming Series',b'Update Series Number',b'Posodobi \xc5\xa1tevilko zaporedja'
+b'DocType: Account',b'Equity',b'Kapital'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78',"b""{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry""","b'{0} {1}: ""Izkaz poslovnega izida"" tip ra\xc4\x8duna {2} ni dovoljen v Otvoritvenem zapisu'"
+b'DocType: Sales Order',b'Printing Details',b'Tiskanje Podrobnosti'
+b'DocType: Task',b'Closing Date',b'Zapiranje Datum'
+b'DocType: Sales Order Item',b'Produced Quantity',b'Proizvedena koli\xc4\x8dina'
+b'DocType: Timesheet',b'Work Detail',b'Delovna detajl'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126',b'Engineer',b'In\xc5\xbeenir'
+b'DocType: Journal Entry',b'Total Amount Currency',b'Skupni znesek Valuta'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38',b'Search Sub Assemblies',b'Iskanje sklope'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171',b'Item Code required at Row No {0}',b'Oznaka zahteva pri Row \xc5\xa1t {0}'
+b'DocType: GST Account',b'SGST Account',b'Ra\xc4\x8dun SGST'
+b'apps/erpnext/erpnext/utilities/user_progress.py +154',b'Go to Items',b'Pojdi na elemente'
+b'DocType: Sales Partner',b'Partner Type',b'Partner Type'
+b'DocType: Purchase Taxes and Charges',b'Actual',b'Actual'
+b'DocType: Restaurant Menu',b'Restaurant Manager',b'Upravitelj restavracij'
+b'DocType: Authorization Rule',b'Customerwise Discount',b'Customerwise Popust'
+b'apps/erpnext/erpnext/config/projects.py +46',b'Timesheet for tasks.',b'Timesheet za naloge.'
+b'DocType: Purchase Invoice',b'Against Expense Account',b'Proti Expense ra\xc4\x8dun'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +282',b'Installation Note {0} has already been submitted',b'Je \xc5\xbee bil predlo\xc5\xbeen Namestitev Opomba {0}'
+b'DocType: Bank Reconciliation',b'Get Payment Entries',b'Dobili pla\xc4\x8dila Entries'
+b'DocType: Quotation Item',b'Against Docname',b'Proti Docname'
+b'DocType: SMS Center',b'All Employee (Active)',b'Vsi zaposlenih (Active)'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9',b'View Now',b'Oglejte si zdaj'
+b'DocType: BOM',b'Raw Material Cost',b'Raw Material Stro\xc5\xa1ki'
+b'DocType: Item Reorder',b'Re-Order Level',b'Ponovno naro\xc4\x8dila ravni'
+b'apps/erpnext/erpnext/projects/doctype/project/project.js +54',b'Gantt Chart',b'Gantogram'
+b'DocType: Crop Cycle',b'Cycle Type',b'Vrsta cikla'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99',b'Part-time',b'Kraj\xc5\xa1i delovni \xc4\x8das'
+b'DocType: Employee',b'Applicable Holiday List',b'Velja Holiday Seznam'
+b'DocType: Employee',b'Cheque',b'\xc4\x8cek'
+b'DocType: Training Event',b'Employee Emails',b'Emails za zaposlene'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +60',b'Series Updated',b'Zaporedje posodobljeno'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +159',b'Report Type is mandatory',b'Vrsta poro\xc4\x8dila je obvezna'
+b'DocType: Item',b'Serial Number Series',b'Serijska \xc5\xa1tevilka zaporedja'
+b'apps/erpnext/erpnext/buying/utils.py +68',b'Warehouse is mandatory for stock Item {0} in row {1}',b'Skladi\xc5\xa1\xc4\x8de je obvezna za borzo postavki {0} v vrstici {1}'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45',b'Retail & Wholesale',b'Trgovina na drobno in na debelo'
+b'DocType: Issue',b'First Responded On',b'Najprej odgovorila'
+b'DocType: Website Item Group',b'Cross Listing of Item in multiple groups',b'Cross Uvrstitev to\xc4\x8dke v ve\xc4\x8d skupinah'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90',b'Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0}',b'Fiskalna Leto Start Date in fiskalno leto End Date so \xc5\xbee dolo\xc4\x8deni v prora\xc4\x8dunskem letu {0}'
+b'DocType: Projects Settings',b'Ignore User Time Overlap',b'Prezreti preklop uporabni\xc5\xa1kega \xc4\x8dasa'
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +113',b'Clearance Date updated',b'Potrditev Datum posodobljeni'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +146',b'Split Batch',b'Split Serija'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +146',b'Split Batch',b'Split Serija'
+b'DocType: Stock Settings',b'Batch Identification',b'Identifikacija serije'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132',b'Successfully Reconciled',b'Uspe\xc5\xa1no usklajeno'
+b'DocType: Request for Quotation Supplier',b'Download PDF',b'Prenos PDF'
+b'DocType: Work Order',b'Planned End Date',b'Na\xc4\x8drtovan End Date'
+b'DocType: Shareholder',b'Hidden list maintaining the list of contacts linked to Shareholder',"b'Skrit seznam, ki vodi seznam kontaktov, povezanih z delni\xc4\x8darjem'"
+b'apps/erpnext/erpnext/config/non_profit.py +63',b'Donor Type information.',b'Podatki o donatorju.'
+b'DocType: Request for Quotation',b'Supplier Detail',b'Dobavitelj Podrobnosti'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100',b'Error in formula or condition: {0}',b'Napaka v formuli ali stanja: {0}'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +99',b'Invoiced Amount',b'Obra\xc4\x8dunani znesek'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47',b'Criteria weights must add up to 100%',b'Ute\xc5\xbei meril morajo biti do 100%'
+b'apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7',b'Attendance',b'Udele\xc5\xbeba'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +115',b'Stock Items',b'zalogi'
+b'DocType: BOM',b'Materials',b'Materiali'
+b'DocType: Leave Block List',"b'If not checked, the list will have to be added to each Department where it has to be applied.'","b'\xc4\x8ce ni izbrana, bo seznam je treba dodati, da vsak oddelek, kjer je treba uporabiti.'"
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +111',b'Creating {0}',b'Ustvarjanje {0}'
+b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28',b'Source and Target Warehouse cannot be same',b'Vir in Target skladi\xc5\xa1\xc4\x8da ne more biti enaka'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +586',b'Posting date and posting time is mandatory',"b'Napotitev datum in \xc4\x8das objavljate, je obvezna'"
+b'apps/erpnext/erpnext/config/buying.py +76',b'Tax template for buying transactions.',b'Dav\xc4\x8dna predloga za nabavne transakcije'
+,b'Item Prices',b'Postavka Cene'
+b'DocType: Purchase Order',b'In Words will be visible once you save the Purchase Order.',"b'V besedi bo viden, ko boste prihranili naro\xc4\x8dilnico.'"
+b'DocType: Period Closing Voucher',b'Period Closing Voucher',b'Obdobje Closing bon'
+b'DocType: Consultation',b'Review Details',b'Pregled podrobnosti'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +185',b'The shareholder does not belong to this company',b'Delni\xc4\x8dar ne pripada tej dru\xc5\xbebi'
+b'DocType: Dosage Form',b'Dosage Form',b'Odmerni obrazec'
+b'apps/erpnext/erpnext/config/selling.py +67',b'Price List master.',b'Cenik gospodar.'
+b'DocType: Task',b'Review Date',b'Pregled Datum'
+b'DocType: Company',b'Series for Asset Depreciation Entry (Journal Entry)',b'Serija za vpis vrednosti amortizacije (dnevnik)'
+b'DocType: Membership',b'Member Since',b'\xc4\x8clan od'
+b'DocType: Purchase Invoice',b'Advance Payments',b'Predpla\xc4\x8dila'
+b'DocType: Purchase Taxes and Charges',b'On Net Total',b'On Net Total'
+b'apps/erpnext/erpnext/controllers/item_variant.py +92',b'Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4}',b'Vrednost atributa {0} mora biti v razponu od {1} do {2} v korakih po {3} za postavko {4}'
+b'DocType: Restaurant Reservation',b'Waitlisted',b'Waitlisted'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +124',b'Currency can not be changed after making entries using some other currency',"b'Valuta ni mogo\xc4\x8de spremeniti, potem ko vnose uporabljate kak\xc5\xa1no drugo valuto'"
+b'DocType: Shipping Rule',b'Fixed',b'Popravljeno'
+b'DocType: Vehicle Service',b'Clutch Plate',b'sklopka Plate'
+b'DocType: Company',b'Round Off Account',b'Zaokro\xc5\xbeijo ra\xc4\x8dun'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93',b'Administrative Expenses',b'Administrativni stro\xc5\xa1ki'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18',b'Consulting',b'Consulting'
+b'DocType: Customer Group',b'Parent Customer Group',b'Parent Customer Group'
+b'DocType: Journal Entry',b'Subscription',b'Naro\xc4\x8dnina'
+b'DocType: Purchase Invoice',b'Contact Email',b'Kontakt E-po\xc5\xa1ta'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11',b'Fee Creation Pending',b'\xc4\x8cakanje v kreiranju'
+b'DocType: Appraisal Goal',b'Score Earned',b'Rezultat Zaslu\xc5\xbeili'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +241',b'Notice Period',b'Odpovedni rok'
+b'DocType: Asset Category',b'Asset Category Name',b'Sredstvo Kategorija Ime'
+b'apps/erpnext/erpnext/setup/doctype/territory/territory.js +13',b'This is a root territory and cannot be edited.',b'To je koren ozemlje in ga ni mogo\xc4\x8de urejati.'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5',b'New Sales Person Name',b'Ime New Sales oseba'
+b'DocType: Packing Slip',b'Gross Weight UOM',b'Bruto Te\xc5\xbea UOM'
+b'DocType: Asset Maintenance Task',b'Preventive Maintenance',b'Preventivno vzdr\xc5\xbeevanje'
+b'DocType: Delivery Note Item',b'Against Sales Invoice',b'Za ra\xc4\x8dun'
+b'DocType: Purchase Invoice',b'07-Others',b'07-Drugo'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151',b'Please enter serial numbers for serialized item ',b'Vnesite serijske \xc5\xa1tevilke za serialized postavko'
+b'DocType: Bin',b'Reserved Qty for Production',b'Rezervirano Koli\xc4\x8dina za proizvodnjo'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43',b'EcritureNum',b'EcritureNum'
+b'DocType: Student Group Creation Tool',"b""Leave unchecked if you don't want to consider batch while making course based groups. ""","b'Pustite neozna\xc4\x8deno, \xc4\x8de ne \xc5\xbeelite, da razmisli serije, hkrati pa seveda temelji skupin.'"
+b'DocType: Asset',b'Frequency of Depreciation (Months)',b'Pogostost amortizacijo (meseci)'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +500',b'Credit Account',b'Credit ra\xc4\x8dun'
+b'DocType: Landed Cost Item',b'Landed Cost Item',b'Pristali Stro\xc5\xa1ki Postavka'
+b'apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57',b'Show zero values',b'Prika\xc5\xbei ni\xc4\x8delnimi vrednostmi'
+b'DocType: BOM',b'Quantity of item obtained after manufacturing / repacking from given quantities of raw materials',b'Koli\xc4\x8dina postavke pridobljeno po proizvodnji / prepakiranja iz danih koli\xc4\x8din surovin'
+b'DocType: Lab Test',b'Test Group',b'Testna skupina'
+b'DocType: Payment Reconciliation',b'Receivable / Payable Account',b'Terjatve / pla\xc4\x8dljivo ra\xc4\x8dun'
+b'DocType: Delivery Note Item',b'Against Sales Order Item',b'Proti Sales Order Postavka'
+b'DocType: Company',b'Company Logo',b'Logo podjetja'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +709',b'Please specify Attribute Value for attribute {0}',"b'Prosimo, navedite Lastnost vrednost za atribut {0}'"
+b'DocType: Item',b'Default Warehouse',b'Privzeto Skladi\xc5\xa1\xc4\x8de'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45',b'Budget cannot be assigned against Group Account {0}',b'Prora\xc4\x8dun ne more biti dodeljena pred Group ra\xc4\x8dun {0}'
+b'DocType: Healthcare Settings',b'Patient Registration',b'Registracija pacientov'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22',b'Please enter parent cost center',b'Vnesite stro\xc5\xa1kovno mesto mati\xc4\x8dno'
+b'DocType: Delivery Note',b'Print Without Amount',b'Natisni Brez Znesek'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57',b'Depreciation Date',b'Amortizacija Datum'
+,b'Work Orders in Progress',b'Delovni nalogi v teku'
+b'DocType: Issue',b'Support Team',b'Support Team'
+b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36',b'Expiry (In Days)',b'Iztek (v dnevih)'
+b'DocType: Appraisal',b'Total Score (Out of 5)',b'Skupna ocena (od 5)'
+b'DocType: Fee Structure',b'FS.',b'FS.'
+b'DocType: Student Attendance Tool',b'Batch',b'Serija'
+b'DocType: Donor',b'Donor Type',b'Vrsta donatorja'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +27',b'Balance',b'Bilanca'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66',b'Please select the Company',b'Izberite podjetje'
+b'DocType: Room',b'Seating Capacity',b'\xc5\xa0tevilo sede\xc5\xbeev'
+b'DocType: Issue',b'ISS-',b'ISS-'
+b'DocType: Lab Test Groups',b'Lab Test Groups',b'Laboratorijske skupine'
+b'DocType: Project',b'Total Expense Claim (via Expense Claims)',b'Total Expense zahtevek (preko Expense zahtevkov)'
+b'DocType: GST Settings',b'GST Summary',b'DDV Povzetek'
+b'apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py +16',b'Please enable default incoming account before creating Daily Work Summary Group',"b'Prosimo, omogo\xc4\x8dite privzeti dohodni ra\xc4\x8dun, preden ustvarite skupino povzetkov dnevnega reda'"
+b'DocType: Assessment Result',b'Total Score',b'Skupni rezultat'
+b'DocType: Journal Entry',b'Debit Note',b'Opomin'
+b'DocType: Stock Entry',b'As per Stock UOM',b'Kot je na borzi UOM'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7',b'Not Expired',b'Ni potekel'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +49',b'ValidDate',b'ValidDate'
+b'DocType: Student Log',b'Achievement',b'dose\xc5\xbeek'
+b'DocType: Batch',b'Source Document Type',b'Vir Vrsta dokumenta'
+b'DocType: Batch',b'Source Document Type',b'Vir Vrsta dokumenta'
+b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24',b'Following course schedules were created',b'Ustanovljeni so bili naslednji razporedi te\xc4\x8daja'
+b'DocType: Journal Entry',b'Total Debit',b'Skupaj Debetna'
+b'DocType: Manufacturing Settings',b'Default Finished Goods Warehouse',b'Privzete Kon\xc4\x8dano Blago Skladi\xc5\xa1\xc4\x8de'
+b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +108',b'Please select Patient',b'Izberite Patient'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76',b'Sales Person',b'Prodaja oseba'
+b'DocType: Hotel Room Package',b'Amenities',b'Amenities'
+b'apps/erpnext/erpnext/config/accounts.py +233',b'Budget and Cost Center',b'Prora\xc4\x8dun in Center Stro\xc5\xa1ki'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65',b'Multiple default mode of payment is not allowed',b'Ve\xc4\x8dkratni na\xc4\x8din pla\xc4\x8dila ni dovoljen'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5',b'for the',b'za'
+,b'Appointment Analytics',b'Imenovanje Analytics'
+b'DocType: Vehicle Service',b'Half Yearly',b'Polletni'
+b'DocType: Lead',b'Blog Subscriber',b'Blog Subscriber'
+b'DocType: Guardian',b'Alternate Number',b'namestnik \xc5\xa0tevilo'
+b'DocType: Healthcare Settings',b'Consultations in valid days',b'Posvetovanja v veljavnih dneh'
+b'DocType: Assessment Plan Criteria',b'Maximum Score',b'Najvi\xc5\xa1ja ocena'
+b'apps/erpnext/erpnext/config/setup.py +83',b'Create rules to restrict transactions based on values.',"b'Ustvarite pravila za omejitev transakcije, ki temeljijo na vrednotah.'"
+b'DocType: Cash Flow Mapping Accounts',b'Cash Flow Mapping Accounts',b'Ra\xc4\x8dunovodski pregledi denarnih tokov'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49',b' Group Roll No',b'\xc5\xa0tevilka skupine'
+b'DocType: Batch',b'Manufacturing Date',b'Datum izdelave'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9',b'Fee Creation Failed',b'Ustvarjanje provizij ni uspelo'
+b'DocType: Opening Invoice Creation Tool',b'Create Missing Party',b'Ustvari manjkajo\xc4\x8do stranko'
+b'DocType: Student Group Creation Tool',b'Leave blank if you make students groups per year',"b'Pustite prazno, \xc4\x8de bi \xc5\xa1tudenti skupin na leto'"
+b'DocType: Student Group Creation Tool',b'Leave blank if you make students groups per year',"b'Pustite prazno, \xc4\x8de bi \xc5\xa1tudenti skupin na leto'"
+b'DocType: HR Settings',"b'If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day'","b'\xc4\x8ce je ozna\xc4\x8deno, Total no. delovnih dni bo vklju\xc4\x8deval praznike, in to se bo zmanj\xc5\xa1ala vrednost pla\xc4\x8d dan na'"
+b'DocType: Purchase Invoice',b'Total Advance',b'Skupaj predpla\xc4\x8dila'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27',b'Change Template Code',b'Spremeni kodo \xc5\xa1ablone'
+b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +23',b'The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.',b'Izraz Kon\xc4\x8dni datum ne more biti zgodnej\xc5\xa1i od datuma Term Start. Popravite datum in poskusite znova.'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19',b'Quot Count',b'quot \xc5\xa0tetje'
+,b'BOM Stock Report',b'BOM Stock Poro\xc4\x8dilo'
+b'DocType: Stock Reconciliation Item',b'Quantity Difference',b'koli\xc4\x8dina Razlika'
+b'DocType: Employee Advance',b'EA-',b'EA-'
+b'DocType: Opportunity Item',b'Basic Rate',b'Osnovni te\xc4\x8daj'
+b'DocType: GL Entry',b'Credit Amount',b'Credit Znesek'
+b'DocType: Cheque Print Template',b'Signatory Position',b'podpisnik Polo\xc5\xbeaj'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +173',b'Set as Lost',b'Nastavi kot Lost'
+b'DocType: Timesheet',b'Total Billable Hours',b'Skupaj pla\xc4\x8dljivih ur'
+b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4',b'Payment Receipt Note',b'Prejem pla\xc4\x8dilnih Note'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6',b'This is based on transactions against this Customer. See timeline below for details',b'Ta temelji na transakcijah zoper to stranko. Oglejte si \xc4\x8dasovnico spodaj za podrobnosti'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +162',b'Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2}',"b'Vrstica {0}: Dodeljena koli\xc4\x8dina {1}, mora biti manj\xc5\xa1a ali enaka pla\xc4\x8dila za vnos zneska {2}'"
+b'DocType: Program Enrollment Tool',b'New Academic Term',b'Novi akademski izraz'
+,b'Course wise Assessment Report',b'Seveda pametno poro\xc4\x8dilo o oceni'
+b'DocType: Purchase Invoice',b'Availed ITC State/UT Tax',b'Izkoristil dav\xc4\x8dno olaj\xc5\xa1avo dr\xc5\xbeave / UT'
+b'DocType: Tax Rule',b'Tax Rule',b'Dav\xc4\x8dna Pravilo'
+b'DocType: Selling Settings',b'Maintain Same Rate Throughout Sales Cycle',b'Ohraniti ista stopnja V celotnem ciklu prodaje'
+b'DocType: Manufacturing Settings',b'Plan time logs outside Workstation Working Hours.',b'Na\xc4\x8drtujte \xc4\x8das dnevnike zunaj Workstation delovnih ur.'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +115',b'Dr {0} does not have a Physician Schedule. Add it in Physician master',b'Dr {0} nima urnika zdravnika. Dodajte ga v glavnega zdravnika'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +98',b'Customers in Queue',b'Stranke v vrsti'
+b'DocType: Driver',b'Issuing Date',b'Datum izdaje'
+b'DocType: Student',b'Nationality',b'dr\xc5\xbeavljanstvo'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +109',b'Submit this Work Order for further processing.',b'Po\xc5\xa1ljite ta delovni nalog za nadaljnjo obdelavo.'
+,b'Items To Be Requested',"b'Predmeti, ki bodo zahtevana'"
+b'DocType: Purchase Order',b'Get Last Purchase Rate',b'Get zadnjega nakupa Rate'
+b'DocType: Company',b'Company Info',b'Informacije o podjetju'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1385',b'Select or add new customer',b'Izberite ali dodati novo stranko'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +173',b'Cost center is required to book an expense claim',b'Stro\xc5\xa1kovno mesto je potrebno rezervirati odhodek zahtevek'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9',b'Application of Funds (Assets)',b'Uporaba sredstev (sredstva)'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6',b'This is based on the attendance of this Employee',b'Ta temelji na prisotnosti tega zaposlenega'
+b'DocType: Assessment Result',b'Summary',b'Povzetek'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112',b'Mark Attendance',b'Ozna\xc4\x8di udele\xc5\xbebo'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +494',b'Debit Account',b'Debetni ra\xc4\x8dun'
+b'DocType: Fiscal Year',b'Year Start Date',b'Leto Start Date'
+b'DocType: Attendance',b'Employee Name',b'ime zaposlenega'
+b'DocType: Restaurant Order Entry Item',b'Restaurant Order Entry Item',b'Vnos naro\xc4\x8dila restavracije'
+b'DocType: Purchase Invoice',b'Rounded Total (Company Currency)',b'Zaokro\xc5\xbeena Skupaj (Company Valuta)'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +96',b'Cannot covert to Group because Account Type is selected.',"b'Ne more prikrite skupini, saj je izbrana vrsta ra\xc4\x8duna.'"
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260',b'{0} {1} has been modified. Please refresh.',b'{0} {1} je bila spremenjena. Osve\xc5\xbeite.'
+b'DocType: Leave Block List',b'Stop users from making Leave Applications on following days.',b'Stop uporabnike iz \xc4\x8desar dopusta aplikacij na naslednjih dneh.'
+b'DocType: Asset Maintenance Team',b'Maintenance Team Members',b'\xc4\x8clani vzdr\xc5\xbeevalne ekipe'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63',b'Purchase Amount',b'Znesek nakupa'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +261',b'Supplier Quotation {0} created',b'Dobavitelj za predra\xc4\x8dun {0} ustvaril'
+b'apps/erpnext/erpnext/accounts/report/financial_statements.py +103',b'End Year cannot be before Start Year',b'Konec leta ne more biti pred za\xc4\x8detkom leta'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234',b'Employee Benefits',b'Zaslu\xc5\xbeki zaposlencev'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +264',b'Packed quantity must equal quantity for Item {0} in row {1}',b'Pakirana koli\xc4\x8dina mora biti enaka koli\xc4\x8dini za postavko {0} v vrstici {1}'
+b'DocType: Work Order',b'Manufactured Qty',b'Izdelano Kol'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +78',"b""The shares don't exist with the {0}""",b'Delnice ne obstajajo z {0}'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64',b'Invoice Created',b'Ra\xc4\x8dun ustvarjen'
+b'DocType: Asset',b'Out of Order',b'Ne deluje'
+b'DocType: Purchase Receipt Item',b'Accepted Quantity',b'Accepted Koli\xc4\x8dina'
+b'DocType: Projects Settings',b'Ignore Workstation Time Overlap',b'Prezri \xc4\x8das prekrivanja delovne postaje'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +242',b'Please set a default Holiday List for Employee {0} or Company {1}',b'Nastavite privzeto Hi\xc5\xa1a List za zaposlenega {0} ali podjetja {1}'
+b'apps/erpnext/erpnext/accounts/party.py +30',b'{0}: {1} does not exists',b'{0}: {1} ne obstaja'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76',b'Select Batch Numbers',b'Izberite \xc5\xa1tevilke Serija'
+b'apps/erpnext/erpnext/config/accounts.py +12',b'Bills raised to Customers.',b'Ra\xc4\x8duni zbrana strankam.'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26',b'Project Id',b'ID Projekta'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +534',b'Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2}',b'Vrstica \xc5\xa1t {0}: koli\xc4\x8dina ne more biti ve\xc4\x8dja od Dokler Znesek proti Expense zahtevka {1}. Dokler Znesek je {2}'
+b'DocType: Patient Service Unit',b'Medical Administrator',b'Zdravstveni administrator'
+b'DocType: Assessment Plan',b'Schedule',b'Urnik'
+b'DocType: Account',b'Parent Account',b'Mati\xc4\x8dni ra\xc4\x8dun'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266',b'Available',b'Na voljo'
+b'DocType: Quality Inspection Reading',b'Reading 3',b'Branje 3'
+b'DocType: Stock Entry',b'Source Warehouse Address',b'Naslov skladi\xc5\xa1\xc4\x8da vira'
+,b'Hub',b'Vozli\xc5\xa1\xc4\x8de'
+b'DocType: GL Entry',b'Voucher Type',b'Bon Type'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1717',b'Price List not found or disabled',b'Cenik ni mogo\xc4\x8de najti ali onemogo\xc4\x8dena'
+b'DocType: Student Applicant',b'Approved',b'Odobreno'
+b'apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15',b'Price',b'Cena'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +267',"b""Employee relieved on {0} must be set as 'Left'""",b'Zaposleni razre\xc5\xa1en na {0} mora biti nastavljen kot &quot;levo&quot;'
+b'DocType: Hub Settings',b'Last Sync On',b'Zadnja sinhronizacija je vklju\xc4\x8dena'
+b'DocType: Guardian',b'Guardian',b'Guardian'
+b'DocType: Opening Invoice Creation Tool',b'Create missing customer or supplier.',b'Ustvari manjkajo\xc4\x8do stranko ali dobavitelja.'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42',b'Appraisal {0} created for Employee {1} in the given date range',b'Cenitev {0} ustvarjena za Employee {1} v dolo\xc4\x8denem \xc4\x8dasovnem obdobju'
+b'DocType: Academic Term',b'Education',b'Izobra\xc5\xbeevanje'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +89',b'Del',b'del'
+b'DocType: Selling Settings',b'Campaign Naming By',b'Imenovanje akcija Z'
+b'DocType: Employee',b'Current Address Is',b'Trenutni Naslov je'
+b'apps/erpnext/erpnext/utilities/user_progress.py +51',b'Monthly Sales Target (',b'Mese\xc4\x8dna prodajna tar\xc4\x8da ('
+b'DocType: Physician Service Unit Schedule',b'Physician Service Unit Schedule',b'Urnik servisnih enot zdravnika'
+b'apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9',b'modified',b'spremenjene'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43',"b""Optional. Sets company's default currency, if not specified.""","b'Neobvezno. Nastavi privzeto valuto dru\xc5\xbebe, \xc4\x8de ni dolo\xc4\x8deno.'"
+b'DocType: Sales Invoice',b'Customer GSTIN',b'GSTIN stranka'
+b'DocType: Crop Cycle',"b""List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ""","b'Seznam bolezni, odkritih na terenu. Ko je izbran, bo samodejno dodal seznam nalog, ki se ukvarjajo z boleznijo'"
+b'DocType: Asset Repair',b'Repair Status',b'Stanje popravila'
+b'apps/erpnext/erpnext/config/accounts.py +67',b'Accounting journal entries.',b'Vpisi ra\xc4\x8dunovodstvo lista.'
+b'DocType: Delivery Note Item',b'Available Qty at From Warehouse',b'Na voljo Koli\xc4\x8dina na IZ SKLADI\xc5\xa0\xc4\x8cA'
+b'DocType: POS Profile',b'Account for Change Amount',b'Ra\xc4\x8dun za znesek spremembe'
+b'DocType: Purchase Invoice',b'input service',b'vnosna storitev'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217',b'Row {0}: Party / Account does not match with {1} / {2} in {3} {4}',b'Vrstica {0}: Party / ra\xc4\x8dun se ne ujema z {1} / {2} v {3} {4}'
+b'DocType: Maintenance Team Member',b'Maintenance Team Member',b'\xc4\x8clan vzdr\xc5\xbeevalne ekipe'
+b'DocType: Agriculture Analysis Criteria',b'Soil Analysis',b'Analiza tal'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +13',b'Course Code: ',b'\xc5\xa0ifra predmeta:'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240',b'Please enter Expense Account',b'Vnesite Expense ra\xc4\x8dun'
+b'DocType: Account',b'Stock',b'Zaloga'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1095',"b'Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry'","b'Row # {0}: Reference Vrsta dokumenta mora biti eden od narocilo, Nakup ra\xc4\x8duna ali Journal Entry'"
+b'DocType: Employee',b'Current Address',b'Trenutni naslov'
+b'DocType: Item',"b'If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified'","b'\xc4\x8ce postavka je varianta drug element, potem opis, slike, cene, davki, itd bo dolo\xc4\x8dil iz predloge, razen \xc4\x8de je izrecno dolo\xc4\x8deno'"
+b'DocType: Serial No',b'Purchase / Manufacture Details',b'Nakup / Izdelava Podrobnosti'
+b'DocType: Assessment Group',b'Assessment Group',b'Skupina ocena'
+b'apps/erpnext/erpnext/config/stock.py +329',b'Batch Inventory',b'Serija Inventory'
+b'DocType: Employee',b'Contract End Date',b'Naro\xc4\x8dilo End Date'
+b'DocType: Sales Order',b'Track this Sales Order against any Project',b'Sledi tej Sales Order proti kateri koli projekt'
+b'DocType: Sales Invoice Item',b'Discount and Margin',b'Popust in Margin'
+b'DocType: Lab Test',b'Prescription',b'Predpis'
+b'DocType: Project',b'Second Email',b'Druga e-po\xc5\xa1ta'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +111',b'Not Available',b'Ni na voljo'
+b'DocType: Pricing Rule',b'Min Qty',b'Min Kol'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36',b'Disable Template',b'Onemogo\xc4\x8di predlogo'
+b'DocType: GL Entry',b'Transaction Date',b'Transakcijski Datum'
+b'DocType: Production Plan Item',b'Planned Qty',b'Na\xc4\x8drtovano Kol'
+b'apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121',b'Total Tax',b'Skupna dav\xc4\x8dna'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +204',b'For Quantity (Manufactured Qty) is mandatory',b'Za Koli\xc4\x8dina (Izdelano Kol) obvezna'
+b'DocType: Stock Entry',b'Default Target Warehouse',b'Privzeto Target Skladi\xc5\xa1\xc4\x8de'
+b'DocType: Purchase Invoice',b'Net Total (Company Currency)',b'Net Total (dru\xc5\xbeba Valuta)'
+b'apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14',b'The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.',b'Leto Kon\xc4\x8dni datum ne more biti zgodnej\xc5\xa1i od datuma Leto Start. Popravite datum in poskusite znova.'
+b'DocType: Notification Control',b'Purchase Receipt Message',b'Potrdilo o nakupu Sporo\xc4\x8dilo'
+b'DocType: BOM',b'Scrap Items',b'ostanki To\xc4\x8dke'
+b'DocType: Work Order',b'Actual Start Date',b'Dejanski datum za\xc4\x8detka'
+b'DocType: Sales Order',b'% of materials delivered against this Sales Order',b'% materiala dobavljeno po tej naro\xc4\x8dilnici'
+b'apps/erpnext/erpnext/config/manufacturing.py +18',b'Generate Material Requests (MRP) and Work Orders.',b'Ustvari materialne zahteve (MRP) in delovne naloge.'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62',b'Set default mode of payment',b'Nastavite privzeti na\xc4\x8din pla\xc4\x8dila'
+b'DocType: Grant Application',b'Withdrawn',b'umaknjena'
+b'DocType: Hub Settings',b'Hub Settings',b'Nastavitve vozli\xc5\xa1\xc4\x8da'
+b'DocType: Project',b'Gross Margin %',b'Gross Margin%'
+b'DocType: BOM',b'With Operations',b'Pri poslovanju'
+b'apps/erpnext/erpnext/accounts/party.py +259',b'Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.',b'Vknji\xc5\xbebe so \xc5\xbee bili sprejeti v valuti {0} za dru\xc5\xbebo {1}. Izberite terjatve ali obveznosti ra\xc4\x8dun z valuto {0}.'
+b'DocType: Asset',b'Is Existing Asset',b'Je obstoje\xc4\x8demu sredstvu'
+b'DocType: Salary Detail',b'Statistical Component',b'Statisti\xc4\x8dni Komponenta'
+b'DocType: Salary Detail',b'Statistical Component',b'Statisti\xc4\x8dni Komponenta'
+b'DocType: Warranty Claim',b'If different than customer address',b'\xc4\x8ce je druga\xc4\x8den od naslova kupca'
+b'DocType: Purchase Invoice',b'Without Payment of Tax',b'Brez pla\xc4\x8dila davka'
+b'DocType: BOM Operation',b'BOM Operation',b'BOM Delovanje'
+b'apps/erpnext/erpnext/config/stock.py +141',b'Fulfilment',b'Izpolnjevanje'
+b'DocType: Purchase Taxes and Charges',b'On Previous Row Amount',b'Na prej\xc5\xa1nje vrstice Znesek'
+b'DocType: Item',b'Has Expiry Date',b'Ima rok veljavnosti'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +282',b'Transfer Asset',b'prenos sredstev'
+b'DocType: POS Profile',b'POS Profile',b'POS profila'
+b'DocType: Training Event',b'Event Name',b'Ime dogodka'
+b'DocType: Physician',b'Phone (Office)',b'Telefon (Office)'
+b'apps/erpnext/erpnext/hooks.py +151',b'Admission',b'sprejem'
+b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29',b'Admissions for {0}',b'Vstopnine za {0}'
+b'apps/erpnext/erpnext/config/accounts.py +257',"b'Seasonality for setting budgets, targets etc.'","b'Sezonskost za nastavitev prora\xc4\x8dunov, cilji itd'"
+b'DocType: Supplier Scorecard Scoring Variable',b'Variable Name',b'Ime spremenljivke'
+b'apps/erpnext/erpnext/stock/get_item_details.py +144',"b'Item {0} is a template, please select one of its variants'","b'Postavka {0} je predlogo, izberite eno od njenih razli\xc4\x8dic'"
+b'DocType: Asset',b'Asset Category',b'sredstvo Kategorija'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31',b'Net pay cannot be negative',b'Neto pla\xc4\x8da ne more biti negativna'
+b'DocType: Purchase Order',b'Advance Paid',b'Advance Paid'
+b'DocType: Item',b'Item Tax',b'Postavka Tax'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +883',b'Material to Supplier',b'Material za dobavitelja'
+b'DocType: Soil Texture',b'Loamy Sand',b'Loamy Sand'
+b'DocType: Production Plan',b'Material Request Planning',b'Na\xc4\x8drtovanje materialnih zahtev'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +638',b'Excise Invoice',b'Tro\xc5\xa1arina Ra\xc4\x8dun'
+b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16',b'Treshold {0}% appears more than once',b'Praga {0}% pojavi ve\xc4\x8d kot enkrat'
+b'DocType: Expense Claim',b'Employees Email Id',b'Zaposleni Email Id'
+b'DocType: Employee Attendance Tool',b'Marked Attendance',b'markirana Udele\xc5\xbeba'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138',b'Current Liabilities',b'Kratkoro\xc4\x8dne obveznosti'
+b'apps/erpnext/erpnext/config/selling.py +297',b'Send mass SMS to your contacts',b'Po\xc5\xa1lji mno\xc5\xbei\xc4\x8dno SMS va\xc5\xa1ih stikov'
+b'DocType: Patient',b'A Positive',b'Pozitiven'
+b'DocType: Program',b'Program Name',b'Ime programa'
+b'DocType: Purchase Taxes and Charges',b'Consider Tax or Charge for',b'Razmislite davek ali dajatev za'
+b'DocType: Driver',b'Driving License Category',b'Kategorija vozni\xc5\xa1kega dovoljenja'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +158',b'No Reference',b'Brez reference'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57',b'Actual Qty is mandatory',b'Dejanska Koli\xc4\x8dina je obvezna'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92',"b'{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.'",b'{0} ima trenutno {1} oceno dobavitelja in naro\xc4\x8dila temu dobavitelju je treba izdajati s previdnostjo'
+b'DocType: Asset Maintenance Team',b'Asset Maintenance Team',b'Ekipa za vzdr\xc5\xbeevanje sredstev'
+b'DocType: Employee Loan',b'Loan Type',b'posojilo Vrsta'
+b'DocType: Scheduling Tool',b'Scheduling Tool',b'razporejanje orodje'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180',b'Credit Card',b'Credit Card'
+b'DocType: BOM',b'Item to be manufactured or repacked',"b'Postavka, ki se proizvaja ali prepakirana'"
+b'DocType: Employee Education',b'Major/Optional Subjects',b'Major / Izbirni predmeti'
+b'DocType: Sales Invoice Item',b'Drop Ship',b'Drop Ship'
+b'DocType: Driver',b'Suspended',b'Suspendirano'
+b'DocType: Training Event',b'Attendees',b'udele\xc5\xbeenci'
+b'DocType: Employee',"b'Here you can maintain family details like name and occupation of parent, spouse and children'","b'Tukaj lahko hranite dru\xc5\xbeinske podrobnosti, kot so ime in poklic star\xc5\xa1ev, zakonca in otrok'"
+b'DocType: Academic Term',b'Term End Date',b'Izraz Kon\xc4\x8dni datum'
+b'DocType: Purchase Invoice',b'Taxes and Charges Deducted (Company Currency)',b'Davki in dajatve Odbitek (dru\xc5\xbeba Valuta)'
+b'DocType: Item Group',b'General Settings',b'Splo\xc5\xa1ne nastavitve'
+b'apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23',b'From Currency and To Currency cannot be same',b'Od denarja in denarja ne more biti enaka'
+b'DocType: Stock Entry',b'Repack',b'Zapakirajte'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6',b'You must Save the form before proceeding',"b'Morate Shranite obrazec, preden nadaljujete'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113',b'Please select the Company first',b'Najprej izberite podjetje'
+b'DocType: Item Attribute',b'Numeric Values',b'Numeri\xc4\x8dne vrednosti'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +56',b'Attach Logo',b'Prilo\xc5\xbeite Logo'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +51',b'Stock Levels',b'Zaloga Ravni'
+b'DocType: Customer',b'Commission Rate',b'Komisija Rate'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187',b'Created {0} scorecards for {1} between: ',b'Ustvarjene {0} kazalnike za {1} med:'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +505',b'Make Variant',b'Naredite Variant'
+b'apps/erpnext/erpnext/config/hr.py +87',b'Block leave applications by department.',b'Aplikacije blok dopustu oddelka.'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +155',"b'Payment Type must be one of Receive, Pay and Internal Transfer'","b'Pla\xc4\x8dilo Tip mora biti eden od Prejemanje, pla\xc4\x8dati in notranji prenos'"
+b'apps/erpnext/erpnext/config/selling.py +184',b'Analytics',b'Analytics'
+b'apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25',b'Cart is Empty',b'Ko\xc5\xa1arica je Prazna'
+b'DocType: Vehicle',b'Model',b'Model'
+b'DocType: Work Order',b'Actual Operating Cost',b'Dejanski operacijski stro\xc5\xa1kov'
+b'DocType: Payment Entry',b'Cheque/Reference No',b'\xc4\x8cek / referen\xc4\x8dna \xc5\xa1tevilka'
+b'DocType: Soil Texture',b'Clay Loam',b'Clay Loam'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +81',b'Root cannot be edited.',b'Root ni mogo\xc4\x8de urejati.'
+b'DocType: Item',b'Units of Measure',b'Merske enote'
+b'DocType: Manufacturing Settings',b'Allow Production on Holidays',b'Dovoli Proizvodnja na po\xc4\x8ditnicah'
+b'DocType: Sales Invoice',"b""Customer's Purchase Order Date""",b'Stranke Naro\xc4\x8dilo Datum'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163',b'Capital Stock',b'Osnovni kapital'
+b'DocType: Shopping Cart Settings',b'Show Public Attachments',b'Prika\xc5\xbei Javna Priklju\xc4\x8dki'
+b'DocType: Packing Slip',b'Package Weight Details',b'Paket Te\xc5\xbea Podrobnosti'
+b'DocType: Restaurant Reservation',b'Reservation Time',b'\xc4\x8cas rezervacije'
+b'DocType: Payment Gateway Account',b'Payment Gateway Account',b'Pla\xc4\x8dilo Gateway ra\xc4\x8dun'
+b'DocType: Shopping Cart Settings',b'After payment completion redirect user to selected page.',b'Po zaklju\xc4\x8dku pla\xc4\x8dila preusmeri uporabnika na izbrano stran.'
+b'DocType: Company',b'Existing Company',b'obstoje\xc4\x8da podjetja'
+b'DocType: Healthcare Settings',b'Result Emailed',b'Rezultati so poslani'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +87',"b'Tax Category has been changed to ""Total"" because all the Items are non-stock items'","b'Dav\xc4\x8dna kategorija se je spremenila v &quot;Skupaj&quot;, ker so vsi artikli, ki niso zalogi'"
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103',b'Please select a csv file',b'Izberite csv datoteko'
+b'DocType: Student Leave Application',b'Mark as Present',b'Ozna\xc4\x8di kot Present'
+b'DocType: Supplier Scorecard',b'Indicator Color',b'Barva indikatorja'
+b'DocType: Purchase Order',b'To Receive and Bill',b'Za prejemanje in Bill'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +445',b'Row #{0}: Reqd by Date cannot be before Transaction Date',b'Vrstica # {0}: Reqd po datumu ne more biti pred datumom transakcije'
+b'apps/erpnext/erpnext/templates/pages/home.html +14',b'Featured Products',b'Izbrani izdelki'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136',b'Designer',b'Oblikovalec'
+b'apps/erpnext/erpnext/config/selling.py +163',b'Terms and Conditions Template',b'Pogoji Template'
+b'DocType: Serial No',b'Delivery Details',b'Dostava Podrobnosti'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +495',b'Cost Center is required in row {0} in Taxes table for type {1}',"b'Stro\xc5\xa1kov Center, je potrebno v vrstici {0} v Davki miza za tip {1}'"
+b'DocType: Program',b'Program Code',b'Program Code'
+b'DocType: Terms and Conditions',b'Terms and Conditions Help',b'Pogoji Pomo\xc4\x8d'
+,b'Item-wise Purchase Register',b'Element-pametno Nakup Registriraj se'
+b'DocType: Driver',b'Expiry Date',b'Rok uporabnosti'
+b'DocType: Healthcare Settings',b'Employee name and designation in print',b'Ime in oznaka zaposlenega v tiskani obliki'
+,b'accounts-browser',b'ra\xc4\x8duni brskalnik'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368',b'Please select Category first',"b'Prosimo, izberite kategorijo najprej'"
+b'apps/erpnext/erpnext/config/projects.py +13',b'Project master.',b'Master projekt.'
+b'apps/erpnext/erpnext/controllers/status_updater.py +212',"b'To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.'","b'\xc4\x8ce \xc5\xbeelite, da pretirano zara\xc4\x8dunavanje ali over-naro\xc4\x8danje, posodobi &quot;dodatku&quot; v delni\xc5\xa1kih nastavitvah ali to\xc4\x8dko.'"
+b'DocType: Global Defaults',b'Do not show any symbol like $ etc next to currencies.',"b'Ne ka\xc5\xbeejo vsak simbol, kot $ itd zraven valute.'"
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +431',b' (Half Day)',b'(Poldnevni)'
+b'DocType: Payment Term',b'Credit Days',b'Kreditne dnevi'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +145',b'Please select Patient to get Lab Tests',"b'Prosimo, izberite Patient, da dobite laboratorijske teste'"
+b'apps/erpnext/erpnext/utilities/activation.py +128',b'Make Student Batch',b'Naj Student Batch'
+b'DocType: Fee Schedule',b'FRQ.',b'FRQ.'
+b'DocType: Leave Type',b'Is Carry Forward',b'Se Carry Forward'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +841',b'Get Items from BOM',b'Pridobi artikle iz BOM'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40',b'Lead Time Days',b'Dobavni rok dni'
+b'DocType: Cash Flow Mapping',b'Is Income Tax Expense',b'Ali je prihodek od davka na dohodek'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +621',b'Row #{0}: Posting Date must be same as purchase date {1} of asset {2}',b'Row # {0}: Napotitev Datum mora biti enak datumu nakupa {1} od sredstva {2}'
+b'DocType: Program Enrollment',"b""Check this if the Student is residing at the Institute's Hostel.""","b'Ozna\xc4\x8dite to, \xc4\x8de je \xc5\xa1tudent s stalnim prebivali\xc5\xa1\xc4\x8dem v Hostel in\xc5\xa1tituta.'"
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125',b'Please enter Sales Orders in the above table',b'Vnesite Prodajne nalogov v zgornji tabeli'
+,b'Stock Summary',b'Stock Povzetek'
+b'apps/erpnext/erpnext/config/assets.py +54',b'Transfer an asset from one warehouse to another',b'Prenese sredstva iz enega skladi\xc5\xa1\xc4\x8da v drugo'
+b'DocType: Vehicle',b'Petrol',b'Petrol'
+b'apps/erpnext/erpnext/config/learn.py +217',b'Bill of Materials',b'Kosovnica'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105',b'Row {0}: Party Type and Party is required for Receivable / Payable account {1}',b'Vrstica {0}: Vrsta stranka in stranka je potrebna za terjatve / obveznosti ra\xc4\x8dun {1}'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94',b'Ref Date',b'Ref Datum'
+b'DocType: Employee',b'Reason for Leaving',b'Razlog za odhod'
+b'DocType: BOM Operation',b'Operating Cost(Company Currency)',b'Obratovalni stro\xc5\xa1ki (dru\xc5\xbeba Valuta)'
+b'DocType: Employee Loan Application',b'Rate of Interest',b'Obrestna mera'
+b'DocType: Expense Claim Detail',b'Sanctioned Amount',b'Sankcionirano Znesek'
+b'DocType: Item',b'Shelf Life In Days',b'Rok uporabe v dnevih'
+b'DocType: GL Entry',b'Is Opening',b'Je Odpiranje'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196',b'Row {0}: Debit entry can not be linked with a {1}',b'Vrstica {0}: debetna vnos ne more biti povezano z {1}'
+b'DocType: Journal Entry',b'Subscription Section',b'Naro\xc4\x8dni\xc5\xa1ka sekcija'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +177',b'Account {0} does not exist',b'Ra\xc4\x8dun {0} ne obstaja'
+b'DocType: Training Event',b'Training Program',b'Program usposabljanja'
+b'DocType: Account',b'Cash',b'Gotovina'
+b'DocType: Employee',b'Short biography for website and other publications.',b'Kratka biografija za spletne strani in drugih publikacij.'
