DocType: Accounting Period,Period Name,Ime obdobja
DocType: Employee,Salary Mode,Način plače
apps/erpnext/erpnext/public/js/hub/marketplace.js,Register,Registriraj se
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Received,Delno prejeto
DocType: Patient,Divorced,Ločen
DocType: Support Settings,Post Route Key,Ključ objave posta
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Dovoli da se artikel večkrat  doda v transakciji.
DocType: Content Question,Content Question,Vsebinsko vprašanje
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Cancel Material Visit {0} before cancelling this Warranty Claim,Opusti Material obisk {0} pred preklicem te garancije
DocType: Customer Feedback Table,Qualitative Feedback,Kakovostne povratne informacije
apps/erpnext/erpnext/config/education.py,Assessment Reports,Poročila o oceni
DocType: Invoice Discounting,Accounts Receivable Discounted Account,Račun s terjatvami s popustom
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting_list.js,Canceled,Prekinjeno
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consumer Products,Consumer Products
DocType: Supplier Scorecard,Notify Supplier,Obvesti dobavitelja
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.js,Please select Party Type first,Izberite Party Vrsta najprej
DocType: Item,Customer Items,Artikli stranke
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Liabilities,Obveznosti
DocType: Project,Costing and Billing,Obračunavanje stroškov in plačevanja
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Advance account currency should be same as company currency {0},Predplačilna valuta mora biti enaka valuti podjetja {0}
DocType: QuickBooks Migrator,Token Endpoint,Končna točka žetona
apps/erpnext/erpnext/accounts/doctype/account/account.py,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/hr/doctype/leave_application/leave_application.py,Cannot find active Leave Period,Aktivnega obdobja puščanja ni mogoče najti
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Evaluation,vrednotenje
DocType: Item,Default Unit of Measure,Privzeto mersko enoto
DocType: SMS Center,All Sales Partner Contact,Vse Sales Partner Kontakt
DocType: Department,Leave Approvers,Pustite Approvers
DocType: Employee,Bio / Cover Letter,Bio / Cover Letter
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Search Items ...,Elementi iskanja ...
DocType: Patient Encounter,Investigations,Preiskave
DocType: Restaurant Order Entry,Click Enter To Add,Kliknite Enter za dodajanje
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py,"Missing value for Password, API Key or Shopify URL","Manjka vrednost za geslo, ključ API ali URL prodajanja"
DocType: Employee,Rented,Najemu
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,All Accounts,Vsi računi
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Cannot transfer Employee with status Left,Uslužbenca ni mogoče prenesti s statusom Levo
DocType: Vehicle Service,Mileage,Kilometrina
apps/erpnext/erpnext/assets/doctype/asset/asset.js,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,Select Default Supplier,Izberite Privzeta Dobavitelj
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Show Employee,Prikaži zaposlenega
DocType: Payroll Period,Standard Tax Exemption Amount,Standardni znesek oprostitve davka
DocType: Exchange Rate Revaluation Account,New Exchange Rate,Nov tečaj
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,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: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-YYYY-
DocType: Purchase Order,Customer Contact,Stranka Kontakt
DocType: Shift Type,Enable Auto Attendance,Omogoči samodejno udeležbo
apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Vnesite skladišče in datum
DocType: Lost Reason Detail,Opportunity Lost Reason,Priložnost izgubljen razlog
DocType: Patient Appointment,Check availability,Preveri razpoložljivost
DocType: Retention Bonus,Bonus Payment Date,Datum plačila bonusa
DocType: Employee,Job Applicant,Job Predlagatelj
DocType: Job Card,Total Time in Mins,Skupni čas v min
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py,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
DocType: Manufacturing Settings,Overproduction Percentage For Work Order,Odstotek prekomerne proizvodnje za delovni red
DocType: Landed Cost Voucher,MAT-LCV-.YYYY.-,MAT-LCV-.YYYY.-
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Legal,Pravna
DocType: Sales Invoice,Transport Receipt Date,Datum prejema transporta
DocType: Shopify Settings,Sales Order Series,Serija prodajnih naročil
DocType: Vital Signs,Tongue,Jezik
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,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: Allowed To Transact With,Allowed To Transact With,Dovoljeno transakcijo z
DocType: Bank Guarantee,Customer,Stranka
DocType: Purchase Receipt Item,Required By,Zahtevani Z
DocType: Delivery Note,Return Against Delivery Note,Vrni Proti dobavnica
DocType: Asset Category,Finance Book Detail,Finance Book Detail
apps/erpnext/erpnext/assets/doctype/asset/asset.py,All the depreciations has been booked,Vse amortizacije so bile knjižene
DocType: Purchase Order,% Billed,% zaračunano
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Payroll Number,Številka plače
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Exchange Rate must be same as {0} {1} ({2}),Menjalni tečaj mora biti enaka kot {0} {1} ({2})
DocType: Employee Tax Exemption Declaration,HRA Exemption,Oprostitev HRA
DocType: Sales Invoice,Customer Name,Ime stranke
DocType: Vehicle,Natural Gas,Zemeljski plin
DocType: Project,Message will sent to users to get their status on the project,"Uporabnikom bo poslano sporočilo, da dobijo status v projektu"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Bank account cannot be named as {0},Bančni račun ne more biti imenovan kot {0}
DocType: Employee Tax Exemption Declaration,HRA as per Salary Structure,HRA po plačni strukturi
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,Outstanding for {0} cannot be less than zero ({1}),Izjemna za {0} ne more biti manjša od nič ({1})
apps/erpnext/erpnext/public/js/controllers/transaction.js,Service Stop Date cannot be before Service Start Date,Datum zaustavitve storitve ne sme biti pred datumom začetka storitve
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,Show open,Prikaži odprte
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Series Updated Successfully,Zaporedje uspešno posodobljeno
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html,Checkout,Naročilo
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} in row {1},{0} v vrstici {1}
DocType: Asset Finance Book,Depreciation Start Date,Začetni datum amortizacije
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/accounts/doctype/account/account.py,Account {0} is added in the child company {1},Račun {0} je dodan v otroškem podjetju {1}
apps/erpnext/erpnext/erpnext_integrations/doctype/exotel_settings/exotel_settings.py,Invalid credentials,Neveljavne poverilnice
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Available (whether in full op part),ITC Na voljo (v celoti v delu)
DocType: Amazon MWS Settings,Amazon MWS Settings,Amazonske nastavitve MWS
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Vouchers,Obdelava bonov
apps/erpnext/erpnext/utilities/transaction_base.py,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Vrstica # {0}: Stopnja mora biti enaka kot {1}: {2} ({3} / {4})
,Batch Item Expiry Status,Serija Točka preteka Status
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Bank Draft,Bank Osnutek
DocType: Journal Entry,ACC-JV-.YYYY.-,ACC-JV-.YYYY.-
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Late Entries,Skupni pozni vpisi
DocType: Mode of Payment Account,Mode of Payment Account,Način plačilnega računa
apps/erpnext/erpnext/config/healthcare.py,Consultation,Posvetovanje
DocType: Accounts Settings,Show Payment Schedule in Print,Prikaži čas plačila v tisku
apps/erpnext/erpnext/stock/doctype/item/item.py,Item Variants updated,Različice izdelkov so posodobljene
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py,Sales and Returns,Prodaja in vrnitev
apps/erpnext/erpnext/stock/doctype/item/item.js,Show Variants,Prikaži Variante
DocType: Academic Term,Academic Term,Academic Term
DocType: Employee Tax Exemption Sub Category,Employee Tax Exemption Sub Category,Podrazdelek za davčne oprostitve za zaposlene
apps/erpnext/erpnext/regional/italy/utils.py,Please set an Address on the Company '%s',"Prosimo, nastavite naslov v podjetju &#39;% s&#39;"
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py,Material,Material
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of benefit application pro-rata component\
			amount and previous claimed amount",Najvišja korist zaposlenega {0} presega {1} za vsoto {2} komponent pro-rata komponente \ ugodnosti in predhodnega zahtevanega zneska
DocType: Opening Invoice Creation Tool Item,Quantity,Količina
,Customers Without Any Sales Transactions,Stranke brez prodajnih transakcij
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Accounts table cannot be blank.,Predstavlja tabela ne more biti prazno.
DocType: Delivery Trip,Use Google Maps Direction API to calculate estimated arrival times,Uporabite API za usmerjanje Google Maps za izračun predvidenih časov prihoda
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Loans (Liabilities),Posojili (obveznosti)
DocType: Patient Encounter,Encounter Time,Čas srečanja
DocType: Staffing Plan Detail,Total Estimated Cost,Skupni predvideni stroški
DocType: Employee Education,Year of Passing,"Leto, ki poteka"
DocType: Routing,Routing Name,Ime poti
DocType: Item,Country of Origin,Država izvora
DocType: Soil Texture,Soil Texture Criteria,Kriteriji za teksturo tal
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,In Stock,Na zalogi
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js,Primary Contact Details,Primarni kontaktni podatki
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Issues,odprta vprašanja
DocType: Production Plan Item,Production Plan Item,Proizvodni načrt Postavka
DocType: Leave Ledger Entry,Leave Ledger Entry,Pustite vpis v knjigo
apps/erpnext/erpnext/hr/doctype/employee/employee.py,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/utilities/activation.py,Create Lead,Ustvari potencial
DocType: Production Plan,Projected Qty Formula,Projektirana številka formule
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Health Care,Zdravstvo
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,Delay in payment (Days),Zamuda pri plačilu (dnevi)
DocType: Payment Terms Template Detail,Payment Terms Template Detail,Podrobnosti o predlogi za plačila
DocType: Hotel Room Reservation,Guest Name,Ime gosta
DocType: Delivery Note,Issue Credit Note,Izdajte kreditno obvestilo
DocType: Lab Prescription,Lab Prescription,Laboratorijski recept
,Delay Days,Dnevi zamude
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,Service Expense,Service Expense
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Serial Number: {0} is already referenced in Sales Invoice: {1},Serijska številka: {0} že naveden v prodajne fakture: {1}
DocType: Bank Statement Transaction Invoice Item,Invoice,Račun
DocType: Employee Tax Exemption Declaration Category,Maximum Exempted Amount,Najvišja oproščena količina
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,Fiscal Year {0} is required,Poslovno leto {0} je potrebno
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py,Net Profit/Loss,Čisti dobiček / izguba
DocType: Employee Group Table,ERPNext User ID,ID uporabnika ERPNext
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/healthcare/doctype/patient_appointment/patient_appointment.js,Please select Patient to get prescribed procedure,"Prosimo, izberite Pacient, da dobite predpisan postopek"
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Defense,Obramba
DocType: Salary Component,Abbr,Abbr
DocType: Appraisal Goal,Score (0-5),Ocena (0-5)
DocType: Tally Migration,Tally Creditors Account,Račun upnikov Tally
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,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,Row # {0}:,Vrstica # {0}:
DocType: Timesheet,Total Costing Amount,Skupaj Stanejo Znesek
DocType: Sales Invoice,Vehicle No,Nobeno vozilo
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select Price List,Izberite Cenik
DocType: Accounts Settings,Currency Exchange Settings,Nastavitve menjave valut
DocType: Work Order Operation,Work In Progress,Delo v teku
DocType: Leave Control Panel,Branch (optional),Podružnica (neobvezno)
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,Row {0}: user has not applied rule <b>{1}</b> on the item <b>{2}</b>,Vrstica {0}: uporabnik ni uporabil pravila <b>{1}</b> za element <b>{2}</b>
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Please select date,Izberite datum
DocType: Item Price,Minimum Qty ,Najmanjša količina
DocType: Finance Book,Finance Book,Finance knjiga
DocType: Patient Encounter,HLC-ENC-.YYYY.-,HLC-ENC-.GGGG.-
DocType: Daily Work Summary Group,Holiday List,Seznam praznikov
apps/erpnext/erpnext/config/quality_management.py,Review and Action,Pregled in ukrepanje
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,This employee already has a log with the same timestamp.{0},Ta zaposleni že ima dnevnik z istim časovnim žigom. {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Accountant,Računovodja
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Selling Price List,Prodajni cenik
DocType: Patient,Tobacco Current Use,Trenutna uporaba tobaka
apps/erpnext/erpnext/selling/report/customer_wise_item_price/customer_wise_item_price.py,Selling Rate,Prodajna cena
DocType: Cost Center,Stock User,Stock Uporabnik
DocType: Soil Analysis,(Ca+Mg)/K,(Ca+Mg)/K
DocType: Delivery Stop,Contact Information,Kontaktni podatki
apps/erpnext/erpnext/public/js/hub/pages/Search.vue,Search for anything ...,Poiščite karkoli ...
DocType: Company,Phone No,Telefon
DocType: Delivery Trip,Initial Email Notification Sent,Poslano je poslano obvestilo o e-pošti
DocType: Bank Statement Settings,Statement Header Mapping,Kartiranje glave izjave
,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,Abbreviation cannot have more than 5 characters,Kratica ne more imeti več kot 5 znakov
DocType: Amazon MWS Settings,AU,AU
DocType: Payment Order,Payment Request,Plačilni Nalog
apps/erpnext/erpnext/config/retail.py,To view logs of Loyalty Points assigned to a Customer.,"Če si želite ogledati dnevnike točk zvestobe, dodeljenih naročniku."
DocType: Asset,Value After Depreciation,Vrednost po amortizaciji
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Did not found transfered item {0} in Work Order {1}, the item not added in Stock Entry","Ni bilo prenesenega izdelka {0} v delovnem naročilu {1}, izdelek ni bil dodan v zalogi"
DocType: Student,O+,O +
apps/erpnext/erpnext/stock/doctype/material_request/material_request_dashboard.py,Related,Podobni
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,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: Employee Training,Training Date,Datum usposabljanja
apps/erpnext/erpnext/public/js/hub/marketplace.js,Add Users to Marketplace,Dodaj uporabnike v Marketplace
apps/erpnext/erpnext/accounts/doctype/account/account.js,This is a root account and cannot be edited.,To je račun root in jih ni mogoče urejati.
DocType: POS Profile,Company Address,Naslov podjetja
DocType: BOM,Operations,Operacije
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Cannot set authorization on basis of Discount for {0},Ni mogoče nastaviti dovoljenja na podlagi popust za {0}
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill JSON cannot be generated for Sales Return as of now,Računa za e-način JSON od zdaj ni mogoče ustvariti za vračilo prodaje
DocType: Subscription,Subscription Start Date,Začetni datum naročnine
DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Appointment charges.,"Neplačani računi za terjatve, ki jih je treba uporabiti, če niso nastavljeni v Patientu za knjiženje Imenovanje."
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/regional/report/eway_bill/eway_bill.py,From Address 2,Od naslova 2
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_proof_submission/employee_tax_exemption_proof_submission.js,Get Details From Declaration,Preberite podrobnosti iz izjave
apps/erpnext/erpnext/accounts/utils.py,{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,"Reference: {0}, Item Code: {1} and Customer: {2}",Referenca: {0} Oznaka: {1} in stranke: {2}
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py,{0} {1} is not present in the parent company,{0} {1} ni v matični družbi
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Trial Period End Date Cannot be before Trial Period Start Date,Datum konca poskusnega obdobja ne more biti pred začetkom začetnega poskusnega obdobja
apps/erpnext/erpnext/utilities/user_progress.py,Kg,Kg
DocType: Tax Withholding Category,Tax Withholding Category,Kategorija pobiranja davkov
apps/erpnext/erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py,Cancel the journal entry {0} first,Najprej prekličite vnos v dnevnik {0}
DocType: Purchase Invoice,ACC-PINV-.YYYY.-,ACC-PINV-.LLLL.-
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,BOM is not specified for subcontracting item {0} at row {1},BOM ni določen za podizvajalsko postavko {0} v vrstici {1}
DocType: Vital Signs,Reflexes,Refleksi
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,{0} Result submittted,{0} vloženo
DocType: Item Attribute,Increment,Prirastek
apps/erpnext/erpnext/templates/pages/search_help.py,Help Results for,Pomoč za
apps/erpnext/erpnext/public/js/stock_analytics.js,Select Warehouse...,Izberite Skladišče ...
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Advertising,Oglaševanje
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py,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,Not permitted for {0},Ni dovoljeno za {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get items from,Pridobi artikle iz
DocType: Stock Entry,Send to Subcontractor,Pošlji podizvajalcu
DocType: Purchase Invoice,Apply Tax Withholding Amount,Znesek davčnega odbitka
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Total completed qty can not be greater than for quantity,Skupno dokončana količina ne more biti večja od količine
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Stock cannot be updated against Delivery Note {0},Stock ni mogoče posodobiti proti dobavnica {0}
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Total Amount Credited,Skupni znesek kredita
apps/erpnext/erpnext/templates/generators/item_group.html,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,Grocery,Trgovina z živili
DocType: Quality Inspection Reading,Reading 1,Branje 1
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Pension Funds,Pokojninski skladi
DocType: Exchange Rate Revaluation Account,Gain/Loss,Dobiček / izguba
DocType: Crop,Perennial,Trajen
DocType: Program,Is Published,Je objavljeno
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Delivery Notes,Pokaži dobavnice
apps/erpnext/erpnext/controllers/status_updater.py,"To allow over billing, update ""Over Billing Allowance"" in Accounts Settings or the Item.","Če želite omogočiti preveč zaračunavanja, posodobite »Nadomestitev za obračunavanje« v nastavitvah računov ali postavke."
DocType: Patient Appointment,Procedure,Postopek
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,Not items found,Ni najdenih predmetov
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Structure Missing,Plača Struktura Missing
DocType: Lead,Person Name,Ime oseba
,Supplier Ledger Summary,Povzetek glavne knjige dobavitelja
DocType: Sales Invoice Item,Sales Invoice Item,Artikel na računu
DocType: Quality Procedure Table,Quality Procedure Table,Tabela s kakovostnimi postopki
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,"e.g. ""Primary School"" or ""University""",npr &quot;Osnovna šola&quot; ali &quot;University&quot;
apps/erpnext/erpnext/config/stock.py,Stock Reports,Poročila o zalogi
DocType: Warehouse,Warehouse Detail,Skladišče Detail
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Last carbon check date cannot be a future date,Zadnji datum preverjanja emisij ogljika ne more biti prihodnji datum
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"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,"""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
,Completed Work Orders,Dokončana delovna naročila
DocType: Support Settings,Forum Posts,Objave foruma
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Naloga je bila vključena v ozadje. Če obstaja kakšna težava pri obdelavi v ozadju, bo sistem dodal komentar o napaki na tej usklajevanju zalog in se vrnil v fazo osnutka."
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",Veljavnost kode kupona se žal ni začela
apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Davčna osnova
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Nimate dovoljenja za dodajanje ali posodobitev vnose pred {0}
DocType: Leave Policy,Leave Policy Details,Pustite podrobnosti pravilnika
DocType: BOM,Item Image (if not slideshow),Postavka Image (če ne slideshow)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order {3}. Please update operation status via Job Card {4}.,Vrstica # {0}: Postopek {1} ni končan za {2} količino končnih izdelkov v delovnem naročilu {3}. Posodobite stanje delovanja s Job Card {4}.
DocType: Work Order Operation,(Hour Rate / 60) * Actual Operation Time,(Urna postavka / 60) * Dejanski  čas operacije
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Vrstica # {0}: 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,Select BOM,Izberite BOM
DocType: SMS Log,SMS Log,SMS Log
DocType: Call Log,Ringing,Zvonjenje
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Delivered Items,Nabavna vrednost dobavljenega predmeta
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py,The holiday on {0} is not between From Date and To Date,"Praznik na {0} ni med Od datuma, do sedaj"
DocType: Inpatient Record,Admission Scheduled,Vstop je načrtovan
DocType: Student Log,Student Log,študent Log
apps/erpnext/erpnext/config/buying.py,Templates of supplier standings.,Predloge dobaviteljevega položaja.
DocType: Lead,Interested,Zanima
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,Opening,Otvoritev
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Program: ,Program:
DocType: Item,Copy From Item Group,Kopiranje iz postavke skupine
DocType: Journal Entry,Opening Entry,Otvoritev Začetek
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Account Pay Only,Račun Pay samo
DocType: Loan,Repay Over Number of Periods,Odplačilo Over število obdobij
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Quantity to Produce can not be less than Zero,Količina za proizvodnjo ne sme biti manjša od ničle
DocType: Stock Entry,Additional Costs,Dodatni stroški
apps/erpnext/erpnext/accounts/doctype/account/account.py,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,No leave record found for employee {0} for {1},Št odsotnost zapisa dalo za delavca {0} za {1}
DocType: Company,Unrealized Exchange Gain/Loss Account,Nerealiziran borzni dobiček / izguba
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter company first,"Prosimo, da najprej vnesete podjetje"
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Please select Company first,"Prosimo, izberite Company najprej"
DocType: Employee Education,Under Graduate,Pod Graduate
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Status Notification in HR Settings.,"Prosimo, nastavite privzeto predlogo za obvestilo o opustitvi statusa v HR nastavitvah."
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/sales_partner_target_variance_based_on_item_group.js,Target On,Ciljna Na
DocType: BOM,Total Cost,Skupni stroški
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.js,Allocation Expired!,Dodelitev je potekla!
DocType: Soil Analysis,Ca/K,Ca / K
DocType: Leave Type,Maximum Carry Forwarded Leaves,Največje dovoljene sprednje liste
DocType: Salary Slip,Employee Loan,zaposlenih Loan
DocType: Additional Salary,HR-ADS-.YY.-.MM.-,HR-ADS-.YY .-. MM.-
DocType: Fee Schedule,Send Payment Request Email,Pošlji e-pošto za plačilni zahtevek
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Item {0} does not exist in the system or has expired,Element {0} ne obstaja v sistemu ali je potekla
DocType: Supplier,Leave blank if the Supplier is blocked indefinitely,"Pustite prazno, če je dobavitelj blokiran za nedoločen čas"
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Real Estate,Nepremičnina
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Statement of Account,Izkaz računa
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Pharmaceuticals,Farmacevtski izdelki
DocType: Purchase Invoice Item,Is Fixed Asset,Je osnovno sredstvo
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Future Payments,Prikažite bodoča plačila
DocType: Patient,HLC-PAT-.YYYY.-,HLC-PAT-.GGGG.-
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,This bank account is already synchronized,Ta bančni račun je že sinhroniziran
DocType: Homepage,Homepage Section,Oddelek za domačo stran
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work Order has been {0},Delovni nalog je bil {0}
DocType: Budget,Applicable on Purchase Order,Velja za nakupno naročilo
DocType: Item,STO-ITEM-.YYYY.-,STO-ITEM-.GGGZ.-
apps/erpnext/erpnext/hr/doctype/hr_settings/hr_settings.py,Password policy for Salary Slips is not set,Pravilnik o geslu za plače ni nastavljen
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate customer group found in the cutomer group table,Dvojnik skupina kupcev so v tabeli cutomer skupine
DocType: Location,Location Name,Ime lokacije
DocType: Quality Procedure Table,Responsible Individual,Odgovorni posameznik
DocType: Naming Series,Prefix,Predpona
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html,Event Location,Lokacija dogodka
apps/erpnext/erpnext/selling/report/customer_wise_item_price/customer_wise_item_price.py,Available Stock,Na zalogi
DocType: Asset Settings,Asset Settings,Nastavitve sredstva
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Potrošni
DocType: Student,B-,B-
DocType: Assessment Result,Grade,razred
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Koda izdelka&gt; Skupina izdelkov&gt; Blagovna znamka
DocType: Restaurant Table,No of Seats,Število sedežev
DocType: Sales Invoice,Overdue and Discounted,Prepozno in znižano
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Klic prekinjen
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/setup/setup_wizard/operations/install_fixtures.py,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,{0} {1} is frozen,{0} {1} je zamrznjeno
apps/erpnext/erpnext/setup/doctype/company/company.py,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_with_account_number.py,Stock Expenses,Zaloga Stroški
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Select Target Warehouse,Izberite Target Skladišče
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Select Target Warehouse,Izberite Target Skladišče
apps/erpnext/erpnext/hr/doctype/employee/employee.js,Please enter Preferred Contact Email,Vnesite Želeni Kontakt Email
DocType: Purchase Invoice Item,Accepted Qty,Sprejeto Količina
DocType: Journal Entry,Contra Entry,Contra Začetek
DocType: Journal Entry Account,Credit in Company Currency,Kredit v valuti podjetja
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,"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,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: Item,Supply Raw Materials for Purchase,Dobava surovine za nakup
DocType: Agriculture Analysis Criteria,Fertilizer,Gnojilo
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
				Item {0} is added with and without Ensure Delivery by \
				Serial No.","Dostava ni mogoče zagotoviti s serijsko številko, ker se \ Item {0} doda z in brez Zagotoviti dostavo z \ Serial No."
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,At least one mode of payment is required for POS invoice.,za POS računa je potreben vsaj en način plačila.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Batch no is required for batched item {0},Za serijsko postavko {0} ni potrebna nobena serija
DocType: Bank Statement Transaction Invoice Item,Bank Statement Transaction Invoice Item,Postavka računa za transakcijo banke
DocType: Salary Detail,Tax on flexible benefit,Davek na prožne koristi
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,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,Example: Basic Mathematics,Primer: Osnovna matematika
DocType: Customer,Primary Address,Primarni naslov
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Diff Qty,Diff Količina
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,"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/quality_management.py,Quality Procedure.,Postopek kakovosti.
DocType: SMS Center,SMS Center,SMS center
DocType: Payroll Entry,Validate Attendance,Potrjevanje prisotnosti
DocType: Sales Invoice,Change Amount,Znesek spremembe
DocType: Party Tax Withholding Config,Certificate Received,Prejeto potrdilo
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/healthcare/doctype/patient_appointment/patient_appointment.js,Prescribed Procedures,Predpisani postopki
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show only POS,Prikaži samo POS
DocType: Supplier Group,Supplier Group Name,Ime skupine izvajalcev
DocType: Driver,Driving License Categories,Kategorije vozniških dovoljenj
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please enter Delivery Date,Vnesite datum dostave
DocType: Depreciation Schedule,Make Depreciation Entry,Naj Amortizacija Začetek
DocType: Closed Document,Closed Document,Zaprti dokument
DocType: HR Settings,Leave Settings,Pustite nastavitve
DocType: Appraisal Template Goal,KRA,KRA
DocType: Lead,Request Type,Zahteva Type
DocType: Purpose of Travel,Purpose of Travel,Namen potovanja
DocType: Payroll Period,Payroll Periods,Obdobja plačevanja
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Broadcasting,Broadcasting
apps/erpnext/erpnext/config/retail.py,Setup mode of POS (Online / Offline),Način nastavitve POS (Online / Offline)
DocType: Manufacturing Settings,Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order,Onemogoči ustvarjanje časovnih dnevnikov z delovnimi nalogi. Operacijam se ne sme slediti delovnemu nalogu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Execution,Izvedba
apps/erpnext/erpnext/config/manufacturing.py,Details of the operations carried out.,Podrobnosti o poslovanju izvajajo.
DocType: Asset Maintenance Log,Maintenance Status,Status vzdrževanje
DocType: Purchase Invoice Item,Item Tax Amount Included in Value,Znesek davka na postavke je vključen v vrednost
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Membership Details,Podrobnosti o članstvu
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Supplier is required against Payable account {2},{0} {1}: zahtevan je Dobavitelj za račun izdatkov {2}
apps/erpnext/erpnext/config/buying.py,Items and Pricing,Predmeti in Cene
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Total hours: {0},Skupno število ur: {0}
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,From Date should be within the Fiscal Year. Assuming From Date = {0},Od datuma mora biti v poslovnem letu. Ob predpostavki Od datuma = {0}
DocType: Patient Medical Record,HLC-PMR-.YYYY.-,HLC-PMR-YYYY.-
DocType: Drug Prescription,Interval,Interval
DocType: Pricing Rule,Promotional Scheme Id,ID promocijske sheme
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Preference,Prednost
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward Supplies(liable to reverse charge,Vhodne potrebščine (lahko obračunajo z obratnim polnjenjem)
DocType: Supplier,Individual,Individualno
DocType: Academic Term,Academics User,akademiki Uporabnik
DocType: Cheque Print Template,Amount In Figure,Znesek v sliki
DocType: Loan Application,Loan Info,posojilo Info
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,All Other ITC,Vsi ostali ITC
apps/erpnext/erpnext/config/crm.py,Plan for maintenance visits.,Načrt za vzdrževanje obiskov.
DocType: Supplier Scorecard Period,Supplier Scorecard Period,Period ocenjevanja dobaviteljev
DocType: Support Settings,Search APIs,API za iskanje
DocType: Share Transfer,Share Transfer,Prenos delnic
,Expiring Memberships,Izguba članstva
apps/erpnext/erpnext/templates/pages/home.html,Read blog,Preberite blog
DocType: POS Profile,Customer Groups,Skupine strank
apps/erpnext/erpnext/public/js/financial_statements.js,Financial Statements,Finančne izjave
DocType: Guardian,Students,študenti
apps/erpnext/erpnext/config/buying.py,Rules for applying pricing and discount.,Pravila za uporabo cene in popust.
DocType: Daily Work Summary,Daily Work Summary Group,Skupina dnevnih del
DocType: Practitioner Schedule,Time Slots,Časovne reže
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py,Price List must be applicable for Buying or Selling,Cenik mora biti primerno za nakup ali prodajo
DocType: Shift Assignment,Shift Request,Zahteva za premik
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Installation date cannot be before delivery date for Item {0},Datum namestitve ne more biti pred datumom dostave za postavko {0}
DocType: Purchase Invoice Item,Discount on Price List Rate (%),Popust na ceno iz cenika Stopnja (%)
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,Item Template,Predloga postavke
DocType: Job Offer,Select Terms and Conditions,Izberite Pogoji
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Out Value,iz Vrednost
DocType: Bank Statement Settings Item,Bank Statement Settings Item,Postavka postavke bančne postavke
DocType: Woocommerce Settings,Woocommerce Settings,Nastavitve Woocommerce
DocType: Leave Ledger Entry,Transaction Name,Ime transakcije
DocType: Production Plan,Sales Orders,Naročila Kupcev
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Multiple Loyalty Program found for the Customer. Please select manually.,Za naročnika je bil najden več program zvestobe. Izberite ročno.
DocType: Purchase Taxes and Charges,Valuation,Vrednotenje
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Set as Default,Nastavi kot privzeto
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Expiry date is mandatory for selected item.,Datum izteka roka uporabnosti je za izbrani artikel obvezen.
,Purchase Order Trends,Naročilnica Trendi
apps/erpnext/erpnext/utilities/user_progress.py,Go to Customers,Pojdi na stranke
DocType: Hotel Room Reservation,Late Checkin,Pozno preverjanje
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Finding linked payments,Iskanje povezanih plačil
apps/erpnext/erpnext/templates/emails/request_for_quotation.html,The request for quotation can be accessed by clicking on the following link,Zahteva za ponudbo lahko dostopate s klikom na spodnjo povezavo
DocType: Quiz Result,Selected Option,Izbrana možnost
DocType: SG Creation Tool Course,SG Creation Tool Course,SG ustvarjanja orodje za golf
DocType: Bank Statement Transaction Invoice Item,Payment Description,Opis plačila
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Insufficient Stock,Nezadostna zaloga
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 Account,Bank Account,Bančni račun
DocType: Travel Itinerary,Check-out Date,Datum odhoda
DocType: Leave Type,Allow Negative Balance,Dovoli negativni saldo
apps/erpnext/erpnext/projects/doctype/project_type/project_type.py,You cannot delete Project Type 'External',Ne morete izbrisati vrste projekta &quot;Zunanji&quot;
apps/erpnext/erpnext/public/js/utils.js,Select Alternate Item,Izberite nadomestni element
DocType: Employee,Create User,Ustvari uporabnika
DocType: Selling Settings,Default Territory,Privzeto Territory
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Television,Televizija
DocType: Work Order Operation,Updated via 'Time Log',Posodobljeno preko &quot;Čas Logu&quot;
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Select the customer or supplier.,Izberite kupca ali dobavitelja.
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Select only one Priority as Default.,Za privzeto izberite samo eno prednostno nalogo.
apps/erpnext/erpnext/controllers/taxes_and_totals.py,Advance amount cannot be greater than {0} {1},Advance znesek ne sme biti večja od {0} {1}
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Časovna reža je preskočena, reža {0} do {1} prekriva obstoječo režo {2} do {3}"
DocType: Naming Series,Series List for this Transaction,Seznam zaporedij za to transakcijo
DocType: Company,Enable Perpetual Inventory,Omogoči nepretrganega popisovanja
DocType: Bank Guarantee,Charges Incurred,"Stroški, nastali"
apps/erpnext/erpnext/public/js/education/lms/quiz.js,Something went wrong while evaluating the quiz.,Pri ocenjevanju kviza je šlo nekaj narobe.
DocType: Company,Default Payroll Payable Account,Privzeto Plače plačljivo račun
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Edit Details,Uredite podrobnosti
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Update Email Group,Posodobitev e-Group
DocType: POS Profile,Only show Customer of these Customer Groups,Pokaži samo kupcem teh skupin kupcev
DocType: Sales Invoice,Is Opening Entry,Je vstopna odprtina
apps/erpnext/erpnext/public/js/conf.js,Documentation,Dokumentacija
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: Company,Arrear Component,Arrear Component
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.py,Stock Entry has been already created against this Pick List,Vpis zalog je že ustvarjen na tem seznamu izbir
DocType: Supplier Scorecard,Criteria Setup,Nastavitev meril
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,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,Received On,Prejetih Na
DocType: Codification Table,Medical Code,Zdravstvena koda
apps/erpnext/erpnext/config/integrations.py,Connect Amazon with ERPNext,Povežite Amazon z ERPNext
apps/erpnext/erpnext/templates/generators/item/item_configure.html,Contact Us,Kontaktiraj nas
DocType: Delivery Note Item,Against Sales Invoice Item,Proti Sales računa Postavka
DocType: Agriculture Analysis Criteria,Linked Doctype,Povezani Doctype
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Financing,Neto denarni tokovi pri financiranju
apps/erpnext/erpnext/accounts/page/pos/pos.js,"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: Party Tax Withholding Config,Party Tax Withholding Config,Config davka pri odtegovanju stranke
DocType: Lab Test,Custom Result,Rezultat po meri
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.js,Bank accounts added,Dodani so bančni računi
DocType: Call Log,Contact Name,Kontaktno ime
DocType: Plaid Settings,Synchronize all accounts every hour,Vsako uro sinhronizirajte vse račune
DocType: Course Assessment Criteria,Course Assessment Criteria,Merila ocenjevanja tečaj
DocType: Pricing Rule Detail,Rule Applied,Uporabljeno pravilo
DocType: Service Level Priority,Resolution Time Period,Čas ločljivosti
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Tax Id: ,Davčna številka:
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student ID: ,Študentski ID:
DocType: POS Customer Group,POS Customer Group,POS Group stranke
DocType: Healthcare Practitioner,Practitioner Schedules,Urniki zdravnikov
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,No description given,Opis ni dana
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Pridobivanje izdelkov iz skladišča
apps/erpnext/erpnext/config/buying.py,Request for purchase.,Zaprosi za nakup.
DocType: POS Closing Voucher Details,Collected Amount,Zbrani znesek
DocType: Lab Test,Submitted Date,Datum predložitve
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Company field is required,Polje podjetja je obvezno
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py,This is based on the Time Sheets created against this project,Ta temelji na časovnih preglednicah ustvarjenih pred tem projektu
DocType: Call Log,Recording URL,Snemalni URL
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,Start Date cannot be before the current date,Datum začetka ne sme biti pred trenutnim datumom
,Open Work Orders,Odpiranje delovnih nalogov
DocType: Healthcare Practitioner,Out Patient Consulting Charge Item,Out Patient Consulting Charge Item
DocType: Payment Term,Credit Months,Kreditni meseci
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Net Pay cannot be less than 0,Neto plača ne sme biti manjši od 0
DocType: Contract,Fulfilled,Izpolnjeno
DocType: Inpatient Record,Discharge Scheduled,Razrešnica načrtovana
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Relieving Date must be greater than Date of Joining,Lajšanje Datum mora biti večja od Datum pridružitve
DocType: POS Closing Voucher,Cashier,Blagajnik
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Leaves per Year,Listi na leto
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Vrstica {0}: Prosimo, preverite &quot;Je Advance&quot; proti račun {1}, če je to predujem vnos."
apps/erpnext/erpnext/stock/utils.py,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,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,Please setup Students under Student Groups,"Prosimo, nastavite Študente v študentskih skupinah"
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Complete Job,Izpolnite Job
DocType: Item Website Specification,Item Website Specification,Element Spletna stran Specifikacija
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave Blocked,Pustite blokiranih
apps/erpnext/erpnext/stock/doctype/item/item.py,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,Bank Entries,bančni vnosi
DocType: Customer,Is Internal Customer,Je notranja stranka
DocType: Crop,Annual,Letno
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)","Če se preveri samodejni izklop, bodo stranke samodejno povezane z zadevnim programom zvestobe (pri prihranku)"
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Stock Sprava Postavka
DocType: Stock Entry,Sales Invoice No,Prodaja Račun Ne
DocType: Website Filter Field,Website Filter Field,Polje filtra spletnega mesta
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Supply Type,Vrsta dobave
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,People who teach at your organisation,"Ljudje, ki poučujejo v vaši organizaciji"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Software Developer,Razvijalec programske opreme
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Create Sample Retention Stock Entry,Ustvari vnos zalog za vzorčenje
DocType: Item,Minimum Order Qty,Najmanjše naročilo Kol
DocType: Supplier,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
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is cancelled,Postavka {0} je odpovedan
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Depreciation Start Date is entered as past date,Amortizacijski vrstici {0}: začetni datum amortizacije se vnese kot pretekli datum
DocType: Contract Template,Fulfilment Terms and Conditions,Izpolnjevanje pogojev
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material Request,Zahteva za material
DocType: Bank Reconciliation,Update Clearance Date,Posodobitev Potrditev Datum
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,Bundle Qty,Število kosov
,GSTR-2,GSTR-2
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},"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: Quiz Result,Correct,Pravilno
DocType: Student Guardian,Mother,mati
DocType: Restaurant Reservation,Reservation End Time,Končni čas rezervacije
DocType: Crop,Biennial,Bienale
,BOM Variance Report,Poročilo o varstvu BOM
apps/erpnext/erpnext/config/selling.py,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,Payment request {0} created,Zahtevek za plačilo {0} je bil ustvarjen
DocType: Inpatient Record,Admitted Datetime,Sprejeto Datetime
DocType: Work Order,Backflush raw materials from work-in-progress warehouse,"Backflush surovine iz skladišča, ki dela v teku"
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Open Orders,Odprta naročila
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Unable to find Salary Component {0},Ni mogoče najti komponente plače {0}
apps/erpnext/erpnext/healthcare/setup.py,Low Sensitivity,Nizka občutljivost
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_log/shopify_log.js,Order rescheduled for sync,Naročilo je prestavljeno za sinhronizacijo
apps/erpnext/erpnext/templates/emails/training_event.html,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: Plaid Settings,Plaid Public Key,Plaid javni ključ
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,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}
apps/erpnext/erpnext/patches/v11_0/add_healthcare_service_unit_tree_root.py,All Healthcare Service Units,Vse enote zdravstvenega varstva
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Converting Opportunity,O pretvorbi priložnosti
DocType: Bank Account,Address HTML,Naslov HTML
DocType: Lead,Mobile No.,Mobilni No.
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html,Mode of Payments,Način plačila
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,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,Latest,Zadnje
DocType: Asset Maintenance Task,2 Yearly,pred 2 letoma
DocType: Education Settings,Education Settings,Nastavitve izobraževanja
DocType: Vehicle Service,Inspection,Pregled
apps/erpnext/erpnext/regional/italy/utils.py,E-Invoicing Information Missing,Podatki o e-računu manjkajo
DocType: Leave Allocation,HR-LAL-.YYYY.-,HR-LAL-YYYY-
DocType: Exchange Rate Revaluation Account,Balance In Base Currency,Stanje v osnovni valuti
DocType: Supplier Scorecard Scoring Standing,Max Grade,Max razred
DocType: Email Digest,New Quotations,Nove ponudbe
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as {1} on leave.,Udeležba ni potrjena {0} kot {1} na dopustu.
DocType: Journal Entry,Payment Order,Plačilni nalog
DocType: Employee Tax Exemption Declaration,Income From Other Sources,Dohodek iz drugih virov
DocType: Warehouse,"If blank, parent Warehouse Account or company default will be considered","Če je prazno, se upošteva nadrejeni račun skladišča ali privzeto podjetje"
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: Tax Rule,Shipping County,Dostava County
DocType: Currency Exchange,For Selling,Za prodajo
apps/erpnext/erpnext/config/desktop.py,Learn,Naučite
,Trial Balance (Simple),Preizkusna bilanca (preprosto)
DocType: Purchase Invoice Item,Enable Deferred Expense,Omogoči odloženi strošek
apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Uporabljena koda kupona
DocType: Asset,Next Depreciation Date,Naslednja Amortizacija Datum
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,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,Supplier Invoice No exists in Purchase Invoice {0},Dobavitelj računa ni v računu o nakupu obstaja {0}
apps/erpnext/erpnext/config/crm.py,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,Outstanding Cheques and Deposits to clear,Neporavnani čeki in depoziti želite počistiti
DocType: Item,Synced With Hub,Sinhronizirano Z Hub
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward supplies from ISD,Vhodne zaloge ISD
DocType: Driver,Fleet Manager,Fleet Manager
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Row #{0}: {1} can not be negative for item {2},Vrstica # {0} {1} ne more biti negativna za element {2}
apps/erpnext/erpnext/setup/doctype/company/company.js,Wrong Password,Napačno geslo
DocType: POS Profile,Offline POS Settings,Nastavitve brez povezave POS
DocType: Stock Entry Detail,Reference Purchase Receipt,Referenčno potrdilo o nakupu
DocType: Stock Reconciliation,MAT-RECO-.YYYY.-,MAT-RECO-.LLLL.-
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Variant Of,Varianta
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Completed Qty can not be greater than 'Qty to Manufacture',Dopolnil Količina ne sme biti večja od &quot;Kol za Izdelava&quot;
apps/erpnext/erpnext/public/js/purchase_trends_filters.js,Period based On,Obdobje na podlagi
DocType: Period Closing Voucher,Closing Account Head,Zapiranje računa Head
DocType: Employee,External Work History,Zunanji Delo Zgodovina
apps/erpnext/erpnext/projects/doctype/task/task.py,Circular Reference Error,Krožna Reference Error
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Report Card,Student Report Card
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Pin Code,Iz kode PIN
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Sales Person,Pokaži prodajno osebo
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,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,{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: BOM Item,Rate & Amount,Stopnja in znesek
apps/erpnext/erpnext/config/website.py,Settings for website product listing,Nastavitve za seznam izdelkov na spletnem mestu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Amount of Integrated Tax,Znesek integriranega davka
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Obvesti po e-pošti na ustvarjanje avtomatičnega Material dogovoru
DocType: Accounting Dimension,Dimension Name,Ime razsežnosti
apps/erpnext/erpnext/healthcare/setup.py,Resistant,Odporen
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Please set Hotel Room Rate on {},"Prosimo, nastavite hotelsko sobo na {"
DocType: Journal Entry,Multi Currency,Multi Valuta
DocType: Bank Statement Transaction Invoice Item,Invoice Type,Račun Type
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from date must be less than valid upto date,"Velja od datuma, ki mora biti manjši od veljavnega do datuma"
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Exception occurred while reconciling {0},Med usklajevanjem {0} je prišlo do izjeme.
DocType: Purchase Invoice,Set Accepted Warehouse,Nastavite Sprejeto skladišče
DocType: Employee Benefit Claim,Expense Proof,Dokazilo o stroških
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.py,Saving {0},Shranjevanje {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Delivery Note,Poročilo o dostavi
DocType: Patient Encounter,Encounter Impression,Ujemanje prikaza
apps/erpnext/erpnext/config/help.py,Setting up Taxes,Postavitev Davki
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Sold Asset,Stroški Prodano sredstvi
DocType: Volunteer,Morning,Jutro
apps/erpnext/erpnext/accounts/utils.py,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/accounts/doctype/item_tax_template/item_tax_template.py,{0} entered twice in Item Tax,{0} dvakrat vpisano v davčni postavki
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,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/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid transactions sync error,Napaka sinhronizacije transakcij v plaidu
DocType: Leave Ledger Entry,Is Expired,Isteklo
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py,Amount After Depreciation,Znesek Po amortizacijo
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Upcoming Calendar Events,Prihajajoči Koledar dogodkov
apps/erpnext/erpnext/public/js/templates/item_quick_entry.html,Variant Attributes,Atributi atributov
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Please select month and year,"Prosimo, izberite mesec in leto"
DocType: Employee,Company Email,Družba E-pošta
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,User has not applied rule on the invoice {0},Uporabnik na računu ni uporabil pravila {0}
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,Order Value,Vrednost naročila
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Value,Vrednost naročila
DocType: Certified Consultant,Certified Consultant,Certified Consultant
apps/erpnext/erpnext/config/accounting.py,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/hr/doctype/training_event/training_event.py,End time cannot be before start time,Končni čas ne more biti pred začetkom
apps/erpnext/erpnext/templates/generators/item/item_configure.js,1 exact match.,1 natančno ujemanje.
apps/erpnext/erpnext/stock/doctype/item/item.js,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"Ta postavka je Predloga in je ni mogoče uporabiti v transakcijah. Atributi 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,Total Order Considered,Skupaj naročite Upoštevani
DocType: Certification Application,Not Certified,Ni potrjeno
DocType: Asset Value Adjustment,New Asset Value,Nova vrednost sredstev
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,Tečajno orodje za planiranje
apps/erpnext/erpnext/controllers/accounts_controller.py,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}
DocType: Crop Cycle,LInked Analysis,LInked analiza
DocType: POS Closing Voucher,POS Closing Voucher,POS zaključni bon
apps/erpnext/erpnext/support/doctype/issue_priority/issue_priority.py,Issue Priority Already Exists,Prednostna naloga izdaje že obstaja
DocType: Invoice Discounting,Loan Start Date,Datum začetka posojila
DocType: Contract,Lapsed,Neodločeno
DocType: Item Tax Template Detail,Tax Rate,Davčna stopnja
apps/erpnext/erpnext/education/doctype/course_activity/course_activity.py,Course Enrollment {0} does not exists,Vpis na tečaj {0} ne obstaja
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Application period cannot be across two allocation records,Obdobje uporabe ne more biti v dveh evidencah dodelitve
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,{0} already allocated for Employee {1} for period {2} to {3},{0} že dodeljeno za zaposlenega {1} za obdobje {2} do {3}
DocType: Buying Settings,Backflush Raw Materials of Subcontract Based On,Backflush surovine podizvajalske pogodbe na podlagi
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Purchase Invoice {0} is already submitted,Nakup Račun {0} je že predložila
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,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
DocType: Leave Type,Allow Encashment,Dovoli Encashment
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to non-Group,"Pretvarjanje, da non-Group"
DocType: Exotel Settings,Account SID,SID računa
DocType: Bank Statement Transaction Invoice Item,Invoice Date,Datum računa
DocType: GL Entry,Debit Amount,Debetni Znesek
apps/erpnext/erpnext/accounts/party.py,There can only be 1 Account per Company in {0} {1},"Ne more biti samo 1 račun na podjetje, v {0} {1}"
DocType: Support Search Source,Response Result Key Path,Ključna pot Result Result
DocType: Journal Entry,Inter Company Journal Entry,Inter Entry Journal Entry
apps/erpnext/erpnext/accounts/party.py,Due Date cannot be before Posting / Supplier Invoice Date,Datum zapadlosti ne more biti pred datumom napotitve / računa
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For quantity {0} should not be grater than work order quantity {1},Količina {0} ne sme biti višja od količine delovnega naloga {1}
DocType: Employee Training,Employee Training,Usposabljanje zaposlenih
DocType: Quotation Item,Additional Notes,Dodatne opombe
DocType: Purchase Order,% Received,% Prejeto
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Create Student Groups,Ustvarjanje skupin študentov
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Available quantity is {0}, you need {1}","Količina na voljo je {0}, potrebujete {1}"
DocType: Volunteer,Weekends,Vikendi
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,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,Pregledal
DocType: Asset,ACC-ASS-.YYYY.-,ACC-ASS-.YYYY.-
DocType: Asset Maintenance Log,Maintenance Type,Vzdrževanje Tip
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Course {2},{0} - {1} ni vpisan v smer {2}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Name: ,Študentsko ime:
DocType: POS Closing Voucher,Difference,Razlika
DocType: Delivery Settings,Delay between Delivery Stops,Zakasnitev med stopnjami dostave
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Serial No {0} does not belong to Delivery Note {1},Serijska št {0} ne pripada dobavnica {1}
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,"There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.","Zdi se, da obstaja težava s strežniško GoCardless konfiguracijo. V primeru neuspeha ne skrbite, znesek bo povrnjen na vaš račun."
apps/erpnext/erpnext/templates/pages/demo.html,ERPNext Demo,ERPNext Demo
apps/erpnext/erpnext/public/js/utils/item_selector.js,Add Items,Dodaj artikel
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Postavka Inšpekcijski parametrov kakovosti
DocType: Leave Application,Leave Approver Name,Pustite odobritelju Name
DocType: Depreciation Schedule,Schedule Date,Urnik Datum
DocType: Amazon MWS Settings,FR,FR
DocType: Packed Item,Packed Item,Pakirani Postavka
DocType: Job Offer Term,Job Offer Term,Job Offer Term
apps/erpnext/erpnext/config/buying.py,Default settings for buying transactions.,Privzete nastavitve za nabavo
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,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,Mandatory field - Get Students From,Obvezno polje - Pridobi študente iz
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Get Students From,Obvezno polje - Pridobi študente iz
DocType: Program Enrollment,Enrolled courses,vpisani tečaji
DocType: Program Enrollment,Enrolled courses,vpisani tečaji
DocType: Currency Exchange,Currency Exchange,Menjalnica
apps/erpnext/erpnext/support/doctype/issue/issue.js,Resetting Service Level Agreement.,Ponastavitev sporazuma o ravni storitev.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Item Name,Ime izdelka
DocType: Authorization Rule,Approving User  (above authorized value),Odobritvi uporabnik (zgoraj pooblaščeni vrednosti)
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Credit Balance,Kreditno stanje
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: Attendance,Working Hours,Delovni čas
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,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: Accounts Settings,Percentage you are allowed to bill more against the amount ordered. For example: If the order value is $100 for an item and tolerance is set as 10% then you are allowed to bill for $110.,"Odstotek vam lahko zaračuna več v primerjavi z naročenim zneskom. Na primer: Če je vrednost naročila za izdelek 100 USD in je toleranca nastavljena na 10%, potem lahko zaračunate 110 USD."
DocType: Dosage Strength,Strength,Moč
apps/erpnext/erpnext/public/js/controllers/transaction.js,Cannot find Item with this barcode,Elementa ni mogoče najti s to črtno kodo
apps/erpnext/erpnext/accounts/page/pos/pos.js,Create a new Customer,Ustvari novo stranko
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Expiring On,Izteče se
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Če je več Rules Cenik še naprej prevladovala, so pozvane, da nastavite Priority ročno za reševanje morebitnih sporov."
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Purchase Return,nakup Return
apps/erpnext/erpnext/utilities/activation.py,Create Purchase Orders,Ustvari naročilnice
,Purchase Register,Nakup Register
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Patient not found,Bolnik ni najden
DocType: Landed Cost Item,Applicable Charges,Veljavnih cenah
DocType: Workstation,Consumable Cost,Potrošni stroški
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Response Time for {0} at index {1} can't be greater than Resolution Time.,Odzivni čas za {0} pri indeksu {1} ne more biti daljši od ločljivosti.
DocType: Purchase Receipt,Vehicle Date,Datum vozilo
DocType: Campaign Email Schedule,Campaign Email Schedule,Načrt e-poštnih sporočil kampanje
DocType: Student Log,Medical,Medical
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Drug,Izberite Drogo
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Lead Owner cannot be same as the Lead,Svinec Lastnik ne more biti isto kot vodilni
DocType: Announcement,Receiver,sprejemnik
DocType: Location,Area UOM,Področje UOM
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,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,Opportunities,Priložnosti
DocType: Lab Test Template,Single,Samski
DocType: Compensatory Leave Request,Work From Date,Delo od datuma
DocType: Salary Slip,Total Loan Repayment,Skupaj posojila Povračilo
DocType: Project User,View attachments,Ogled prilog
DocType: Account,Cost of Goods Sold,Nabavna vrednost prodanega blaga
DocType: Article,Publish Date,Datum objave
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,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,Avg. Selling Rate,Avg. Prodajni tečaj
DocType: Assessment Plan,Examiner Name,Ime Examiner
DocType: Lab Test Template,No Result,Ne Rezultat
DocType: Woocommerce Settings,"The fallback series is ""SO-WOO-"".",Nadomestna serija je &quot;SO-WOO-&quot;.
DocType: Purchase Invoice Item,Quantity and Rate,Količina in stopnja
DocType: Delivery Note,% Installed,% nameščeno
apps/erpnext/erpnext/utilities/user_progress.py,Classrooms/ Laboratories etc where lectures can be scheduled.,"Učilnice / Laboratories itd, kjer se lahko načrtovana predavanja."
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Company currencies of both the companies should match for Inter Company Transactions.,Valutne družbe obeh družb se morajo ujemati s transakcijami Inter Company.
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Please enter company name first,"Prosimo, da najprej vpišete ime podjetja"
DocType: Travel Itinerary,Non-Vegetarian,Ne-vegetarijanska
DocType: Purchase Invoice,Supplier Name,Dobavitelj Name
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Read the ERPNext Manual,Preberite ERPNext navodila
DocType: HR Settings,Show Leaves Of All Department Members In Calendar,Prikaži liste vseh članov oddelka v koledarju
DocType: Purchase Invoice,01-Sales Return,01-Prodaja Vrnitev
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Qty per BOM Line,Količina na vrstico BOM
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,Temporarily on Hold,Začasno zadržano
DocType: Account,Is Group,Is Group
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Credit Note {0} has been created automatically,Kreditna kartica {0} je bila ustvarjena samodejno
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Request for Raw Materials,Prošnja za Surove materiale
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,Primary Address Details,Osnovni podatki o naslovu
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Public token is missing for this bank,Za to banko manjka javni žeton
DocType: Vehicle Service,Oil Change,Menjava olja
DocType: Leave Encashment,Leave Balance,Pusti ravnovesje
DocType: Asset Maintenance Log,Asset Maintenance Log,Dnevnik o vzdrževanju sredstev
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,'To Case No.' cannot be less than 'From Case No.','Do št. primera' ne more biti nižja od 'Od št. primera'
DocType: Certification Application,Non Profit,Non Profit
DocType: Production Plan,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,Mandatory field - Academic Year,Obvezno polje - študijsko leto
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Academic Year,Obvezno polje - študijsko leto
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} is not associated with {2} {3},{0} {1} ni povezan z {2} {3}
DocType: Opportunity,Converted By,Pretvoril
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,You need to login as a Marketplace User before you can add any reviews.,"Preden lahko dodate ocene, se morate prijaviti kot uporabnik tržnice."
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0} : Operation is required against the raw material item {1},Vrstica {0}: delovanje je potrebno proti elementu surovin {1}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Please set default payable account for the company {0},"Prosimo, nastavite privzeto se plača račun za podjetje {0}"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Transaction not allowed against stopped Work Order {0},Transakcija ni dovoljena prekinjena Delovni nalog {0}
DocType: Setup Progress Action,Min Doc Count,Min Doc Count
apps/erpnext/erpnext/config/manufacturing.py,Global settings for all manufacturing processes.,Globalne nastavitve za vseh proizvodnih procesov.
DocType: Accounts Settings,Accounts Frozen Upto,Računi Zamrznjeni do
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Day Book Data,Obdelajte podatke o knjigi na dan
DocType: SMS Log,Sent On,Pošlje On
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Incoming call from {0},Dohodni klic od {0}
apps/erpnext/erpnext/stock/doctype/item/item.py,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
DocType: Amazon MWS Settings,UK,Velika Britanija
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Opening Invoice Item,Odpiranje računa
DocType: Request for Quotation Item,Required Date,Zahtevani Datum
DocType: Accounts Settings,Billing Address,Naslov za pošiljanje računa
DocType: Bank Statement Settings,Statement Headers,Glave izjave
DocType: Travel Request,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"
DocType: Request for Quotation,Message for Supplier,Sporočilo za dobavitelja
DocType: BOM,Work Order,Delovni nalog
DocType: Sales Invoice,Total Qty,Skupaj Kol
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Skrbnika2 E-ID
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,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,Reserved for sale,Rezervirano za prodajo
DocType: Packing Slip,From Package No.,Od paketa No.
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Row #{0}: Payment document is required to complete the transaction,Vrstica # {0}: Za dokončanje transakcije je potreben plačilni dokument
DocType: Item Attribute,To Range,Da Domet
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Securities and Deposits,Vrednostne papirje in depozite
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","ne more spremeniti metode vrednotenja, kot so transakcije pred nekaj elementov, ki ga ne imeti svojo lastno metodo vrednotenja"
DocType: Student Report Generation Tool,Attended by Parents,Obiskujejo starši
apps/erpnext/erpnext/hr/doctype/shift_assignment/shift_assignment.py,Employee {0} has already applied for {1} on {2} : ,Zaposleni {0} je že zaprosil za {1} na {2}:
DocType: Inpatient Record,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,Pending activities for today,V čakanju na aktivnosti za danes
DocType: Salary Structure,Salary Component for timesheet based payroll.,"Plača Komponenta za Timesheet na izplačane plače, ki temelji."
DocType: Driver,Applicable for external driver,Velja za zunanjega voznika
DocType: Sales Order Item,Used for Production Plan,Uporablja se za proizvodnjo načrta
DocType: BOM,Total Cost (Company Currency),Skupni stroški (valuta podjetja)
DocType: Loan,Total Payment,Skupaj plačila
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Cannot cancel transaction for Completed Work Order.,Transakcije za zaključeno delovno nalogo ni mogoče preklicati.
DocType: Manufacturing Settings,Time Between Operations (in mins),Čas med dejavnostmi (v minutah)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,PO already created for all sales order items,PO je že ustvarjen za vse postavke prodajnega naročila
DocType: Healthcare Service Unit,Occupied,Zasedeno
DocType: Clinical Procedure,Consumables,Potrošni material
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js,Include Default Book Entries,Vključi privzete vnose v knjige
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled so the action cannot be completed,"{0} {1} je preklican, dejanje ne more biti dokončano"
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Planned Qty: Quantity, for which, Work Order has been raised, but is pending to be manufactured.","Količina načrtovanih: Količina, za katero je bil delovni nalog dvignjen, vendar ga bo treba izdelati."
DocType: Customer,Buyer of Goods and Services.,Kupec blaga in storitev.
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,'employee_field_value' and 'timestamp' are required.,Zahtevana sta &#39;Employ_field_value&#39; in &#39;timetamp&#39;.
DocType: Journal Entry,Accounts Payable,Računi se plačuje
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,"V tem zahtevku za plačilo je znesek {0} različen od izračunane vsote vseh plačilnih načrtov: {1}. Preden pošljete dokument, se prepričajte, da je to pravilno."
DocType: Patient,Allergies,Alergije
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,The selected BOMs are not for the same item,Izbrani BOMs niso na isti točki
apps/erpnext/erpnext/stock/doctype/item_variant_settings/item_variant_settings.py,Cannot set the field <b>{0}</b> for copying in variants,Polja <b>{0}</b> ni mogoče nastaviti za kopiranje v različicah
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Item Code,Koda postavke spremenite
DocType: Supplier Scorecard Standing,Notify Other,Obvesti drugo
DocType: Vital Signs,Blood Pressure (systolic),Krvni tlak (sistolični)
apps/erpnext/erpnext/controllers/buying_controller.py,{0} {1} is {2},{0} {1} je {2}
DocType: Item Price,Valid Upto,Valid Stanuje
DocType: Leave Type,Expire Carry Forwarded Leaves (Days),Pretekle rokavice (dnevi)
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,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.
DocType: Employee Tax Exemption Proof Submission,Rented From Date,Najem od datuma
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Enough Parts to Build,Dovolj deli za izgradnjo
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Please save first,Najprej shranite
DocType: POS Profile User,POS Profile User,POS profil uporabnika
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Row {0}: Depreciation Start Date is required,Vrstica {0}: začetni datum amortizacije je obvezen
DocType: Purchase Invoice Item,Service Start Date,Datum začetka storitve
DocType: Subscription Invoice,Subscription Invoice,Naročniški račun
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Income,Neposredne dohodkovne
DocType: Patient Appointment,Date TIme,Datum čas
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"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,Administrative Officer,Upravni uradnik
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Course,Izberite tečaj
DocType: Codification Table,Codification Table,Tabela kodifikacije
DocType: Timesheet Detail,Hrs,Ur
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Changes in {0},Spremembe v {0}
DocType: Employee Skill,Employee Skill,Spretnost zaposlenih
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Difference Account,Razlika račun
DocType: Pricing Rule,Discount on Other Item,Popust na drugi artikel
DocType: Purchase Invoice,Supplier GSTIN,Dobavitelj GSTIN
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,View Form,Prikaži obrazec
DocType: Work 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,Cosmetics,Kozmetika
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,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/material_request/material_request.py,{0} is not the default supplier for any items.,{0} ni privzeti dobavitelj za nobene izdelke.
apps/erpnext/erpnext/stock/doctype/item/item.py,"To merge, following properties must be same for both items","Za pripojitev, mora naslednje lastnosti biti enaka za oba predmetov"
DocType: Supplier,Block Supplier,Blokiraj dobavitelja
DocType: Shipping Rule,Net Weight,Neto teža
DocType: Job Opening,Planned number of Positions,Predvideno število pozicij
DocType: Employee,Emergency Phone,Zasilna Telefon
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,{0} {1} does not exist.,{0} {1} ne obstaja.
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Buy,Nakup
,Serial No Warranty Expiry,Zaporedna številka Garancija preteka
DocType: Sales Invoice,Offline POS Name,Offline POS Ime
DocType: Task,Dependencies,Odvisnosti
apps/erpnext/erpnext/utilities/user_progress.py,Student Application,Študijska aplikacija
DocType: Bank Statement Transaction Payment Item,Payment Reference,Sklicevanje na plačilo
DocType: Supplier,Hold Type,Tip držite
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Please define grade for Threshold 0%,"Prosimo, določite stopnjo za praga 0%"
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Please define grade for Threshold 0%,"Prosimo, določite stopnjo za praga 0%"
DocType: Bank Statement Transaction Payment Item,Bank Statement Transaction Payment Item,Postavka plačilne transakcije za bančno izjavo
DocType: Sales Order,To Deliver,Dostaviti
DocType: Purchase Invoice Item,Item,Postavka
apps/erpnext/erpnext/healthcare/setup.py,High Sensitivity,Visoka občutljivost
apps/erpnext/erpnext/config/non_profit.py,Volunteer Type information.,Informacije o prostovoljcih.
DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Predloga za preslikavo denarnega toka
DocType: Travel Request,Costing Details,Podrobnosti o stroških
apps/erpnext/erpnext/selling/report/sales_partner_transaction_summary/sales_partner_transaction_summary.js,Show Return Entries,Prikaži vnose za vračilo
apps/erpnext/erpnext/accounts/page/pos/pos.js,Serial no item cannot be a fraction,Serijska št postavka ne more biti del
DocType: Journal Entry,Difference (Dr - Cr),Razlika (Dr - Cr)
DocType: Bank Guarantee,Providing,Zagotavljanje
DocType: Account,Profit and Loss,Dobiček in izguba
DocType: Tally Migration,Tally Migration,Tally Migration
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,"Not permitted, configure Lab Test Template as required","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
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Stock Entries already created for Work Order ,"Zaloge, ki so že bile ustvarjene za delovno nalogo"
apps/erpnext/erpnext/templates/pages/cart.html,See past orders,Glej pretekla naročila
apps/erpnext/erpnext/public/js/hub/pages/Selling.vue,{0} conversations,{0} pogovori
DocType: Vital Signs,Respiratory rate,Stopnja dihanja
apps/erpnext/erpnext/config/help.py,Managing Subcontracting,Upravljanje Podizvajalcev
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
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},"Ni mogoče preklicati {0} {1}, ker serijska številka {2} ne pripada skladišču {3}"
DocType: Detected Disease,Disease,Bolezen
DocType: Company,Default Deferred Expense Account,Privzeti odloženi račun za stroške
apps/erpnext/erpnext/config/projects.py,Define Project type.,Določite vrsto projekta.
DocType: Supplier Scorecard,Weighting Function,Tehtalna funkcija
DocType: Employee Tax Exemption Proof Submission,Total Actual Amount,Skupni dejanski znesek
DocType: Healthcare Practitioner,OP Consulting Charge,OP Consulting Charge
apps/erpnext/erpnext/utilities/user_progress.py,Setup your ,Nastavite svoje
DocType: Student Report Generation Tool,Show Marks,Pokaži oznake
DocType: Support Settings,Get Latest Query,Najnovejša poizvedba
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,Account {0} does not belong to company: {1},Račun {0} ne pripada podjetju: {1}
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation already used for another company,Kratica že uporabljena za druge družbe
DocType: Selling Settings,Default Customer Group,Privzeta skupina kupcev
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Payment Tems,Tems plačila
DocType: Employee,IFSC Code,Kodeks IFSC
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: Bank Statement Transaction Entry,Match Transaction to Invoices,Ujemanje transakcije z računi
apps/erpnext/erpnext/erpnext_integrations/exotel_integration.py,Error in Exotel incoming call,Napaka pri dohodnem klicu Exotel
DocType: Sales Order Item,Gross Profit,Bruto dobiček
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Unblock Invoice,Odblokiraj račun
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Increment cannot be 0,Prirastek ne more biti 0
DocType: Company,Delete Company Transactions,Izbriši transakcije družbe
DocType: Production Plan Item,Quantity and Description,Količina in opis
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,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
DocType: Inpatient Record,HLC-INP-.YYYY.-,HLC-INP-.LLLL.-
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"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,Closing (Cr),Zapiranje (Cr)
DocType: Purchase Invoice,Registered Composition,Registrirana sestava
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html,Hello,Pozdravljeni
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Move Item,Move Item
DocType: Employee Incentive,Incentive Amount,Spodbujevalni znesek
,Employee Leave Balance Summary,Povzetek salda zaposlenih
DocType: Serial No,Warranty Period (Days),Garancijski rok (dni)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Total Credit/ Debit Amount should be same as linked Journal Entry,Skupni znesek kredita / obresti mora biti enak kot povezan dnevnik
DocType: Installation Note Item,Installation Note Item,Namestitev Opomba Postavka
DocType: Production Plan Item,Pending Qty,Pending Kol
DocType: Budget,Ignore,Prezri
apps/erpnext/erpnext/accounts/party.py,{0} {1} is not active,{0} {1} ni aktiven
DocType: Woocommerce Settings,Freight and Forwarding Account,Tovorni in posredniški račun
apps/erpnext/erpnext/config/accounting.py,Setup cheque dimensions for printing,Preverite nastavitve za dimenzije za tiskanje
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Create Salary Slips,Ustvarite plači
DocType: Vital Signs,Bloated,Napihnjen
DocType: Salary Slip,Salary Slip Timesheet,Plača Slip Timesheet
apps/erpnext/erpnext/controllers/buying_controller.py,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dobavitelj Skladišče obvezno za podizvajalcev Potrdilo o nakupu
DocType: Item Price,Valid From,Velja od
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Your rating: ,Vaša ocena:
DocType: Sales Invoice,Total Commission,Skupaj Komisija
DocType: Tax Withholding Account,Tax Withholding Account,Davčni odtegljaj
DocType: Pricing Rule,Sales Partner,Prodaja Partner
apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Vse ocenjevalne table dobaviteljev.
DocType: Coupon Code,To be used to get discount,Uporabiti za popust
DocType: Buying Settings,Purchase Receipt Required,Potrdilo o nakupu Obvezno
DocType: Sales Invoice,Rail,Železnica
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Dejanski stroški
DocType: Item,Website Image,Slika spletnega mesta
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Target warehouse in row {0} must be same as Work Order,Ciljno skladišče v vrstici {0} mora biti enako kot delovni nalog
apps/erpnext/erpnext/stock/doctype/item/item.py,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,No records found in the Invoice table,Ni najdenih v tabeli računa zapisov
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Please select Company and Party Type first,Izberite podjetja in Zabava Vrsta najprej
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,"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/accounting.py,Financial / accounting year.,Finančni / računovodstvo leto.
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js,Accumulated Values,nakopičene Vrednosti
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Sorry, Serial Nos cannot be merged","Oprostite, Serijska št ni mogoče združiti"
DocType: Shopify Settings,Customer Group will set to selected group while syncing customers from Shopify,"Skupina strank bo nastavila na izbrano skupino, medtem ko bo sinhronizirala stranke s spletnim mestom Shopify"
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Territory is Required in POS Profile,Ozemlje je obvezno v profilu POS
DocType: Supplier,Prevent RFQs,Preprečite RFQ-je
DocType: Hub User,Hub User,Uporabnik Hub
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Salary Slip submitted for period from {0} to {1},Plačilo za plačilo je oddano za obdobje od {0} do {1}
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Passing Score value should be between 0 and 100,Vrednost prenosa ocene mora biti med 0 in 100
DocType: Loyalty Point Entry Redemption,Redeemed Points,Uveljavljene točke
,Lead Id,ID Ponudbe
DocType: C-Form Invoice Detail,Grand Total,Skupna vsota
DocType: Assessment Plan,Course,Tečaj
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Section Code,Koda oddelka
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Valuation Rate required for Item {0} at row {1},"Stopnja vrednotenja, potrebna za postavko {0} v vrstici {1}"
DocType: Timesheet,Payslip,Payslip
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Pricing Rule {0} is updated,Pravilo oblikovanja cen {0} je posodobljeno
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Half day date should be in between from date and to date,Poldnevni datum mora biti med datumom in datumom
DocType: POS Closing Voucher,Expense Amount,Znesek odhodkov
apps/erpnext/erpnext/public/js/pos/pos.html,Item Cart,Točka košarico
DocType: Quality Action,Resolution,Ločljivost
DocType: Employee,Personal Bio,Osebni Bio
DocType: C-Form,IV,IV
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Membership ID,ID članstva
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Receive at Warehouse Entry,Prejem na vhodu v skladišče
apps/erpnext/erpnext/templates/pages/material_request_info.html,Delivered: {0},Dobava: {0}
DocType: QuickBooks Migrator,Connected to QuickBooks,Povezava na QuickBooks
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please identify/create Account (Ledger) for type - {0},Opišite / ustvarite račun (knjigo) za vrsto - {0}
DocType: Bank Statement Transaction Entry,Payable Account,Plačljivo račun
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,You haven\,Še niste \
DocType: Payment Entry,Type of Payment,Vrsta plačila
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date is mandatory,Datum poldnevnika je obvezen
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,Repeat Customers,Ponovite Stranke
DocType: Leave Control Panel,Allocate,Dodeli
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variant,Ustvari varianto
DocType: Sales Invoice,Shipping Bill Date,Datum pošiljanja
DocType: Production Plan,Production Plan,Načrt proizvodnje
DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Odpiranje orodja za ustvarjanje računov
DocType: Salary Component,Round to the Nearest Integer,Zaokrožite do najbližjega celega števila
DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,"Dovoli, da se izdelki, ki niso na zalogi, dodajo v košarico"
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Prodaja Return
DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Nastavite količino transakcij na podlagi serijskega vhoda
,Total Stock Summary,Skupaj Stock Povzetek
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,"You can only plan for upto {0} vacancies and budget {1} \
				for {2} as per staffing plan {3} for parent company {4}.",Načrtujete lahko le do {0} prostih delovnih mest in proračuna {1} \ za {2} glede na načrt osebja {3} za matično podjetje {4}.
DocType: Announcement,Posted By,Avtor
apps/erpnext/erpnext/controllers/stock_controller.py,Quality Inspection required for Item {0} to submit,"Inšpekcijski pregled kakovosti, potreben za pošiljanje predmeta {0}"
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,Database of potential customers.,Podatkovna baza potencialnih strank.
DocType: Authorization Rule,Customer or Item,Stranka ali Artikel
apps/erpnext/erpnext/config/crm.py,Customer database.,Baza podatkov o strankah.
DocType: Quotation,Quotation To,Ponudba za
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Middle Income,Bližnji Prihodki
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Cr),Odprtino (Cr)
apps/erpnext/erpnext/stock/doctype/item/item.py,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"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."
DocType: Purchase Invoice,Overseas,V tujini
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Please set the Company,Nastavite Company
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Please set the Company,Nastavite Company
DocType: Share Balance,Share Balance,Deljeno stanje
DocType: Amazon MWS Settings,AWS Access Key ID,AWS Access Key ID
DocType: Employee Tax Exemption Declaration,Monthly House Rent,Mesečna najemnina za hišo
apps/erpnext/erpnext/projects/doctype/task/task_list.js,Set as Completed,Nastavi kot dokončano
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."
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Principal Amount,glavni Znesek
DocType: Loan Application,Total Payable Interest,Skupaj plačljivo Obresti
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Outstanding: {0},Skupno izjemno: {0}
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Open Contact,Odprite stik
DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Prodaja Račun Timesheet
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference No & Reference Date is required for {0},Referenčna št &amp; Referenčni datum je potrebna za {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Serial no(s) required for serialized item {0},Za serijsko postavko {0} niso potrebni serijski številki
DocType: Payroll Entry,Select Payment Account to make Bank Entry,"Izberite Plačilo računa, da bo Bank Entry"
apps/erpnext/erpnext/config/accounting.py,Opening and Closing,Odpiranje in zapiranje
DocType: Hotel Settings,Default Invoice Naming Series,Privzeto imenovanje računov
apps/erpnext/erpnext/utilities/activation.py,"Create Employee records to manage leaves, expense claims and payroll","Ustvarjanje zapisov zaposlencev za upravljanje listje, odhodkov terjatev in na izplačane plače"
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,An error occurred during the update process,Pri postopku posodabljanja je prišlo do napake
DocType: Restaurant Reservation,Restaurant Reservation,Rezervacija restavracij
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Your Items,Predmeti
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal Writing,Predlog Pisanje
DocType: Payment Entry Deduction,Payment Entry Deduction,Plačilo Začetek odštevanja
DocType: Service Level Priority,Service Level Priority,Prednostna raven storitve
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Wrapping up,Zavijanje
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Notify Customers via Email,Obvesti stranke po e-pošti
DocType: Item,Batch Number Series,Serijska številka serije
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,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/hr/doctype/leave_allocation/leave_allocation.js,Expire Allocation,Poteče dodelitev
DocType: QuickBooks Migrator,Authorization Settings,Nastavitve avtorizacije
DocType: Travel Itinerary,Departure Datetime,Odhod Datetime
apps/erpnext/erpnext/hub_node/api.py,No items to publish,Ni predmetov za objavo
DocType: Customer,CUST-.YYYY.-,CUST-.YYYY.-
DocType: Travel Request Costing,Travel Request Costing,Potni stroški
apps/erpnext/erpnext/config/healthcare.py,Masters,Masters
DocType: Employee Onboarding,Employee Onboarding Template,Predloga za vknjiževanje zaposlenih
DocType: Assessment Plan,Maximum Assessment Score,Najvišja ocena Ocena
apps/erpnext/erpnext/config/accounting.py,Update Bank Transaction Dates,Update banka transakcijske Termini
apps/erpnext/erpnext/config/projects.py,Time Tracking,sledenje čas
DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DVOJNIK ZA TRANSPORTER
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Row {0}# Paid Amount cannot be greater than requested advance amount,Vrstica {0} # Plačan znesek ne sme biti 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: Employee Grade,Default Salary Structure,Privzeta plačna struktura
DocType: Stock Entry,Send to Warehouse,Pošlji v Skladišče
apps/erpnext/erpnext/hr/report/daily_work_summary_replies/daily_work_summary_replies.py,Replies,Odgovori
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,Creating student groups,Ustvarjanje študentskih skupin
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Creating student groups,Ustvarjanje študentskih skupin
apps/erpnext/erpnext/accounts/utils.py,"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,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: Supplier Scorecard Period,PU-SSP-.YYYY.-,PU-SSP-YYYY.-
DocType: Vital Signs,Height (In Meter),Višina (v metrih)
DocType: Student,Sibling Details,sorodstvena Podrobnosti
DocType: Vehicle Service,Vehicle Service,servis vozila
DocType: Employee,Reason for Resignation,Razlog za odstop
DocType: Sales Invoice,Credit Note Issued,Dobropis Izdano
DocType: Task,Weight,Teža
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Račun / Journal Entry Podrobnosti
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,{0} bank transaction(s) created,{0} ustvarili bančne transakcije
apps/erpnext/erpnext/accounts/utils.py,{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,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,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
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Maintenance Schedule,Vzdrževanje Urnik
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Potem Označevanje cen Pravila se filtrirajo temeljijo na stranke, skupine kupcev, ozemlje, dobavitelja, dobavitelj Type, kampanje, prodajnemu partnerju itd"
DocType: Employee Promotion,Employee Promotion Details,Podrobnosti o napredovanju zaposlenih
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Inventory,Neto sprememba v popisu
DocType: Employee,Passport Number,Številka potnega lista
DocType: Invoice Discounting,Accounts Receivable Credit Account,Kreditni račun terjatev
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian2,Povezava z skrbnika2
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Manager,Manager
DocType: Payment Entry,Payment From / To,Plačilo Od / Do
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,From Fiscal Year,Od fiskalnega leta
apps/erpnext/erpnext/selling/doctype/customer/customer.py,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},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,Please set account in Warehouse {0},Nastavite račun v Galeriji {0}
apps/erpnext/erpnext/controllers/trends.py,'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: GSTR 3B Report,December,December
DocType: Work Order Operation,In minutes,V minutah
DocType: Production Plan,"If enabled, then system will create the material even if the raw materials are available","Če je omogočeno, sistem ustvari material, tudi če so na voljo surovine"
apps/erpnext/erpnext/templates/pages/cart.html,See past quotations,Oglejte si pretekle navedke
DocType: Issue,Resolution Date,Resolucija Datum
DocType: Lab Test Template,Compound,Spojina
DocType: Opportunity,Probability (%),Verjetnost (%)
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Dispatch Notification,Obvestilo o odpremi
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Select Property,Izberite lastnost
DocType: Course Activity,Course Activity,Dejavnost tečaja
DocType: Student Batch Name,Batch Name,serija Ime
DocType: Fee Validity,Max number of visit,Največje število obiska
DocType: Accounting Dimension Detail,Mandatory For Profit and Loss Account,Obvezno za račun dobička in izgube
,Hotel Room Occupancy,Hotelske sobe
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,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,Enroll,včlanite se
DocType: GST Settings,GST Settings,GST Nastavitve
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Currency should be same as Price List Currency: {0},Valuta mora biti enaka ceni valute: {0}
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,Convert to Group,Pretvarjanje skupini
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)
,Qty To Be Billed,"Količina, ki jo morate plačati"
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Delivered Znesek
DocType: Coupon Code,Gift Card,Darilne kartice
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Količina pridržane za proizvodnjo: Količina surovin za izdelavo izdelkov.
DocType: Loyalty Point Entry Redemption,Redemption Date,Datum odkupa
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Ta bančna transakcija je že v celoti usklajena
DocType: Sales Invoice,Packing List,Seznam pakiranja
apps/erpnext/erpnext/config/buying.py,Purchase Orders given to Suppliers.,Naročila dati dobaviteljev.
DocType: Contract,Contract Template,Predloga pogodbe
DocType: Clinical Procedure Item,Transfer Qty,Prenos količine
DocType: Purchase Invoice Item,Asset Location,Lokacija sredstva
apps/erpnext/erpnext/projects/report/billing_summary.py, From Date can not be greater than To Date,Od datuma ne more biti večje od Do datuma
DocType: Tax Rule,Shipping Zipcode,Poštna številka pošiljanja
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,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,Consumed,Porabljeno
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,{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,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Vzdrževanje obisk {0} je treba odpovedati pred preklicem te Sales Order
apps/erpnext/erpnext/templates/pages/help.html,What do you need help with?,Kaj potrebujete pomoč?
DocType: Employee Checkin,Shift Start,Shift Start
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Material Transfer,Prenos materialov
DocType: Cost Center,Cost Center Number,Številka stroškovnega centra
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py,Could not find path for ,Pot ni mogla najti
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Dr),Odprtje (Dr)
DocType: Compensatory Leave Request,Work End Date,Datum zaključka dela
DocType: Loan,Applicant,Vlagatelj
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Posting timestamp must be after {0},Napotitev žig mora biti po {0}
,GST Itemised Purchase Register,DDV Razčlenjeni Nakup Registracija
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is a limited liability company,"Uporablja se, če je družba z omejeno odgovornostjo"
DocType: Course Scheduling Tool,Reschedule,Ponovni premik
DocType: Item Tax Template,Item Tax Template,Predloga davčne predloge
DocType: Loan,Total Interest Payable,Skupaj Obresti plačljivo
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for Hold,Razlog za zadrževanje
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Iztovorjeni stroškov Davki in prispevki
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,"Vrstica {0}: Prosimo, nastavite Razlog oprostitve plačila davkov na promet in davkov"
DocType: Quality Goal Objective,Quality Goal Objective,Cilj Kakovostni cilj
DocType: Work Order Operation,Actual Start Time,Actual Start Time
DocType: Purchase Invoice Item,Deferred Expense Account,Odloženi račun za stroške
DocType: BOM Operation,Operation Time,Operacija čas
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Finish,Finish
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Base,Osnovna
DocType: Timesheet,Total Billed Hours,Skupaj Obračunane ure
DocType: Pricing Rule Item Group,Pricing Rule Item Group,Skupina izdelkov s predpisi o cenah
DocType: Travel Itinerary,Travel To,Potovati v
apps/erpnext/erpnext/config/accounting.py,Exchange Rate Revaluation master.,Poveljnik prevrednotenja deviznega tečaja
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,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: Lab Test Template,Grouped,Združeno
DocType: Selling Settings,Delivery Note Required,Dostava Opomba Obvezno
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Submitting Salary Slips...,Predložitev plakatov ...
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)
apps/erpnext/erpnext/accounts/doctype/account/account.py,"While creating account for child Company {0}, parent account {1} not found. Please create the parent account in corresponding COA","Pri ustvarjanju računa za otroško podjetje {0}, nadrejenega računa {1} ni mogoče najti. Ustvarite nadrejeni račun v ustreznem COA"
apps/erpnext/erpnext/support/doctype/issue/issue.js,Split Issue,Razdelitev izdaje
DocType: Student Attendance,Student Attendance,študent Udeležba
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,No data to export,Ni podatkov za izvoz
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,Reserve Warehouse,Rezervno skladišče
DocType: Lead,Lead is an Organization,Svinec je organizacija
DocType: Guardian Interest,Interest,Obresti
apps/erpnext/erpnext/accounts/doctype/tax_category/tax_category_dashboard.py,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,Suplier,suplier
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Actual Delivery Date,Dejanski datum dostave
DocType: Lab Test,Test Template,Preskusna predloga
DocType: Restaurant Order Entry Item,Served,Servirano
apps/erpnext/erpnext/config/non_profit.py,Chapter information.,Podatki o poglavju.
DocType: Account,Accounts,Računi
DocType: Vehicle,Odometer Value (Last),Vrednost števca (Zadnja)
apps/erpnext/erpnext/config/buying.py,Templates of supplier scorecard criteria.,Predloge meril uspešnosti dobaviteljev.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Marketing,Trženje
DocType: Sales Invoice,Redeem Loyalty Points,Izkoristite točke zvestobe
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,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
DocType: Pricing Rule,System will notify to increase or decrease quantity or amount ,Sistem bo obvestil o povečanju ali zmanjšanju količine ali količine
apps/erpnext/erpnext/controllers/accounts_controller.py,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,Preview Salary Slip,Predogled Plača listek
apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Ustvari časopis
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,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/hooks.py,Purchase Invoices,Nakup računov
apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,"Obnovite lahko le, če vaše članstvo poteče v 30 dneh"
DocType: Shopping Cart Settings,Show Stock Availability,Prihranite sedaj null%!
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Nastavite {0} v kategoriji sredstev {1} ali podjetje {2}
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per section 17(5),Po oddelku 17 (5)
DocType: Location,Longitude,Dolžina
,Absent Student Report,Odsoten Student Report
DocType: Crop,Crop Spacing UOM,UOM razmika rastlin
DocType: Loyalty Program,Single Tier Program,Program enotnega razreda
DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,"Izberite samo, če imate nastavljene dokumente o denarnem toku Mapper"
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Address 1,Od naslova 1
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,Item has variants.,Element ima variante.
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Total Student,Skupaj študent
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Item {0} not found,Postavka {0} ni bilo mogoče najti
DocType: Bin,Stock Value,Stock Value
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Duplicate {0} found in the table,Podvojeni {0} v tabeli
apps/erpnext/erpnext/accounts/doctype/account/account.py,Company {0} does not exist,Podjetje {0} ne obstaja
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} has fee validity till {1},{0} ima veljavnost pristojbine {1}
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Tree Type,Tree Type
DocType: Leave Control Panel,Employee Grade (optional),Stopnja zaposlenega (neobvezno)
DocType: Pricing Rule,Apply Rule On Other,Uporabi pravilo o drugem
DocType: BOM Explosion Item,Qty Consumed Per Unit,Količina porabljene na enoto
DocType: Shift Type,Late Entry Grace Period,Obdobje poznega vstopa
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: Sales Invoice,Commission Rate (%),Komisija Stopnja (%)
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Program,Izberite program
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Program,Izberite program
DocType: Project,Estimated Cost,Ocenjeni strošek
DocType: Supplier Quotation,Link to material requests,Povezava na materialne zahteve
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Publish,Objavi
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Aerospace,Aerospace
,Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC]
DocType: Journal Entry,Credit Card Entry,Začetek Credit Card
apps/erpnext/erpnext/config/selling.py,Invoices for Costumers.,Računi za kupce.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,In Value,v vrednosti
DocType: Asset Settings,Depreciation Options,Možnosti amortizacije
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Either location or employee must be required,Mora biti potrebna lokacija ali zaposleni
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Create Employee,Ustvari zaposlenega
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid Posting Time,Neveljaven čas pošiljanja
DocType: Salary Component,Condition and Formula,Pogoj in formula
DocType: Lead,Campaign Name,Ime kampanje
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Task Completion,Ob zaključku naloge
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,There is no leave period in between {0} and {1},Obdobja dopusta ni med {0} in {1}
DocType: Fee Validity,Healthcare Practitioner,Zdravstveni delavec
DocType: Hotel Room,Capacity,Zmogljivost
DocType: Travel Request Costing,Expense Type,Vrsta izdatkov
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,The field From Shareholder cannot be blank,Polje Od delničarja ne more biti prazno
DocType: Leave Allocation,Allocation,Dodelitev
DocType: Purchase Order,Supply Raw Materials,Oskrba z Surovine
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Structures have been assigned successfully,Strukture so bile dodeljene uspešno
apps/erpnext/erpnext/config/getting_started.py,Create Opening Sales and Purchase Invoices,Ustvarite začetne račune za prodajo in nakup
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Current Assets,Kratkoročna sredstva
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,{0} is not a stock Item,{0} ni zaloge artikla
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',"Pošljite povratne informacije o usposabljanju, tako da kliknete »Povratne informacije o usposabljanju« in nato »Novo«,"
DocType: Call Log,Caller Information,Podatki o klicalcu
DocType: Mode of Payment Account,Default Account,Privzeti račun
apps/erpnext/erpnext/stock/doctype/item/item.py,Please select Sample Retention Warehouse in Stock Settings first,Najprej izberite skladišče za shranjevanje vzorcev v nastavitvah zalog
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,Please select the Multiple Tier Program type for more than one collection rules.,"Prosimo, izberite vrsto programa z več tirnimi sistemi za več pravil za zbiranje."
DocType: Payment Entry,Received Amount (Company Currency),Prejela znesek (družba Valuta)
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Cancelled. Please check your GoCardless Account for more details,Plačilo preklicano. Preverite svoj GoCardless račun za več podrobnosti
DocType: Work Order,Skip Material Transfer to WIP Warehouse,Preskočite prenos materiala v skladišče WIP
DocType: Contract,N/A,N / A
DocType: Task Type,Task Type,Vrsta naloge
DocType: Topic,Topic Content,Vsebina teme
DocType: Delivery Settings,Send with Attachment,Pošlji s prilogo
DocType: Service Level,Priorities,Prednostne naloge
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py,Please select weekly off day,"Prosimo, izberite tedensko off dan"
DocType: Inpatient Record,O Negative,O Negativno
DocType: Work Order Operation,Planned End Time,Načrtovano Končni čas
DocType: POS Profile,Only show Items from these Item Groups,Prikažite samo izdelke iz teh skupin predmetov
apps/erpnext/erpnext/accounts/doctype/account/account.py,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,Memebership Type Details,Podatki o tipu memebership
DocType: Delivery Note,Customer's Purchase Order No,Stranke Naročilo Ne
DocType: Clinical Procedure,Consume Stock,Porabi zalogo
DocType: Budget,Budget Against,proračun proti
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Lost Reasons,Izgubljeni razlogi
apps/erpnext/erpnext/stock/reorder_item.py,Auto Material Requests Generated,Auto Material Zahteve Izdelano
DocType: Shift Type,Working hours below which Half Day is marked. (Zero to disable),"Delovni čas, pod katerim je označen pol dneva. (Nič, da onemogoči)"
DocType: Job Card,Total Completed Qty,Skupaj opravljeno Količina
DocType: HR Settings,Auto Leave Encashment,Samodejno zapustite enkaš
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js,Lost,Lost
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,You can not enter current voucher in 'Against Journal Entry' column,"Ne, ne more vstopiti trenutno bon v &quot;Proti listu vstopa&quot; stolpcu"
DocType: Employee Benefit Application Detail,Max Benefit Amount,Max Benefit znesek
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for manufacturing,Rezervirano za proizvodnjo
DocType: Soil Texture,Sand,Pesek
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Energy,Energy
DocType: Opportunity,Opportunity From,Priložnost Od
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,"Vrstica {0}: {1} Serijske številke, potrebne za postavko {2}. Dali ste {3}."
apps/erpnext/erpnext/controllers/accounts_controller.py,Cannot set quantity less than delivered quantity,"Količine ni mogoče nastaviti, kot je bila dobavljena količina"
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please select a table,Izberite tabelo
DocType: BOM,Website Specifications,Spletna Specifikacije
apps/erpnext/erpnext/accounts/doctype/account/account.py,Please add the account to root level Company - %s,Dodajte račun v korensko raven Company -% s
DocType: Content Activity,Content Activity,Vsebinska aktivnost
DocType: Special Test Items,Particulars,Podrobnosti
DocType: Employee Checkin,Employee Checkin,Zaposleni Checkin
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0}: From {0} of type {1},{0}: Od {0} tipa {1}
apps/erpnext/erpnext/config/crm.py,Sends Mails to lead or contact based on a Campaign schedule,Pošlje sporočila za vodenje ali vzpostavitev stika na podlagi razporeda akcij
apps/erpnext/erpnext/controllers/selling_controller.py,Row {0}: Conversion Factor is mandatory,Vrstica {0}: Factor Pretvorba je obvezna
DocType: Student,A+,A +
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Več Cena Pravila obstaja z enakimi merili, se rešujejo spore z dodelitvijo prednost. Cena Pravila: {0}"
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation Account,Račun prevrednotenja deviznih tečajev
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Min Amt can not be greater than Max Amt,Min Amt ne more biti večji od Max Amt
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,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
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Please select Company and Posting Date to getting entries,"Prosimo, izberite Podjetje in Datum objave, da vnesete vnose"
DocType: Asset,Maintenance,Vzdrževanje
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Get from Patient Encounter,Pojdite iz srečanja s pacientom
DocType: Subscriber,Subscriber,Naročnik
DocType: Item Attribute Value,Item Attribute Value,Postavka Lastnost Vrednost
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,Currency Exchange must be applicable for Buying or for Selling.,Menjalnica mora veljati za nakup ali prodajo.
apps/erpnext/erpnext/hr/doctype/leave_ledger_entry/leave_ledger_entry.py,Only expired allocation can be cancelled,Prekliče se lahko le dodelitev s potekom veljavnosti
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,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/crm.py,Sales campaigns.,Prodajne akcije.
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Unknown Caller,Neznani klicatelj
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: Quality Action,Corrective,Popravek
DocType: Employee,Bank A/C No.,Bank A / C No.
DocType: Quality Inspection Reading,Reading 7,Branje 7
DocType: Purchase Invoice,UIN Holders,Nosilci UIN
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Ordered,delno Ž
DocType: Lab Test,Lab Test,Lab Test
DocType: Student Report Generation Tool,Student Report Generation Tool,Orodje za generiranje študentskega poročila
DocType: Healthcare Schedule Time Slot,Healthcare Schedule Time Slot,Časovni razpored zdravstvenega varstva
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Name,Doc Name
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/public/js/hub/pages/Item.vue,Save Item,Shrani element
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Expense,Nov strošek
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Ignore Existing Ordered Qty,Prezri obstoječe urejene količine
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Timeslots,Dodaj Timeslots
apps/erpnext/erpnext/stock/__init__.py,Please set Account in Warehouse {0} or Default Inventory Account in Company {1},V računu Warehouse {0} ali Privzetem inventarju nastavite račun v podjetju {1}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset scrapped via Journal Entry {0},Sredstvo izločeni preko Journal Entry {0}
DocType: Loan,Interest Income Account,Prihodki od obresti račun
DocType: Bank Transaction,Unreconciled,Neusklajeno
DocType: Shift Type,Allow check-out after shift end time (in minutes),Dovoli odjavo po končanem času izmene (v minutah)
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Max benefits should be greater than zero to dispense benefits,"Najvišje koristi bi morale biti večje od nič, da bi se izplačale koristi"
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py,Review Invitation Sent,Povabljeni vabilo
DocType: Shift Assignment,Shift Assignment,Shift Assignment
DocType: Employee Transfer Property,Employee Transfer Property,Lastnina za prenos zaposlencev
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field Equity/Liability Account cannot be blank,Polje Lastniški račun / račun obveznosti ne sme biti prazno
apps/erpnext/erpnext/accounts/doctype/cashier_closing/cashier_closing.py,From Time Should Be Less Than To Time,Od časa bi moral biti manj kot čas
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Biotechnology,Biotehnologija
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Item {0} (Serial No: {1}) cannot be consumed as is reserverd\
						 to fullfill Sales Order {2}.","Elementa {0} (serijska številka: {1}) ni mogoče porabiti, kot je to reserverd \, da izpolnite prodajno naročilo {2}."
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Maintenance Expenses,Pisarniška Vzdrževanje Stroški
,BOM Explorer,BOM Explorer
apps/erpnext/erpnext/utilities/user_progress.py,Go to ,Pojdi do
DocType: Shopify Settings,Update Price from Shopify To ERPNext Price List,Posodobitev cene od Shopify na ERPNext Cenik
apps/erpnext/erpnext/config/help.py,Setting up Email Account,Nastavitev e-poštnega računa
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Please enter Item first,"Prosimo, da najprej vnesete artikel"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Needs Analysis,Analiza potreb
DocType: Asset Repair,Downtime,Odmore
DocType: Account,Liability,Odgovornost
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,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,Academic Term: ,Akademski izraz:
DocType: Salary Detail,Do not include in total,Ne vključite v celoti
DocType: Quiz Activity,Quiz Activity,Dejavnost kviza
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,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,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
DocType: Quality Goal,Weekday,Delovni dan
apps/erpnext/erpnext/stock/doctype/item/item.py,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,No Permission,Ne Dovoljenje
DocType: Contract Fulfilment Checklist,Contract Fulfilment Checklist,Kontrolni seznam izpolnjevanja pogodb
DocType: Vital Signs,Heart Rate / Pulse,Srčni utrip / pulz
DocType: Supplier,Default Bank Account,Privzeti bančni račun
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"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,'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/regional/italy/utils.py,Nos,Nos
DocType: Item,Items with higher weightage will be shown higher,Postavke z višjo težo bodo prikazane višje
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py,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,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,No employee found,Najdenih ni delavec
DocType: Supplier Quotation,Stopped,Ustavljen
DocType: Item,If subcontracted to a vendor,Če podizvajanje prodajalca
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Student Group is already updated.,Študent Skupina je že posodobljen.
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Student Group is already updated.,Študent Skupina je že posodobljen.
apps/erpnext/erpnext/config/projects.py,Project Update.,Posodobitev projekta.
DocType: SMS Center,All Customer Contact,Vse Customer Contact
DocType: Location,Tree Details,drevo Podrobnosti
DocType: Marketplace Settings,Registered,Registrirani
DocType: Training Event,Event Status,Status dogodek
DocType: Volunteer,Availability Timeslot,Razpoložljivost Timeslot
apps/erpnext/erpnext/config/support.py,Support Analytics,Podpora Analytics
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,"If you have any questions, please get back to us.","Č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,{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/www/lms/program.py,Program {0} does not exist.,Program {0} ne obstaja.
apps/erpnext/erpnext/utilities/user_progress.py,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,{0} {1}: Account {2} cannot be a Group,{0} {1}: račun {2} ne more biti skupina
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Timesheet {0} is already completed or cancelled,"Timesheet {0}, je že končana ali preklicana"
DocType: QuickBooks Migrator,QuickBooks Migrator,QuickBooks migrator
apps/erpnext/erpnext/templates/pages/projects.html,No tasks,ni opravil
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Sales Invoice {0} created as paid,Prodajni račun {0} je bil ustvarjen kot plačan
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,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/accounting.py,C-Form records,Zapisi C-Form
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shares already exist,Delnice že obstajajo
apps/erpnext/erpnext/config/help.py,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,Thank you for your business!,Hvala za vaš posel!
apps/erpnext/erpnext/config/support.py,Support queries from customers.,Podpora poizvedbe strank.
DocType: Employee Property History,Employee Property History,Zgodovina lastnine zaposlenih
apps/erpnext/erpnext/stock/doctype/item/item.py,Variant Based On cannot be changed,"Variante, ki temelji na, ni mogoče spremeniti"
DocType: Setup Progress Action,Action Doctype,Dejanje Doctype
DocType: HR Settings,Retirement Age,upokojitvena starost
DocType: Bin,Moving Average Rate,Moving Average Rate
DocType: Share Transfer,To Shareholder,Za delničarja
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Bill {1} dated {2},{0} za Račun {1} z dne {2}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From State,Iz države
apps/erpnext/erpnext/utilities/user_progress.py,Setup Institution,Namestitvena ustanova
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Allocating leaves...,Dodeljevanje listov ...
DocType: Program Enrollment,Vehicle/Bus Number,Vozila / Bus številka
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Create New Contact,Ustvari nov stik
apps/erpnext/erpnext/education/doctype/course/course.js,Course Schedule,Razpored za golf
DocType: GSTR 3B Report,GSTR 3B Report,Poročilo GSTR 3B
DocType: Request for Quotation Supplier,Quote Status,Citiraj stanje
DocType: GoCardless Settings,Webhooks Secret,Webhooks Secret
DocType: Maintenance Visit,Completion Status,Zaključek Status
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Total payments amount can't be greater than {},Skupni znesek plačil ne sme biti večji od {}
DocType: Daily Work Summary Group,Select Users,Izberite Uporabniki
DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,Postavka hotelske sobe
DocType: Loyalty Program Collection,Tier Name,Ime razreda
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,Please select a warehouse,Izberite skladišče
DocType: Cheque Print Template,Starting location from left edge,Izhajajoč lokacijo od levega roba
,Territory Target Variance Based On Item Group,Odstopanje glede na ciljno območje glede na skupino izdelkov
DocType: Upload Attendance,Import Attendance,Uvoz Udeležba
apps/erpnext/erpnext/public/js/pos/pos.html,All Item Groups,Vse Postavka Skupine
DocType: Work Order,Item To Manufacture,Postavka za izdelavo
DocType: Leave Control Panel,Employment Type (optional),Vrsta zaposlitve (neobvezno)
DocType: Pricing Rule,Threshold for Suggestion,Prag za predlog
apps/erpnext/erpnext/buying/utils.py,{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/help.py,Purchase Order to Payment,Nakup naročila do plačila
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Projected Qty,Predvidoma Kol
DocType: Sales Invoice,Payment Due Date,Datum zapadlosti
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Reserved Qty: Quantity ordered for sale, but not delivered.","Količina rezervirana: Količina, naročena za prodajo, vendar ni dobavljena."
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/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Subcontract: Raw materials quantity to make subcontracted items.,Količina za naročila podizvajalcev: Količina surovin za izdelavo odvzetih predmetov.
apps/erpnext/erpnext/stock/doctype/item/item.js,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,'Opening',&quot;Odpiranje&quot;
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open To Do,Odpri storiti
DocType: Pricing Rule,Mixed Conditions,Mešani pogoji
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Summary Saved,Povzetek klica je shranjen
DocType: Issue,Via Customer Portal,Preko portala za stranke
DocType: Employee Tax Exemption Proof Submission Detail,Actual Amount,Dejanski znesek
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,SGST Amount,SGST Znesek
DocType: Lab Test Template,Result Format,Format zapisa
DocType: Expense Claim,Expenses,Stroški
DocType: Service Level,Support Hours,podpora ure
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Delivery Notes,Opombe o dostavi
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,Research & Development,Raziskave in razvoj
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py,Amount to Bill,Znesek za Bill
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Based On Payment Terms,Na podlagi plačilnih pogojev
apps/erpnext/erpnext/config/settings.py,ERPNext Settings,Nastavitve ERPNext
DocType: Company,Registration Details,Podrobnosti registracije
apps/erpnext/erpnext/support/doctype/issue/issue.py,Couldn't Set Service Level Agreement {0}.,Dogovora o ravni storitve ni bilo mogoče nastaviti {0}.
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
DocType: Quality Feedback Parameter,Quality Feedback Parameter,Parameter kakovostne povratne informacije
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,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,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: Production Plan Item,"If enabled, system will create the work order for the exploded items against which BOM is available.","Če je omogočeno, bo sistem ustvaril delovni nalog za eksplodirane predmete, proti katerim je BOM na voljo."
DocType: Sales Team,Incentives,Spodbude
DocType: SMS Log,Requested Numbers,Zahtevane številke
DocType: Volunteer,Evening,Večer
DocType: Quiz,Quiz Configuration,Konfiguracija kviza
DocType: Vital Signs,Normal,Normalno
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","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"
DocType: Sales Invoice Item,Stock Details,Stock Podrobnosti
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Value,Project Value
apps/erpnext/erpnext/config/help.py,Point-of-Sale,Prodajno mesto
DocType: Fee Schedule,Fee Creation Status,Status ustvarjanja provizije
apps/erpnext/erpnext/utilities/activation.py,Create Sales Orders to help you plan your work and deliver on-time,"Ustvarite prodajna naročila, ki vam bodo pomagala načrtovati delo in dostaviti pravočasno"
DocType: Vehicle Log,Odometer Reading,Stanje kilometrov
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Stanje na računu je že v ""kredit"", ni dovoljeno nastaviti ""Stanje mora biti"" kot ""bremenitev"""
DocType: Account,Balance must be,Ravnotežju mora biti
,Available Qty,Na voljo Količina
DocType: Shopify Settings,Default Warehouse to to create Sales Order and Delivery Note,Privzeta skladišče za ustvarjanje prodajnega naročila in dostave
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: Amazon MWS Settings,Always synch your products from Amazon MWS before synching the Orders details,Vedno sinhronizirajte svoje izdelke iz Amazon MWS pred sinhronizacijo podrobnosti o naročilih
DocType: Delivery Trip,Delivery Stops,Dobavni izklopi
DocType: Salary Slip,Working Days,Delovni dnevi
apps/erpnext/erpnext/accounts/deferred_revenue.py,Cannot change Service Stop Date for item in row {0},Datum zaustavitve storitve ni mogoče spremeniti za predmet v vrstici {0}
DocType: Serial No,Incoming Rate,Dohodni Rate
DocType: Packing Slip,Gross Weight,Bruto Teža
DocType: Leave Type,Encashment Threshold Days,Dnevi praga obkroževanja
,Final Assessment Grades,Končne ocene
apps/erpnext/erpnext/public/js/setup_wizard.js,The name of your company for which you are setting up this system.,"Ime vašega podjetja, za 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,Setup your Institute in ERPNext,Nastavite svoj inštitut v ERPNext
DocType: Agriculture Analysis Criteria,Plant Analysis,Analiza rastlin
DocType: Task,Timeline,Časovnica
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Hold,Drži
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Alternate Item,Nadomestna postavka
DocType: Shopify Log,Request Data,Zahtevajte podatke
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,Purchase Receipt,Potrdilo o nakupu
,Received Items To Be Billed,Prejete Postavke placevali
DocType: Purchase Invoice,Accounting Dimensions,Računovodske dimenzije
,Subcontracted Raw Materials To Be Transferred,Podpogodbene surovine za prenos
apps/erpnext/erpnext/config/accounting.py,Currency exchange rate master.,Menjalnega tečaja valute gospodar.
,Sales Person Target Variance Based On Item Group,Ciljna odstopanje prodajne osebe na podlagi skupine izdelkov
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,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,Filter Total Zero Qty,Filter Total Zero Qty
DocType: Work Order,Plan material for sub-assemblies,Plan material za sklope
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} must be active,Surovina {0} mora biti aktivna
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,No Items available for transfer,Ni razpoložljivih elementov za prenos
DocType: Employee Boarding Activity,Activity Name,Ime dejavnosti
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Change Release Date,Sprememba datuma izdaje
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Končana količina izdelka <b>{0}</b> in Za količino <b>{1}</b> ne moreta biti drugačna
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Closing (Opening + Total),Zapiranje (odpiranje + skupno)
DocType: Delivery Settings,Dispatch Notification Attachment,Priloga za obvestilo o odpošiljanju
DocType: Payroll Entry,Number Of Employees,Število zaposlenih
DocType: Journal Entry,Depreciation Entry,Amortizacija Začetek
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Please select the document type first,"Prosimo, najprej izberite vrsto dokumenta"
apps/erpnext/erpnext/stock/doctype/item/item.py,You have to enable auto re-order in Stock Settings to maintain re-order levels.,Za vzdrževanje ravni ponovnega naročila morate v nastavitvah zalog omogočiti samodejno ponovno naročilo.
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,Cancel Material Visits {0} before cancelling this Maintenance Visit,Preklic Material Obiski {0} pred preklicem to vzdrževanje obisk
DocType: Pricing Rule,Rate or Discount,Stopnja ali popust
apps/erpnext/erpnext/accounts/doctype/bank/bank_dashboard.py,Bank Details,Bančne podrobnosti
DocType: Vital Signs,One Sided,Enostransko
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Item {1},Serijska št {0} ne pripada postavki {1}
DocType: Purchase Order Item Supplied,Required Qty,Zahtevani Kol
DocType: Marketplace Settings,Custom Data,Podatki po meri
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to ledger.,Skladišča z obstoječim poslom ni mogoče pretvoriti v knjigi.
DocType: Service Day,Service Day,Dan storitve
apps/erpnext/erpnext/projects/doctype/project/project.py,Project Summary for {0},Povzetek projekta za {0}
apps/erpnext/erpnext/hub_node/api.py,Unable to update remote activity,Oddaljene dejavnosti ni mogoče posodobiti
apps/erpnext/erpnext/controllers/buying_controller.py,Serial no is mandatory for the item {0},Serijska številka je obvezna za predmet {0}
DocType: Bank Reconciliation,Total Amount,Skupni znesek
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,From Date and To Date lie in different Fiscal Year,Od Datum in do datuma se nahajajo v drugem fiskalnem letu
apps/erpnext/erpnext/healthcare/utils.py,The Patient {0} do not have customer refrence to invoice,Pacient {0} nima potrdila stranke za račun
DocType: Quality Feedback Template,Quality Feedback Template,Predloga za povratne informacije o kakovosti
apps/erpnext/erpnext/config/education.py,LMS Activity,LMS dejavnost
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Internet Publishing,Internet Založništvo
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Creating {0} Invoice,Ustvarjanje računa {0}
DocType: Medical Code,Medical Code Standard,Standard medicinske oznake
DocType: Soil Texture,Clay Composition (%),Glina Sestava (%)
DocType: Item Group,Item Group Defaults,Privzete nastavitve skupine elementov
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Please save before assigning task.,"Prosimo, shranite, preden dodelite nalogo."
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Balance Value,Balance Vrednost
DocType: Lab Test,Lab Technician,Laboratorijski tehnik
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,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."
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,Customer isn't enrolled in any Loyalty Program,Stranka ni vpisana v program zvestobe
DocType: Bank Reconciliation,Account Currency,Valuta računa
DocType: Lab Test,Sample ID,Vzorec ID
apps/erpnext/erpnext/accounts/general_ledger.py,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,Employee {0} is not active or does not exist,Employee {0} ni aktiven ali pa ne obstaja
DocType: Fee Structure,Components,komponente
DocType: Support Search Source,Search Term Param Name,Ime izraza Param za iskanje
DocType: Item Barcode,Item Barcode,Postavka Barcode
DocType: Delivery Trip,In Transit,V tranzitu
DocType: Woocommerce Settings,Endpoints,Končne točke
DocType: Shopping Cart Settings,Show Configure Button,Pokaži gumb Konfiguriraj
DocType: Quality Inspection Reading,Reading 6,Branje 6
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,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
DocType: Shift Type,Every Valid Check-in and Check-out,Vsaka veljavna prijava in odjava
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,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/accounting.py,Define budget for a financial year.,Določite proračuna za proračunsko leto.
DocType: Shopify Tax Account,ERPNext Account,ERPNext račun
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.py,Provide the academic year and set the starting and ending date.,Navedite študijsko leto in določite datum začetka in konca.
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} is blocked so this transaction cannot proceed,"{0} je blokiran, da se ta transakcija ne more nadaljevati"
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on MR,"Ukrep, če je skupni mesečni proračun presegel MR"
DocType: Employee,Permanent Address Is,Stalni naslov je
DocType: Work Order Operation,Operation completed for how many finished goods?,"Operacija zaključena, za koliko končnih izdelkov?"
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Healthcare Practitioner {0} not available on {1},Zdravstveni delavec {0} ni na voljo na {1}
DocType: Payment Terms Template,Payment Terms Template,Predloga za plačilni pogoji
apps/erpnext/erpnext/public/js/setup_wizard.js,The Brand,Brand
DocType: Employee Tax Exemption Proof Submission,Rented To Date,Oddano do datuma
DocType: Manufacturing Settings,Allow Multiple Material Consumption,Dovoli večkratno porabo materiala
DocType: Employee,Exit Interview Details,Exit Intervju Podrobnosti
DocType: Item,Is Purchase Item,Je Nakup Postavka
DocType: Bank Statement Transaction Invoice Item,Purchase Invoice,Nakup Račun
DocType: Manufacturing Settings,Allow multiple Material Consumption against a Work Order,Dovoli večkratni porabi materiala z delovnim nalogom
DocType: GL Entry,Voucher Detail No,Bon Detail Ne
DocType: Email Digest,New Sales Invoice,Nov račun
DocType: Stock Entry,Total Outgoing Value,Skupaj Odhodni Vrednost
DocType: Healthcare Practitioner,Appointments,Imenovanja
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,Action Initialised,Ukrep je sprožen
apps/erpnext/erpnext/public/js/account_tree_grid.js,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
DocType: Course Activity,Activity Date,Datum aktivnosti
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,{} of {},{} od {}
DocType: Sales Invoice Item,Rate With Margin (Company Currency),Stopnja z maržo (valuta podjetja)
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Categories,Kategorije
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Offline Invoices,Sinhronizacija Offline Računi
DocType: Payment Request,Paid,Plačan
DocType: Service Level,Default Priority,Privzeta prioriteta
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: Employee Skill Map,Employee Skill Map,Zemljevid spretnosti zaposlenih
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,The following Work Orders were created:,Ustvarjene so bile naslednje delovne naloge:
DocType: Salary Slip,Total in words,Skupaj z besedami
DocType: Inpatient Record,Discharged,Razrešeno
DocType: Material Request Item,Lead Time Date,Lead Time Datum
,Employee Advance Summary,Povzetek zaposlenih
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: Support Settings,Get Started Sections,Začnite razdelke
DocType: Lead,CRM-LEAD-.YYYY.-,CRM-LEAD-.YYYY.-
DocType: Invoice Discounting,Sanctioned,sankcionirano
,Base Amount,Osnovni znesek
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js,Total Contribution Amount: {0},Skupni znesek prispevka: {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row #{0}: Please specify Serial No for Item {1},Vrstica # {0}: Navedite Zaporedna številka za postavko {1}
DocType: Payroll Entry,Salary Slips Submitted,Poslane plačljive plače
DocType: Crop Cycle,Crop Cycle,Crop Crop
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Za &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: Amazon MWS Settings,BR,BR
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Place,Od kraja
DocType: Student Admission,Publish on website,Objavi na spletni strani
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice Date cannot be greater than Posting Date,Datum dobavitelj na računu ne sme biti večja od Napotitev Datum
DocType: Installation Note,MAT-INS-.YYYY.-,MAT-INS-.LLLL.-
DocType: Subscription,Cancelation Date,Datum preklica
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_with_account_number.py,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: Pick List Item,Picked Qty,Izbrana količina
DocType: Cheque Print Template,Date Settings,Datum Nastavitve
apps/erpnext/erpnext/education/doctype/question/question.py,A question must have more than one options,Vprašanje mora imeti več možnosti
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Variance,Variance
DocType: Employee Promotion,Employee Promotion Detail,Podrobnosti o napredovanju zaposlenih
DocType: SMS Center,Total Message(s),Skupaj sporočil (-i)
DocType: Share Balance,Purchased,Nakup
DocType: Item Variant Settings,Rename Attribute Value in Item Attribute.,Preimenuj atribut vrednosti atributa elementa.
DocType: Purchase Invoice,Additional Discount Percentage,Dodatni popust Odstotek
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,View a list of all the help videos,Oglejte si seznam vseh videoposnetkov 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/education/doctype/student_report_generation_tool/student_report_generation_tool.js,Print Report Card,Kartica za tiskanje poročila
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,"Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \
						Please enter a valid Invoice","Vrstica {0}: Račun {1} ni veljavna, se lahko prekliče / ne obstaja. \ Vnesite veljaven račun"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Vrstica {0}: morala Plačilo proti prodaja / narocilo vedno označen kot vnaprej
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,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: Quiz,Latest Attempt,Najnovejši poskus
DocType: Quiz Result,Quiz Result,Rezultat kviza
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total leaves allocated is mandatory for Leave Type {0},Skupni dodeljeni listi so obvezni za tip zapustitve {0}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Rate cannot be greater than the rate used in {1} {2},"Vrstica # {0}: stopnja ne more biti večji od stopnje, ki se uporablja pri {1} {2}"
apps/erpnext/erpnext/utilities/user_progress.py,Meter,meter
DocType: Workstation,Electricity Cost,Stroški električne energije
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab testing datetime cannot be before collection datetime,Testiranje datotečnega laboratorija ne more biti pred zbiranjem datetime
DocType: Subscription Plan,Cost,Cena
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/templates/pages/help.html,See All Articles,Oglejte si vse članke
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Walk In,Vstopiti
DocType: Item,Inspection Criteria,Merila pregleda
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Transfered,Prenese
DocType: BOM Website Item,BOM Website Item,BOM Spletna stran Element
apps/erpnext/erpnext/public/js/setup_wizard.js,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/setup/setup_wizard/operations/install_fixtures.py,White,Bela
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid Company for Inter Company Transaction.,Neveljavno podjetje za transakcije med podjetji.
DocType: SMS Center,All Lead (Open),Vse ponudbe (Odprte)
apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py,You can only select a maximum of one option from the list of check boxes.,Iz seznama potrditvenih polj lahko izberete največ eno možnost.
DocType: 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
DocType: Woocommerce Settings,"The user that will be used to create Customers, Items and Sales Orders. This user should have the relevant permissions.","Uporabnik, ki bo uporabljen za ustvarjanje kupcev, izdelkov in prodajnih naročil. Ta uporabnik mora imeti ustrezna dovoljenja."
DocType: Supplier,Represents Company,Predstavlja podjetje
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,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,New Employee,Novi zaposleni
apps/erpnext/erpnext/controllers/selling_controller.py,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,Opening Qty,Odpiranje Količina
DocType: Healthcare Settings,Appointment Reminder,Opomnik o imenovanju
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,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: Holiday List,Holiday List Name,Naziv seznama praznikov
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Uvoz elementov in UOM-ov
DocType: Repayment Schedule,Balance Loan Amount,Bilanca Znesek posojila
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Dodano v podrobnosti
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Oprostite, koda kupona je izčrpana"
DocType: Communication Medium,Catch All,Ujemite vse
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,urnik predmeta
DocType: Budget,Applicable on Material Request,Velja za materialno zahtevo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Stock Options,Delniških opcij
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,No Items added to cart,Noben predmet ni dodan v košarico
DocType: Journal Entry Account,Expense Claim,Expense zahtevek
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Do you really want to restore this scrapped asset?,Ali res želite obnoviti ta izločeni sredstva?
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Qty for {0},Količina za {0}
DocType: Attendance,Leave Application,Zapusti Application
DocType: Patient,Patient Relation,Pacientovo razmerje
DocType: Item,Hub Category to Publish,Kategorija vozlišča za objavo
DocType: Leave Block List,Leave Block List Dates,Pustite Block List termini
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Sales Order {0} has reservation for item {1}, you can
		only deliver reserved {1} against {0}. Serial No {2} cannot
		be delivered","Naročilo za prodajo {0} ima rezervacijo za predmet {1}, lahko dostavite samo rezervirano {1} z {0}. Serijska št. {2} ni mogoče dostaviti"
DocType: Sales Invoice,Billing Address GSTIN,Naslov za izstavitev računa GSTIN
DocType: Homepage,Hero Section Based On,Oddelek za heroje
DocType: Employee Tax Exemption Proof Submission,Total Eligible HRA Exemption,Skupna upravičena oprostitev HRA
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! A GSTIN must have 15 characters.,Neveljaven GSTIN! GSTIN mora imeti 15 znakov.
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: 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
DocType: Travel Itinerary,Train,Vlak
,Delayed Item Report,Poročilo o zakasnjeni postavki
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Eligible ITC,Upravičeni ITC
DocType: Healthcare Service Unit,Inpatient Occupancy,Bolnišnično zasedbo
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,Publish Your First Items,Objavite svoje prve izdelke
DocType: Sample Collection,HLC-SC-.YYYY.-,HLC-SC-.YYYY.-
DocType: Shift Type,Time after the end of shift during which check-out is considered for attendance.,"Čas po koncu izmene, med katero se šteje odjava za udeležbo."
apps/erpnext/erpnext/public/js/queries.js,Please specify a {0},Navedite {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,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,Variant creation has been queued.,Ustvarjanje variant je bilo v čakalni vrsti.
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,Work Summary for {0},Povzetek dela za {0}
DocType: Department,The first Leave Approver in the list will be set as the default Leave Approver.,Prvi dovolnik za dovoljenje na seznamu bo nastavljen kot privzeti odobritveni odjemalec.
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute table is mandatory,Lastnost miza je obvezna
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Delayed Days,Zakasnjeni dnevi
DocType: Production Plan,Get Sales Orders,Pridobite prodajnih nalogov
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} can not be negative,{0} ne more biti negativna
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Connect to Quickbooks,Povežite se s Quickbooks
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Clear values,Jasne vrednosti
DocType: Training Event,Self-Study,Samo-študija
DocType: POS Closing Voucher,Period End Date,Datum konca obdobja
apps/erpnext/erpnext/regional/india/utils.py,Transport Receipt No and Date are mandatory for your chosen Mode of Transport,Številka in datum prevoza sta za izbrani način prevoza obvezna
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py,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,Discount,Popust
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Row {0}: {1} is required to create the Opening {2} Invoices,Vrstica {0}: {1} je potrebna za ustvarjanje odpiranja {2} računov
DocType: Membership,Membership,Članstvo
DocType: Asset,Total Number of Depreciations,Skupno število amortizacije
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Debit A/C Number,Številka A / C
DocType: Sales Invoice Item,Rate With Margin,Oceni z mejo
DocType: Sales Invoice Item,Rate With Margin,Oceni z mejo
DocType: Purchase Invoice,Is Return (Debit Note),Je povračilo (obvestilo o obremenitvi)
DocType: Workstation,Wages,Plače
DocType: Asset Maintenance,Maintenance Manager Name,Ime upravitelja vzdrževanja
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Transactions against the company already exist! ,Transakcije s podjetjem že obstajajo!
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requesting Site,"Spletno mesto, ki zaprosi"
DocType: Agriculture Task,Urgent,Nujna
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Fetching records......,Pridobivanje zapisov ......
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,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,Unable to find variable: ,Ni mogoče najti spremenljivke:
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select a field to edit from numpad,Izberite polje za urejanje iz numpad
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot be a fixed asset item as Stock Ledger is created.,"Ne more biti postavka osnovnega sredstva, kot je ustvarjena knjiga zalog."
DocType: Subscription Plan,Fixed rate,Fiksna stopnja
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.js,Admit,Priznaj
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Go to the Desktop and start using ERPNext,Pojdite na namizje in začeti uporabljati ERPNext
apps/erpnext/erpnext/templates/pages/order.js,Pay Remaining,Plačajte preostale
DocType: Purchase Invoice Item,Manufacturer,Proizvajalec
DocType: Landed Cost Item,Purchase Receipt Item,Potrdilo o nakupu Postavka
DocType: Leave Allocation,Total Leaves Encashed,Skupaj na listi
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: Project,First Email,Prva e-pošta
DocType: Company,Exception Budget Approver Role,Izvršilna vloga za odobritev proračuna
DocType: Purchase Invoice,"Once set, this invoice will be on hold till the set date","Ko je nastavljen, bo ta račun zadržan do določenega datuma"
DocType: Cashier Closing,POS-CLO-,POS-CLO-
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Selling Amount,Prodajni Znesek
DocType: Repayment Schedule,Interest Amount,Obresti Znesek
DocType: Job Card,Time Logs,Čas Dnevniki
DocType: Sales Invoice,Loyalty Amount,Znesek zvestobe
DocType: Employee Transfer,Employee Transfer Detail,Podrobnosti o prenosu zaposlencev
DocType: Serial No,Creation Document No,Za ustvarjanje dokumentov ni
DocType: Location,Location Details,Podrobnosti o lokaciji
DocType: Share Transfer,Issue,Težava
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter_dashboard.py,Records,Zapisi
DocType: Asset,Scrapped,izločeni
DocType: Item,Item Defaults,Privzeta postavka
DocType: Cashier Closing,Returns,Vračila
DocType: Job Card,WIP Warehouse,WIP Skladišče
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,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,Recruitment,zaposlovanje
DocType: Lead,Organization Name,Organization Name
DocType: Support Settings,Show Latest Forum Posts,Pokaži zadnje objave foruma
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,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,Delivery Trip,Dostava potovanje
DocType: Student,A-,A-
DocType: Share Transfer,Transfer Type,Vrsta prenosa
DocType: Pricing Rule,Quantity and Amount,Količina in količina
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Sales Expenses,Prodajna Stroški
DocType: Diagnosis,Diagnosis,Diagnoza
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Buying,Standardna nabavna
DocType: Attendance Request,Explanation,Pojasnilo
DocType: GL Entry,Against,Proti
DocType: Item Default,Sales Defaults,Privzete prodaje
DocType: Sales Order Item,Work Order Qty,Količina naročila dela
DocType: Item Default,Default Selling Cost Center,Privzet stroškovni center prodaje
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Disc,Disc
DocType: Buying Settings,Material Transferred for Subcontract,Preneseni material za podizvajalsko pogodbo
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Date,Datum naročila
DocType: Email Digest,Purchase Orders Items Overdue,Postavke nakupnih naročil so prepozne
apps/erpnext/erpnext/accounts/page/pos/pos.js,ZIP Code,Poštna številka
apps/erpnext/erpnext/controllers/selling_controller.py,Sales Order {0} is {1},Naročilo {0} je {1}
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Select interest income account in loan {0},Izberite račun obrestnih prihodkov v posojilu {0}
DocType: Opportunity,Contact Info,Kontaktni podatki
apps/erpnext/erpnext/config/help.py,Making Stock Entries,Izdelava vnosov Zalog
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Cannot promote Employee with status Left,Zaposlenca s statusom Levo ni mogoče spodbujati
DocType: Packing Slip,Net Weight UOM,Neto teža UOM
DocType: Item Default,Default Supplier,Privzeto Dobavitelj
DocType: Loan,Repayment Schedule,Povračilo Urnik
DocType: Shipping Rule Condition,Shipping Rule Condition,Pogoj dostavnega pravila
apps/erpnext/erpnext/hr/doctype/payroll_period/payroll_period.py,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,Invoice can't be made for zero billing hour,Račun ni mogoče naročiti za ničelno uro zaračunavanja
DocType: Company,Date of Commencement,Datum začetka
DocType: Sales Person,Select company name first.,Izberite ime podjetja prvič.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Email sent to {0},E-pošta je poslana na {0}
apps/erpnext/erpnext/config/buying.py,Quotations received from Suppliers.,Prejete ponudbe
DocType: Quality Goal,January-April-July-October,Januar-april-julij-oktober
apps/erpnext/erpnext/config/manufacturing.py,Replace BOM and update latest price in all BOMs,Zamenjajte BOM in posodobite najnovejšo ceno v vseh BOM
apps/erpnext/erpnext/controllers/selling_controller.py,To {0} | {1} {2},Za {0} | {1} {2}
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js,This is a root supplier group and cannot be edited.,To je skupna skupina dobaviteljev in je ni mogoče urejati.
DocType: Sales Invoice,Driver Name,Ime voznika
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,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
DocType: Payment Request,Inward,V notranjost
apps/erpnext/erpnext/utilities/user_progress.py,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.
DocType: Accounting Dimension,Dimension Defaults,Privzete dimenzije
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Minimum Lead Age (Days),Minimalna Svinec Starost (dnevi)
apps/erpnext/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py,Available For Use Date,Na voljo za uporabo
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,All BOMs,Vse BOMs
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Create Inter Company Journal Entry,Ustvari vpis v revijo Inter Company
DocType: Company,Parent Company,Matična družba
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Hotel Rooms of type {0} are unavailable on {1},Sobe Hotela tipa {0} niso na voljo na {1}
apps/erpnext/erpnext/config/manufacturing.py,Compare BOMs for changes in Raw Materials and Operations,Primerjajte BOM za spremembe v surovinah in postopkih
apps/erpnext/erpnext/accounts/doctype/bank_transaction/bank_transaction.js,Document {0} successfully uncleared,Dokument {0} uspešno izbrisan
DocType: Healthcare Practitioner,Default Currency,Privzeta valuta
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Reconcile this account,Poravnajte ta račun
apps/erpnext/erpnext/controllers/selling_controller.py,Maximum discount for Item {0} is {1}%,Najvišji popust za postavko {0} je {1}%
DocType: Chart of Accounts Importer,Attach custom Chart of Accounts file,Priložite datoteko računa računa po meri
DocType: Asset Movement,From Employee,Od zaposlenega
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of services,Uvoz storitev
DocType: Driver,Cellphone Number,številka mobilnega telefona
DocType: Project,Monitor Progress,Spremljajte napredek
DocType: Pricing Rule Item Code,Pricing Rule Item Code,Koda predmeta pravila o cenah
apps/erpnext/erpnext/controllers/accounts_controller.py,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Opozorilo: Sistem ne bo preveril previsokih saj znesek za postavko {0} v {1} je nič
DocType: Journal Entry,Make Difference Entry,Naredite vnos Razlike
DocType: Supplier Quotation,Auto Repeat Section,Samodejni del ponovitve
DocType: Service Level Priority,Response Time,Odzivni čas
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,Invalid Attribute,Neveljavna Lastnost
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} je potrebno vložiti
apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,E-poštne oglaševalske akcije
DocType: Sales Partner,To Track inbound purchase,Sledenje vhodnemu nakupu
DocType: Buying Settings,Default Supplier Group,Privzeta dobaviteljska skupina
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Količina mora biti manjša ali enaka {0}
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Najvišji znesek primernega za sestavino {0} presega {1}
DocType: Department Approver,Department Approver,Odobreni oddelek
DocType: QuickBooks Migrator,Application Settings,Nastavitve aplikacije
DocType: SMS Center,Total Characters,Skupaj Znaki
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Creating Company and Importing Chart of Accounts,Ustvarjanje podjetja in uvoz računa
DocType: Employee Advance,Claimed,Zahtevana
DocType: Crop,Row Spacing,Razmik vrstic
apps/erpnext/erpnext/controllers/buying_controller.py,Please select BOM in BOM field for Item {0},"Prosimo, izberite BOM BOM v polju za postavko {0}"
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,There isn't any item variant for the selected item,Za izbrani predmet ni nobene postavke
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
DocType: Clinical Procedure,Procedure Template,Predloga postopka
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Publish Items,Objavite predmete
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution %,Prispevek%
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","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}"
,HSN-wise-summary of outward supplies,HSN-modri povzetek zunanjih dobav
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Registracijska št. podjetja za lastno evidenco. Davčna številka itn.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To State,Trditi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Distributor,Distributer
DocType: Asset Finance Book,Asset Finance Book,Knjiga o premoženju
DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Pravilo za dostavo za košaro
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.py,Please setup a default bank account for company {0},Nastavite privzeti bančni račun za podjetje {0}
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set 'Apply Additional Discount On',Prosim nastavite &quot;Uporabi dodatni popust na &#39;
DocType: Party Tax Withholding Config,Applicable Percent,Veljaven odstotek
,Ordered Items To Be Billed,Naročeno Postavke placevali
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,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,Project Collaboration Invitation,Projekt Sodelovanje Vabilo
DocType: Salary Slip,Deductions,Odbitki
DocType: Setup Progress Action,Action Name,Ime dejanja
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Start Year,Začetek Leto
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.js,Create Loan,Ustvari posojilo
DocType: Purchase Invoice,Start date of current invoice's period,Datum začetka obdobja sedanje faktura je
DocType: Shift Type,Process Attendance After,Obiskanost procesa po
,IRS 1099,IRS 1099
DocType: Salary Slip,Leave Without Pay,Leave brez plačila
DocType: Payment Request,Outward,Zunaj
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On {0} Creation,Ob {0} Ustvarjanje
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,State/UT Tax,Državni / davek na UT
,Trial Balance for Party,Trial Balance za stranke
,Gross and Net Profit Report,Poročilo o bruto in neto dobičku
apps/erpnext/erpnext/config/quality_management.py,Tree of Procedures,Drevo postopkov
DocType: Lead,Consultant,Svetovalec
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Parents Teacher Meeting Attendance,Udeležba učiteljev na srečanju staršev
DocType: Salary Slip,Earnings,Zaslužek
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,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/help.py,Opening Accounting Balance,Začetna bilanca
,GST Sales Register,DDV prodaje Registracija
DocType: Sales Invoice Advance,Sales Invoice Advance,Predplačila
apps/erpnext/erpnext/public/js/setup_wizard.js,Select your Domains,Izberite svoje domene
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/sync_product.py,Shopify Supplier,Shopify Dobavitelj
DocType: Bank Statement Transaction Entry,Payment Invoice Items,Točke plačilne fakture
DocType: Payroll Entry,Employee Details,Podrobnosti o zaposlenih
DocType: Amazon MWS Settings,CN,CN
DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Polja bodo kopirana samo v času ustvarjanja.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Row {0}: asset is required for item {1},Vrstica {0}: za postavko {1} je potrebno sredstvo
apps/erpnext/erpnext/projects/doctype/task/task.py,'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,Management,Vodstvo
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.js,Show {0},Prikaži {0}
DocType: Cheque Print Template,Payer Settings,Nastavitve plačnik
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,No pending Material Requests found to link for the given items.,"Nobenih čakajočih materialnih zahtevkov, za katere je bilo ugotovljeno, da so povezani za določene predmete."
apps/erpnext/erpnext/public/js/utils/party.js,Select company first,Najprej izberite podjetje
apps/erpnext/erpnext/accounts/general_ledger.py,Account: <b>{0}</b> is capital Work in progress and can not be updated by Journal Entry,Račun: <b>{0}</b> je kapital Delo v teku in ga vnos v časopis ne more posodobiti
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Compare List function takes on list arguments,Funkcija Primerjanje seznama prevzame argumente seznama
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: Delivery Note,Is Return,Je Return
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Caution,Previdno
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Import Successful,Uvoz uspešen
apps/erpnext/erpnext/config/quality_management.py,Goal and Procedure,Cilj in postopek
apps/erpnext/erpnext/agriculture/doctype/disease/disease.py,Start day is greater than end day in task '{0}',Začetni dan je večji od končnega dne pri nalogi &#39;{0}&#39;
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Return / Debit Note,Nazaj / opominu
DocType: Price List Country,Price List Country,Cenik Država
DocType: Sales Invoice,Set Source Warehouse,Nastavite Source Warehouse
DocType: Tally Migration,UOMs,UOMs
DocType: Account Subtype,Account Subtype,Podtip računa
apps/erpnext/erpnext/stock/utils.py,{0} valid serial nos for Item {1},{0} veljavna serijska številka za postavko {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,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/healthcare/doctype/clinical_procedure/clinical_procedure.js,Please enter Item Code to get Batch Number,Vnesite Koda priti Serija Število
DocType: Loyalty Point Entry,Loyalty Point Entry,Vnos točke zvestobe
DocType: Employee Checkin,Shift End,Shift End
DocType: Stock Settings,Default Item Group,Privzeto Element Group
DocType: Job Card Time Log,Time In Mins,Čas v minutah
apps/erpnext/erpnext/config/non_profit.py,Grant information.,Informacije o donaciji.
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.js,This action will unlink this account from any external service integrating ERPNext with your bank accounts. It cannot be undone. Are you certain ?,"S tem dejanjem boste povezali ta račun s katero koli zunanjo storitvijo, ki povezuje ERPNext z vašimi bančnimi računi. Ni mogoče razveljaviti. Ste prepričani?"
apps/erpnext/erpnext/config/buying.py,Supplier database.,Dobavitelj baze podatkov.
DocType: Contract Template,Contract Terms and Conditions,Pogoji pogodbe
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,You cannot restart a Subscription that is not cancelled.,"Naročnino, ki ni preklican, ne morete znova zagnati."
DocType: Account,Balance Sheet,Bilanca stanja
DocType: Leave Type,Is Earned Leave,Je zasluženo zapustiti
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount,Znesek naročila
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Cost Center For Item with Item Code ',Stalo Center za postavko s točko zakonika &quot;
DocType: Fee Validity,Valid Till,Veljavno do
DocType: Student Report Generation Tool,Total Parents Teacher Meeting,Skupaj učiteljski sestanek staršev
apps/erpnext/erpnext/accounts/page/pos/pos.js,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Način plačila ni nastavljen. Prosimo, preverite, ali je bil račun nastavljen na načinu plačila ali na POS profil."
apps/erpnext/erpnext/buying/utils.py,Same item cannot be entered multiple times.,Isti element ni mogoče vnesti večkrat.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Further accounts can be made under Groups, but entries can be made against non-Groups","Nadaljnje računi se lahko izvede v skupinah, vendar vnosi lahko zoper niso skupin"
DocType: Call Log,Lead,Ponudba
DocType: Email Digest,Payables,Obveznosti
DocType: Amazon MWS Settings,MWS Auth Token,MWS Auth Token
DocType: Email Campaign,Email Campaign For ,E-poštna akcija za
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Entry {0} created,Stock Začetek {0} ustvaril
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,You don't have enought Loyalty Points to redeem,Za unovčevanje niste prejeli točk za zvestobo
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py,Please set associated account in Tax Withholding Category {0} against Company {1},"Prosimo, nastavite povezani račun v Kategorija davčne zavrnitve {0} proti podjetju {1}"
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Qty can not be entered in Purchase Return,Vrstica # {0}: Zavrnjena Kol ne more biti vpisana v Nabava Nazaj
apps/erpnext/erpnext/stock/doctype/item/item.js,Changing Customer Group for the selected Customer is not allowed.,Spreminjanje skupine strank za izbrano stranko ni dovoljeno.
,Purchase Order Items To Be Billed,Naročilnica Postavke placevali
DocType: Program Enrollment Tool,Enrollment Details,Podrobnosti o vpisu
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot set multiple Item Defaults for a company.,Ne morete nastaviti več privzetih postavk za podjetje.
DocType: Customer Group,Credit Limits,Kreditne omejitve
DocType: Purchase Invoice Item,Net Rate,Net Rate
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select a customer,Izberite kupca
DocType: Leave Policy,Leave Allocations,Pustite dodelitve
DocType: Job Card,Started Time,Začeti čas
DocType: Purchase Invoice Item,Purchase Invoice Item,Nakup računa item
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Zaloga Glavna knjiga Prijave in GL Vnosi se oglaša za izbrane Nakup Prejemki
DocType: Student Report Generation Tool,Assessment Terms,Pogoji ocenjevanja
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 1,Postavka 1
DocType: Holiday,Holiday,Prazniki
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Leave Type is madatory,Leave Type je premišljen
DocType: Support Settings,Close Issue After Days,Zapri Težava Po dnevih
,Eway Bill,Eway Bill
apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,"Če želite dodati uporabnike v Marketplace, morate biti uporabnik z vlogami upravitelja sistema in upravitelja elementov."
DocType: Attendance,Early Exit,Zgodnji izhod
DocType: Job Opening,Staffing Plan,Načrt zaposlovanja
apps/erpnext/erpnext/accounts/doctype/sales_invoice/regional/india_list.js,e-Way Bill JSON can only be generated from a submitted document,e-Way Bill JSON lahko ustvarite samo iz predloženega dokumenta
apps/erpnext/erpnext/config/hr.py,Employee Tax and Benefits,Davek na zaposlene in ugodnosti
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,C-form is not applicable for Invoice: {0},C-oblika ne velja za računa: {0}
DocType: Certified Consultant,Name of Consultant,Ime svetovalca
DocType: Payment Reconciliation,Unreconciled Payment Details,Unreconciled Plačilni Podrobnosti
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Member Activity,Članska dejavnost
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Count,Da bi Štetje
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Count,Da bi Štetje
DocType: Global Defaults,Current Fiscal Year,Tekočem proračunskem letu
DocType: Purchase Invoice,Group same items,Skupina Iste vsebine
DocType: Purchase Invoice,Disable Rounded Total,Onemogoči zaokroževanje
DocType: Marketplace Settings,Sync in Progress,Sinhronizacija v toku
DocType: Department,Parent Department,Oddelek za starše
DocType: Loan Application,Repayment Info,Povračilo Info
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,'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,Duplicate row {0} with same {1},Dvojnik vrstica {0} z enako {1}
DocType: Marketplace Settings,Disable Marketplace,Onemogoči trg
DocType: Quality Meeting,Minutes,Minute
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Your Featured Items,Vaši predstavljeni predmeti
,Trial Balance,Trial Balance
apps/erpnext/erpnext/templates/pages/projects.js,Show Completed,Prikaži končano
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Fiscal Year {0} not found,Poslovno leto {0} ni bilo mogoče najti
apps/erpnext/erpnext/config/help.py,Setting up Employees,Postavitev Zaposleni
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Naredite vnos zalog
DocType: Hotel Room Reservation,Hotel Reservation User,Uporabnik rezervacije hotela
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Nastavi stanje
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,"Prosimo, izberite predpono najprej"
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,"Prosimo, nastavite Naming Series za {0} z nastavitvijo&gt; Settings&gt; Naming Series"
DocType: Contract,Fulfilment Deadline,Rok izpolnjevanja
apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Blizu vas
DocType: Student,O-,O-
DocType: Subscription Settings,Subscription Settings,Nastavitve naročnine
DocType: Purchase Invoice,Update Auto Repeat Reference,Posodobi samodejno ponavljanje referenc
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Optional Holiday List not set for leave period {0},Neobvezni seznam počitnic ni določen za obdobje dopusta {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Research,Raziskave
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 2,Na naslov 2
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0}: From time must be less than to time,Vrstica {0}: Od časa mora biti manj časa
DocType: Maintenance Visit Purpose,Work Done,Delo končano
apps/erpnext/erpnext/controllers/item_variant.py,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,Item {0} must be a non-stock item,"Točka {0} mora biti postavka, non-stock"
apps/erpnext/erpnext/stock/doctype/batch/batch.js,View Ledger,Ogled Ledger
DocType: Cost Center,Lft,LFT
DocType: Grading Scale,Intervals,intervali
DocType: Bank Statement Transaction Entry,Reconciled Transactions,Usklajene transakcije
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Earliest,Najzgodnejša
DocType: Crop Cycle,Linked Location,Povezana lokacija
apps/erpnext/erpnext/stock/doctype/item/item.py,"An Item Group exists with same name, please change the item name or rename the item group","Element, skupina obstaja z istim imenom, vas prosimo, spremenite ime elementa ali preimenovati skupino element"
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invocies,Pridobite račune
DocType: Designation,Skills,Spretnosti
DocType: Crop Cycle,Less than a year,Manj kot eno leto
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Student Mobile No.,Študent Mobile No.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Rest Of The World,Ostali svet
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,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/accounts/doctype/sales_invoice/sales_invoice.js,Get Items from Healthcare Services,Pridobite predmete iz zdravstvenih storitev
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,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_with_account_number.py,Dividends Paid,Plačane dividende
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Accounting Ledger,Računovodstvo Ledger
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Difference Amount,Razlika Znesek
DocType: Purchase Invoice,Reverse Charge,Povratna obremenitev
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Retained Earnings,Preneseni čisti poslovni izid
DocType: Job Card,Timing Detail,Časovno podrobnost
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,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,Please set an active menu for Restaurant {0},"Prosimo, nastavite aktivni meni za restavracijo {0}"
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Commission Rate %,Stopnja Komisije%
DocType: Woocommerce Settings,"This warehouse will be used to create Sale Orders. The fallback warehouse is ""Stores"".",To skladišče bo uporabljeno za ustvarjanje prodajnih naročil. Rezervno skladišče so &quot;Trgovine&quot;.
DocType: Work Order,Qty To Manufacture,Količina za izdelavo
DocType: Email Digest,New Income,Novi prihodki
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Open Lead,Odprto vodi
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Ohraniti enako stopnjo skozi celotni cikel nabave
DocType: Opportunity Item,Opportunity Item,Priložnost Postavka
DocType: Quality Action,Quality Review,Pregled kakovosti
,Student and Guardian Contact Details,Študent in Guardian Kontaktni podatki
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge Account,Združite račun
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Row {0}: For supplier {0} Email Address is required to send email,Vrstica {0}: Za dobavitelja je potrebno {0} e-poštni naslov za pošiljanje e-pošte
DocType: Shift Type,Attendance will be marked automatically only after this date.,Udeležba bo označena samodejno šele po tem datumu.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Opening,Začasna Otvoritev
,Employee Leave Balance,Zaposleni Leave Balance
apps/erpnext/erpnext/quality_management/doctype/quality_procedure/quality_procedure_tree.js,New Quality Procedure,Nov postopek kakovosti
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Balance for Account {0} must always be {1},"Saldo račun {0}, morajo biti vedno {1}"
DocType: Patient Appointment,More Info,Več informacij
DocType: Supplier Scorecard,Scorecard Actions,Akcije kazalnikov
apps/erpnext/erpnext/utilities/user_progress.py,Example: Masters in Computer Science,Primer: Masters v računalništvu
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,Supplier {0} not found in {1},Dobavitelj {0} ni bil najden v {1}
DocType: Purchase Invoice,Rejected Warehouse,Zavrnjeno Skladišče
DocType: GL Entry,Against Voucher,Proti Voucher
DocType: Item Default,Default Buying Cost Center,Privzet stroškovni center za nabavo
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Payment,Novo plačilo
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Da bi dobili najboljše iz ERPNext, vam priporočamo, da si vzamete nekaj časa in gledam te posnetke pomoč."
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,For Default Supplier (optional),Za privzeto dobavitelja (neobvezno)
DocType: Supplier Quotation Item,Lead Time in days,Lead time v dnevih
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Target ({}),Cilj ({})
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Accounts Payable Summary,Računi plačljivo Povzetek
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,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/work_order/work_order.py,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,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,Lab Test Prescriptions,Testi laboratorijskih testov
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,"The total Issue / Transfer quantity {0} in Material Request {1}  \
							cannot be greater than requested quantity {2} for Item {3}",Skupna količina 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,Small,Majhno
DocType: Shopify Settings,"If Shopify not contains a customer in Order, then while syncing Orders, the system will consider default customer for order","Če Shopify ne vsebuje kupca po naročilu, bo med sinhroniziranjem naročil sistem preučil privzeto stranko po naročilu"
DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Element orodja za ustvarjanje odprtega računa
DocType: Cashier Closing Payments,Cashier Closing Payments,Blizna plačila
DocType: Education Settings,Employee Number,Število zaposlenih
DocType: Subscription Settings,Cancel Invoice After Grace Period,Prekliči račun Po Grace Periodu
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,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)
DocType: Asset Finance Book,Rate of Depreciation,Stopnja amortizacije
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Serial Numbers,Serijske številke
apps/erpnext/erpnext/controllers/stock_controller.py,Row {0}: Quality Inspection rejected for item {1},Vrstica {0}: pregled izdelka je zavrnjen za postavko {1}
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 2,Postavka 2
DocType: Pricing Rule,Validate Applied Rule,Preverjanje veljavnega pravila
DocType: QuickBooks Migrator,Authorization Endpoint,Končna točka avtorizacije
DocType: Employee Onboarding,Notify users by email,Uporabnike obvestite po e-pošti
DocType: Travel Request,International,Mednarodni
DocType: Training Event,Training Event,Dogodek usposabljanje
DocType: Item,Auto re-order,Auto re-order
DocType: Attendance,Late Entry,Počasen vpis
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Total Achieved,Skupaj Doseženi
DocType: Employee,Place of Issue,Kraj izdaje
DocType: Promotional Scheme,Promotional Scheme Price Discount,Popust na ceno promocijske sheme
DocType: Contract,Contract,Pogodba
DocType: GSTR 3B Report,May,Maj
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,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_with_account_number.py,Indirect Expenses,Posredni stroški
apps/erpnext/erpnext/controllers/selling_controller.py,Row {0}: Qty is mandatory,Vrstica {0}: Kol je obvezna
DocType: Agriculture Analysis Criteria,Agriculture,Kmetijstvo
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Sales Order,Ustvari prodajno naročilo
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Accounting Entry for Asset,Računovodski vpis za sredstvo
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Block Invoice,Blokiraj račun
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Quantity to Make,Količina za izdelavo
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Master Data,Sync Master Data
DocType: Asset Repair,Repair Cost,Stroški popravila
apps/erpnext/erpnext/utilities/user_progress.py,Your Products or Services,Svoje izdelke ali storitve
DocType: Quality Meeting Table,Under Review,V pregledu
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Prijava ni uspel
apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Sredstvo {0} je ustvarjeno
DocType: Coupon Code,Promotional,Promocijska
DocType: Special Test Items,Special Test Items,Posebni testni elementi
apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Za registracijo v Marketplace morate biti uporabnik z vlogami upravitelja sistemov in upravitelja elementov.
apps/erpnext/erpnext/config/buying.py,Key Reports,Ključna poročila
DocType: Bank Statement Transaction Payment Item,Mode of Payment,Način plačila
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,As per your assigned Salary Structure you cannot apply for benefits,Glede na dodeljeno strukturo plače ne morete zaprositi za ugodnosti
apps/erpnext/erpnext/stock/doctype/item/item.py,Website Image should be a public file or website URL,Spletna stran Slika bi morala biti javna datoteka ali spletna stran URL
DocType: Purchase Invoice Item,BOM,Surovine
apps/erpnext/erpnext/stock/doctype/item/item.py,Duplicate entry in Manufacturers table,Podvojen vnos v tabeli Proizvajalci
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,This is a root item group and cannot be edited.,"To je skupina, root element in ga ni mogoče urejati."
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge,Spoji se
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/controllers/accounts_controller.py,Rows with duplicate due dates in other rows were found: {0},Vrstice s podvojenimi datumi v drugih vrsticah so bile najdene: {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,"{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/hr/doctype/leave_encashment/leave_encashment.py,No Salary Structure assigned for Employee {0} on given date {1},Struktura plač ni dodeljena zaposlenemu {0} na določenem datumu {1}
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,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/regional/report/eway_bill/eway_bill.py,From Party Name,Iz imena stranke
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Net Salary Amount,Neto znesek plače
DocType: Pick List,Delivery against Sales Order,Dostava proti prodajnemu naročilu
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,"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/accounts/doctype/sales_invoice/sales_invoice.py,Delivery Note {0} is not submitted,Dobavnica {0} ni predložila
apps/erpnext/erpnext/stock/get_item_details.py,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_with_account_number.py,Capital Equipments,Kapitalski Oprema
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","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/work_order/work_order.js,Please set the Item Code first,Najprej nastavite kodo izdelka
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Type
apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Skupna dodeljena odstotek za prodajne ekipe mora biti 100
DocType: Subscription Plan,Billing Interval Count,Številka obračunavanja
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
					to cancel this document","Izbrišite zaposlenega <a href=""#Form/Employee/{0}"">{0}</a> \, če želite preklicati ta dokument"
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Imenovanja in srečanja s pacienti
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Manjka vrednost
DocType: Employee,Department and Grade,Oddelek in razred
DocType: Antibiotic,Antibiotic,Antibiotik
,Team Updates,ekipa Posodobitve
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,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,Create Print Format,Ustvari Print Format
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Created,Ustvarjena provizija
apps/erpnext/erpnext/utilities/bot.py,Did not find any item called {0},Ni našla nobenega elementa z imenom {0}
apps/erpnext/erpnext/stock/report/item_prices/item_prices.js,Items Filter,Filter elementov
DocType: Supplier Scorecard Criteria,Criteria Formula,Kriterijska formula
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Total Outgoing,Skupaj Odhodni
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""",Obstaja lahko samo en prevoz pravilo Pogoj z 0 ali prazno vrednost za &quot;ceniti&quot;
DocType: Bank Statement Transaction Settings Item,Transaction,Posel
DocType: Call Log,Duration,Trajanje
apps/erpnext/erpnext/controllers/status_updater.py,"For an item {0}, quantity must be positive number",Za element {0} mora biti količina pozitivna
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,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/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Compensatory leave request days not in valid holidays,Zahtevki za nadomestni dopust ne veljajo v veljavnih praznikih
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,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/regional/report/eway_bill/eway_bill.py,Accessable Value,Dostopna vrednost
apps/erpnext/erpnext/stock/utils.py,Serial number {0} entered more than once,Serijska številka {0} je začela več kot enkrat
DocType: Bank Statement Transaction Invoice Item,Journal Entry,Vnos v dnevnik
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From GSTIN,Iz GSTIN-a
DocType: Expense Claim Advance,Unclaimed amount,Nezahteven znesek
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{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,Email Digest:,Email Digest:
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Alternative item must not be same as item code,Alternativna postavka ne sme biti enaka kot oznaka izdelka
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} does not belong to Item {1},BOM {0} ne pripada postavki {1}
DocType: Promotional Scheme,Product Discount Slabs,Plošče s popustom na izdelke
DocType: Target Detail,Target Distribution,Target Distribution
DocType: Purchase Invoice,06-Finalization of Provisional assessment,06-Dokončanje začasne ocene
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Parties and Addresses,Uvozne stranke in naslovi
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)"
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Purchase Order,Ustvarite naročilnico
DocType: Quality Inspection Reading,Reading 8,Branje 8
DocType: Inpatient Record,Discharge Note,Razrešnica
apps/erpnext/erpnext/config/desktop.py,Getting Started,Uvod
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,Hardware,Strojna oprema
DocType: Prescription Dosage,Prescription Dosage,Odmerjanje na recept
DocType: Contract,HR Manager,Upravljanje človeških virov
apps/erpnext/erpnext/accounts/party.py,Please select a Company,Prosimo izberite Company
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Privilege Leave,Privilege Zapusti
DocType: Purchase Invoice,Supplier Invoice Date,Dobavitelj Datum računa
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,You need to enable Shopping Cart,Morate omogočiti Košarica
DocType: Payment Entry,Writeoff,Odpisati
DocType: Maintenance Visit,MAT-MVS-.YYYY.-,MAT-MVS-.LLLL.-
DocType: HR Settings,<b>Example:</b> SAL-{first_name}-{date_of_birth.year} <br>This will generate a password like SAL-Jane-1972,"<b>Primer:</b> SAL- {first_name} - {datum_of_birth.year} <br> To bo ustvarilo geslo, kot je SAL-Jane-1972"
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
DocType: Delivery Trip,Total Estimated Distance,Skupna ocenjena razdalja
DocType: Invoice Discounting,Accounts Receivable Unpaid Account,Neplačani račun
DocType: Tally Migration,Tally Company,Tally Company
apps/erpnext/erpnext/config/manufacturing.py,BOM Browser,BOM Browser
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py,Not allowed to create accounting dimension for {0},Ni dovoljeno ustvariti računovodske razsežnosti za {0}
apps/erpnext/erpnext/templates/emails/training_event.html,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,Overlapping conditions found between:,Prekrivajoča pogoji najdemo med:
DocType: Bank Transaction Mapping,Field in Bank Transaction,Polje v bančni transakciji
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Against Journal Entry {0} is already adjusted against some other voucher,Proti listu Začetek {0} je že prilagojena proti neki drugi kupon
,Inactive Sales Items,Neaktivni prodajni artikli
DocType: Quality Review,Additional Information,Dodatne informacije
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Total Order Value,Skupna vrednost naročila
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Food,Hrana
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 3,Staranje Območje 3
DocType: POS Closing Voucher Details,POS Closing Voucher Details,Podrobnosti POS pridržka
DocType: Bank Account,Is the Default Account,Ali je privzeti račun
DocType: Shopify Log,Shopify Log,Nakup dnevnika
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,No communication found.,Sporočila ni mogoče najti.
DocType: Inpatient Occupancy,Check In,Prijava
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Create Payment Entry,Ustvari plačilo
DocType: Maintenance Schedule Item,No of Visits,Število obiskov
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance Schedule {0} exists against {1},obstaja Vzdrževanje Razpored {0} proti {1}
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Enrolling student,Vpisovanje študentov
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Currency of the Closing Account must be {0},Valuta zaključni račun mora biti {0}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,"Appointment overlaps with {0}.<br> {1} has appointment scheduled
			with {2} at {3} having {4} minute(s) duration.",Imenovanje se prekriva z {0}. <br> {1} je predviden sestanek s {2} ob {3} s trajanjem {4} minut.
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py,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
DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Pogoji izpolnjevanja pogodbenih pogojev
,Delivered Items To Be Billed,Dobavljeni artikli placevali
DocType: Coupon Code,Maximum Use,Največja uporaba
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Odprti BOM {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,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: Pricing Rule,UOM,UOM
DocType: Employee Tax Exemption Declaration,Annual HRA Exemption,Letna izjema HRA
DocType: Rename Tool,Utilities,Utilities
DocType: POS Profile,Accounting,Računovodstvo
DocType: Asset,Purchase Receipt Amount,Znesek kupnine
DocType: Employee Separation,Exit Interview Summary,Izhod iz povzetka intervjujev
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select batches for batched item ,Izberite serij za združena postavko
DocType: Asset,Depreciation Schedules,Amortizacija Urniki
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Sales Invoice,Ustvari prodajni račun
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Ineligible ITC,Neupravičena ITC
DocType: Task,Dependent Tasks,Odvisne naloge
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Following accounts might be selected in GST Settings:,V nastavitvah GST se lahko izberejo naslednji računi:
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js,Quantity to Produce,Količina za proizvodnjo
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,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,From {0} | {1} {2},Od {0} | {1} {2}
apps/erpnext/erpnext/public/js/hub/marketplace.js,Some emails are invalid,Nekaj e-poštnih sporočil je neveljavno
DocType: Work Order Operation,Operation Description,Operacija Opis
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,"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,Avg Daily Outgoing,Avg Daily Odhodni
DocType: POS Profile,Campaign,Kampanja
DocType: Supplier,Name and Type,Ime in Type
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Item Reported,Element je prijavljen
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Approval Status must be 'Approved' or 'Rejected',Stanje odobritve mora biti &quot;Approved&quot; ali &quot;Zavrnjeno&quot;
DocType: Healthcare Practitioner,Contacts and Address,Stiki in naslov
DocType: Shift Type,Determine Check-in and Check-out,Določite prijavo in odjavo
DocType: Salary Structure,Max Benefits (Amount),Maksimalne ugodnosti (znesek)
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Add notes,Dodajte opombe
DocType: Purchase Invoice,Contact Person,Kontaktna oseba
apps/erpnext/erpnext/projects/doctype/task/task.py,'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'
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,No data for this period,Za ta čas ni podatkov
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: Water Analysis,Water Analysis Criteria,Kriteriji za analizo vode
DocType: Item,Maintain Stock,Ohraniti Zalogo
DocType: Terms and Conditions,Applicable Modules,Veljavni moduli
DocType: Employee,Prefered Email,Prednostna pošta
DocType: Student Admission,Eligibility and Details,Upravičenost in podrobnosti
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Included in Gross Profit,Vključeno v bruto dobiček
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Fixed Asset,Neto sprememba v osnovno sredstvo
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Reqd Qty,Reqd Qty
apps/erpnext/erpnext/controllers/accounts_controller.py,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/work_order/work_order.js,Max: {0},Max: {0}
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py,From Datetime,Od datetime
DocType: Shopify Settings,For Company,Za podjetje
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,"Request for Quotation is disabled to access from portal, for more check portal settings.",Zahteva za ponudbo je onemogočen dostop iz portala za več nastavitev za preverjanje portala.
DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Dobavitelj Scorecard Scoring Spremenljivka
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Buying Amount,Znesek nabave
DocType: POS Closing Voucher,Modes of Payment,Načini plačila
DocType: Sales Invoice,Shipping Address Name,Naslov dostave
apps/erpnext/erpnext/accounts/doctype/account/account.js,Chart of Accounts,Kontni načrt
DocType: Material Request,Terms and Conditions Content,Pogoji in vsebina
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,There were errors creating Course Schedule,Prišlo je do napak pri urejanju tečaja tečaja
DocType: Communication Medium,Timeslots,Časopisi
DocType: Department,The first Expense Approver in the list will be set as the default Expense Approver.,Prvi odobritev Expenses na seznamu bo nastavljen kot privzeti odobritev Expense.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,cannot be greater than 100,ne more biti večja kot 100
apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,"Če se želite registrirati v Marketplace, morate biti uporabnik, ki ni administrator, z vlogo Upravitelja sistema in Upravitelja elementov."
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is not a stock Item,Postavka {0} ni zaloge Item
DocType: Packing Slip,MAT-PAC-.YYYY.-,MAT-PAC-.LLLL.-
DocType: Maintenance Visit,Unscheduled,Nenačrtovana
DocType: Employee,Owned,Lasti
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
apps/erpnext/erpnext/www/all-products/not_found.html,No products found,Ni najdenih izdelkov
DocType: Employee,Better Prospects,Boljši obeti
DocType: Travel Itinerary,Gluten Free,Brez glutena
DocType: Loyalty Program Collection,Minimum Total Spent,Minimalno skupno porabljeno
apps/erpnext/erpnext/stock/doctype/batch/batch.py,"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Vrstica # {0}: 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: Loyalty Program,Expiry Duration (in days),Trajanje veljavnosti (v dnevih)
DocType: Inpatient Record,Discharge Date,Datum odvajanja
DocType: Subscription Plan,Price Determination,Določitev cene
DocType: Vehicle,License Plate,Registrska tablica
apps/erpnext/erpnext/hr/doctype/department/department_tree.js,New Department,Nov oddelek
DocType: Compensatory Leave Request,Worked On Holiday,Delal na počitnicah
DocType: Appraisal,Goals,Cilji
DocType: Support Settings,Allow Resetting Service Level Agreement,Dovoli ponastavitev sporazuma o ravni storitev
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Select POS Profile,Izberite POS profil
DocType: Warranty Claim,Warranty / AMC Status,Garancija / AMC Status
,Accounts Browser,Računi Browser
DocType: Procedure Prescription,Referral,Napotitev
DocType: Payment Entry Reference,Payment Entry Reference,Plačilo Začetek Reference
DocType: GL Entry,GL Entry,GL Začetek
DocType: Support Search Source,Response Options,Možnosti odziva
DocType: Pricing Rule,Apply Multiple Pricing Rules,Uporabite pravila več cen
DocType: HR Settings,Employee Settings,Nastavitve zaposlenih
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.html,Loading Payment System,Nalaganje plačilnega sistema
,Batch-Wise Balance History,Serija-Wise Balance Zgodovina
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,"Vrstica # {0}: Ne morem nastaviti stopnje, če je znesek večji od zaračunanega zneska za predmet {1}."
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,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,Apprentice,Vajenec
DocType: Purchase Invoice,Company GSTIN,Podjetje GSTIN
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,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
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Employee cannot report to himself.,Delavec ne more poročati zase.
apps/erpnext/erpnext/templates/pages/order.html,Rate:,Oceniti:
DocType: Bank Account,Change this date manually to setup the next synchronization start date,"Ročno spremenite ta datum, da nastavite naslednji datum začetka sinhronizacije"
DocType: Leave Type,Max Leaves Allowed,Dovoljeno je maksimalno dovoljeno odstopanje
DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Če je račun zamrznjen, so vpisi dovoljeni omejenim uporabnikom."
DocType: Email Digest,Bank Balance,Banka Balance
apps/erpnext/erpnext/controllers/accounts_controller.py,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: HR Settings,Leave Approver Mandatory In Leave Application,Pustite odobritev obvezno v odjavi
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/accounting.py,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/chart_of_accounts_importer/chart_of_accounts_importer.js,Resolve error and upload again.,Odpravite napako in naložite znova.
DocType: Buying Settings,Over Transfer Allowance (%),Nadomestilo za prerazporeditev (%)
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{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,Show unclosed fiscal year's P&L balances,Prikaži nezaprt poslovno leto je P &amp; L bilanc
DocType: Item,Asset Naming Series,Serija imenovanja sredstev
DocType: Appraisal,HR-APR-.YY.-.MM.,HR-APR-.YY.-.MM.
apps/erpnext/erpnext/regional/india/utils.py,House rented dates should be atleast 15 days apart,"Datumi, ki jih najamete v hiši, naj bodo vsaj 15 dni narazen"
DocType: Clinical Procedure Template,Collection Details,Podrobnosti o zbirki
DocType: POS Profile,Allow Print Before Pay,Dovoli tiskanje pred plačilom
DocType: Linked Soil Texture,Linked Soil Texture,Povezana tla teksture
DocType: Shipping Rule,Shipping Account,Dostava račun
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} is inactive,{0} {1}: račun {2} je neaktiven
DocType: GSTR 3B Report,March,Marec
DocType: Bank Statement Transaction Entry,Bank Transaction Entries,Vnosi transakcij banke
DocType: Quality Inspection,Readings,Odčitki
DocType: Stock Entry,Total Additional Costs,Skupaj Dodatni stroški
DocType: Quality Action,Quality Action,Kakovostna akcija
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,No of Interactions,Število interakcij
DocType: BOM,Scrap Material Cost(Company Currency),Odpadni material Stroški (družba Valuta)
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,"Set Start Time and End Time for  \
					Support Day {0} at index {1}.",Nastavite začetni in končni čas za \ Support Day {0} v indeksu {1}.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Sub Assemblies,Sklope
DocType: Asset,Asset Name,Ime sredstvo
DocType: Employee Boarding Activity,Task Weight,naloga Teža
DocType: Shipping Rule Condition,To Value,Do vrednosti
DocType: Accounts Settings,Automatically Add Taxes and Charges from Item Tax Template,Samodejno dodajte davke in dajatve iz predloge za davek na postavke
DocType: Loyalty Program,Loyalty Program Type,Vrsta programa zvestobe
DocType: Asset Movement,Stock Manager,Stock Manager
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,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,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,Agriculture (beta),Kmetijstvo (beta)
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Packing Slip,Pakiranje listek
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Rent,Urad za najem
apps/erpnext/erpnext/config/settings.py,Setup SMS gateway settings,Nastavitve Setup SMS gateway
DocType: Disease,Common Name,Pogosto ime
DocType: Customer Feedback Template Table,Customer Feedback Template Table,Tabela predloga za povratne informacije strank
DocType: Employee Boarding Activity,Employee Boarding Activity,Aktivnost vkrcanja zaposlenih
apps/erpnext/erpnext/public/js/templates/address_list.html,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,Analyst,Analitik
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,{0} is not in a valid Payroll Period,{0} ni v veljavnem plačilnem obdobju
DocType: Employee Benefit Application,Max Benefits (Yearly),Maksimalne ugodnosti (letno)
DocType: Item,Inventory,Popis
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Prenesite kot Json
DocType: Item,Sales Details,Prodajna Podrobnosti
DocType: Coupon Code,Used,Rabljeni
DocType: Opportunity,With Items,Z Items
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampanja &#39;{0}&#39; že obstaja za {1} &#39;{2}&#39;
DocType: Asset Maintenance,Maintenance Team,Vzdrževalna ekipa
DocType: Homepage Section,"Order in which sections should appear. 0 is first, 1 is second and so on.","Vrstni red, v katerem morajo biti razdelki. 0 je prvo, 1 je drugo in tako naprej."
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,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: Item,Item Attribute,Postavka Lastnost
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Government,Vlada
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Expense Claim {0} already exists for the Vehicle Log,Expense Zahtevek {0} že obstaja za Prijavi vozil
DocType: Asset Movement,Source Location,Izvorna lokacija
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Name,Ime Institute
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter repayment Amount,Vnesite odplačevanja Znesek
DocType: Shift Type,Working Hours Threshold for Absent,Mejna vrednost delovnega časa za odsotne
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,There can be multiple tiered collection factor based on the total spent. But the conversion factor for redemption will always be same for all the tier.,Na podlagi skupnih porabljenih sredstev je lahko več faktorjev zbiranja. Toda pretvorbeni faktor za odkup bo vedno enak za vse stopnje.
apps/erpnext/erpnext/config/help.py,Item Variants,Artikel Variante
apps/erpnext/erpnext/public/js/setup_wizard.js,Services,Storitve
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,BOM 2,BOM 2
DocType: Payment Order,PMO-,PMO-
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/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Create Invoices,Ustvari račune
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Select Possible Supplier,Izberite Možni Dobavitelj
DocType: Communication Medium,Communication Medium Type,Komunikacija Srednja vrsta
DocType: Customer,"Select, to make the customer searchable with these fields","Izberite, da bo stranka s temi področji omogočila iskanje"
DocType: Shopify Settings,Import Delivery Notes from Shopify on Shipment,Uvozne opombe za dostavo iz Shopify na pošiljko
apps/erpnext/erpnext/templates/pages/projects.html,Show closed,Prikaži zaprto
DocType: Issue Priority,Issue Priority,Prednostna izdaja
DocType: Leave Ledger Entry,Is Leave Without Pay,Se Leave brez plačila
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,GSTIN,GSTIN
apps/erpnext/erpnext/stock/doctype/item/item.py,Asset Category is mandatory for Fixed Asset item,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,No records found in the Payment table,Ni najdenih v tabeli plačil zapisov
apps/erpnext/erpnext/education/utils.py,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
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,{0}: {1} must be less than {2},{0}: {1} mora biti manjši od {2}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,"Select BOM, Qty and For Warehouse","Izberite BOM, Qty in Za skladišče"
DocType: GST HSN Code,GST HSN Code,DDV HSN koda
DocType: Employee External Work History,Total Experience,Skupaj Izkušnje
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Projects,Odprti projekti
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Packing Slip(s) cancelled,Dobavnico (e) odpovedan
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Investing,Denarni tokovi iz naložbenja
DocType: Program Course,Program Course,Tečaj programa
DocType: Healthcare Service Unit,Allow Appointments,Dovoli imenovanja
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,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,Taken,Taken
DocType: Invoice Discounting,Short Term Loan Account,Kratkoročni posojilni račun
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,Executive Search,Executive Search
DocType: Employee Advance,HR-EAD-.YYYY.-,HR-EAD-.LLLL.-
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Setting defaults,Nastavitev privzetih nastavitev
DocType: Loyalty Program,Auto Opt In (For all customers),Auto Opt In (za vse stranke)
apps/erpnext/erpnext/utilities/activation.py,Create Leads,Ustvari Interesenti
DocType: Maintenance Schedule,Schedules,Urniki
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,POS Profile is required to use Point-of-Sale,Profil POS je potreben za uporabo Point-of-Sale
DocType: Cashier Closing,Net Amount,Neto znesek
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} has not been submitted so the action cannot be completed,"{0} {1} ni bila 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,Dodatno zaračunano
DocType: Support Search Source,Result Route Field,Polje poti rezultatov
DocType: Supplier,PAN,PAN
DocType: Employee Checkin,Log Type,Vrsta dnevnika
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
,Support Hour Distribution,Podpora Distribution Hour
DocType: Maintenance Visit,Maintenance Visit,Vzdrževalni obisk
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Close Loan,Zaprite posojilo
DocType: Student,Leaving Certificate Number,Leaving Certificate Število
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,"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,Update Print Format,Update Print Format
DocType: Bank Account,Is Company Account,Je račun podjetja
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,Leave Type {0} is not encashable,Odstop tipa {0} ni zapletljiv
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Credit limit is already defined for the Company {0},Kreditni limit je za podjetje že določen {0}
DocType: Landed Cost Voucher,Landed Cost Help,Pristali Stroški Pomoč
DocType: Vehicle Log,HR-VLOG-.YYYY.-,HR-VLOG-.YYYY.-
DocType: Purchase Invoice,Select Shipping Address,Izbira naslova za dostavo
DocType: Timesheet Detail,Expected Hrs,Pričakovana ura
apps/erpnext/erpnext/config/non_profit.py,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,Please input all required Result Value(s),Vnesite vso zahtevano vrednost (-e)
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Accounts Receivable Summary,Povzetek terjatev
DocType: POS Closing Voucher,Linked Invoices,Povezani računi
DocType: Loan,Monthly Repayment Amount,Mesečni Povračilo Znesek
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices,Odpiranje računov
DocType: Contract,Contract Details,Podrobnosti pogodbe
apps/erpnext/erpnext/hr/doctype/employee/employee.py,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
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 1,Naslov 1
DocType: GST HSN Code,HSN Code,Tarifna številka
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution Amount,Prispevek Znesek
DocType: Homepage Section,Section Order,Odredba oddelka
DocType: Inpatient Record,Patient Encounter,Patient Encounter
DocType: Accounts Settings,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."
apps/erpnext/erpnext/erpnext_integrations/utils.py,Unverified Webhook Data,Nepreverjeni podatki spletnega ure
DocType: Water Analysis,Container,Zabojnik
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Please set valid GSTIN No. in Company Address,V naslov podjetja nastavite veljavno številko GSTIN
apps/erpnext/erpnext/education/utils.py,Student {0} - {1} appears Multiple times in row {2} & {3},Študent {0} - {1} pojavi večkrat v vrsti {2} {3}
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Following fields are mandatory to create address:,Naslednja polja so obvezna za ustvarjanje naslova:
DocType: Item Alternative,Two-way,Dvosmerni
DocType: Item,Manufacturers,Proizvajalci
apps/erpnext/erpnext/accounts/deferred_revenue.py,Error while processing deferred accounting for {0},Napaka pri obdelavi odloženega računovodstva za {0}
,Employee Billing Summary,Povzetek obračunavanja zaposlenih
DocType: Project,Day to Send,Dan za pošiljanje
DocType: Healthcare Settings,Manage Sample Collection,Upravljanje vzorčenja
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set the series to be used.,"Prosimo, nastavite serijo za uporabo."
DocType: Patient,Tobacco Past Use,Pretekla uporaba tobaka
DocType: Travel Itinerary,Mode of Travel,Način potovanja
DocType: Sales Invoice Item,Brand Name,Blagovna znamka
DocType: Purchase Receipt,Transporter Details,Transporter Podrobnosti
DocType: Issue,Service Level Agreement Creation,Izdelava sporazuma o ravni storitev
apps/erpnext/erpnext/accounts/page/pos/pos.js,Default warehouse is required for selected item,Privzeto skladišče je potrebna za izbrano postavko
DocType: Quiz,Passing Score,Prehodna ocena
apps/erpnext/erpnext/utilities/user_progress.py,Box,Škatla
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Possible Supplier,Možni Dobavitelj
DocType: Budget,Monthly Distribution,Mesečni Distribution
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Receiver List is empty. Please create Receiver List,"Sprejemnik Seznam je prazen. Prosimo, da ustvarite sprejemnik seznam"
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! The input you've entered doesn't match the GSTIN format for UIN Holders or Non-Resident OIDAR Service Providers,Neveljaven GSTIN! Vneseni vnos ne ustreza formatu GSTIN za imetnike UIN ali nerezidentne ponudnike storitev OIDAR
apps/erpnext/erpnext/public/js/setup_wizard.js,Healthcare (beta),Zdravstvo (beta)
DocType: Production Plan Sales Order,Production Plan Sales Order,Proizvodni načrt Sales Order
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"No active BOM found for item {0}. Delivery by \
						Serial No cannot be ensured",Za element {0} ni najdena aktivna BOM. Dostava z \ Serial No ne more biti zagotovljena
DocType: Sales Partner,Sales Partner Target,Prodaja Partner Target
DocType: Loan Type,Maximum Loan Amount,Največja Znesek posojila
DocType: Coupon Code,Pricing Rule,Cen Pravilo
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Podvojena številka rola študent {0}
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Podvojena številka rola študent {0}
apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Material Zahteva za narocilo
DocType: Company,Default Selling Terms,Privzeti prodajni pogoji
DocType: Shopping Cart Settings,Payment Success URL,Plačilo Uspeh URL
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Returned Item {1} does not exists in {2} {3},Vrstica # {0}: Vrnjeno Postavka {1} ne obstaja v {2} {3}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Bank Accounts,Bančni računi
,Bank Reconciliation Statement,Izjava Bank Sprava
DocType: Patient Encounter,Medical Coding,Zdravniško kodiranje
DocType: Healthcare Settings,Reminder Message,Opomnik
DocType: Call Log,Lead Name,Ime ponudbe
,POS,POS
DocType: C-Form,III,III
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Prospecting,Raziskovanje
apps/erpnext/erpnext/config/help.py,Opening Stock Balance,Odpiranje Stock Balance
DocType: Asset Category Account,Capital Work In Progress Account,Vloga za kapitalsko delo v teku
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Value Adjustment,Prilagoditev vrednosti sredstva
DocType: Additional Salary,Payroll Date,Datum plačila
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,{0} must appear only once,{0} se morajo pojaviti le enkrat
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,Leaves Allocated Successfully for {0},Listi Dodeljena Uspešno za {0}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,No Items to pack,Ni prispevkov za pakiranje
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Only .csv and .xlsx files are supported currently,Trenutno so podprte samo datoteke .csv in .xlsx
DocType: Shipping Rule Condition,From Value,Od vrednosti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Manufacturing Quantity is mandatory,Proizvodnja Količina je obvezna
DocType: 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/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Pending Quantity,Količina v teku
apps/erpnext/erpnext/utilities/activation.py,"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/non_profit/report/expiring_memberships/expiring_memberships.py,Member ID,ID člana
DocType: Employee Tax Exemption Proof Submission,Monthly Eligible Amount,Mesečni upravičeni znesek
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,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
DocType: Pricing Rule,Supplier Group,Skupina dobaviteljev
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,{0} Digest,{0} Razlaga
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0}: From Time and To Time of {1} is overlapping with {2},Vrstica {0}: V času in času {1} se prekrivajo z {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Liabilities,Zaloga Obveznosti
DocType: Purchase Invoice,Supplier Warehouse,Dobavitelj Skladišče
DocType: Opportunity,Contact Mobile No,Kontaktna mobilna številka
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,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/config/crm.py,"Helps you keep tracks of Contracts based on Supplier, Customer and Employee","Pomaga pri sledenju pogodb na podlagi dobavitelja, kupca in zaposlenega"
DocType: Company,Discount Received Account,Popust s prejetim računom
DocType: Student Report Generation Tool,Print Section,Oddelek za tiskanje
DocType: Staffing Plan Detail,Estimated Cost Per Position,Ocenjeni strošek na pozicijo
DocType: Employee,HR-EMP-,HR-EMP-
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Uporabnik {0} nima privzetega profila POS. Preverite privzeto na vrstici {1} za tega uporabnika.
DocType: Quality Meeting Minutes,Quality Meeting Minutes,Zapisniki o kakovostnem sestanku
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Employee Referral,Napotitev zaposlenih
DocType: Student Group,Set 0 for no limit,Nastavite 0 za brez omejitev
DocType: Cost Center,rgt,RGT
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,"Dan (s), na kateri se prijavljate za dopust, so prazniki. Vam ni treba zaprositi za dopust."
DocType: Customer,Primary Address and Contact Detail,Osnovni naslov in kontaktni podatki
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Resend Payment Email,Ponovno pošlji plačila Email
apps/erpnext/erpnext/templates/pages/projects.html,New task,Nova naloga
DocType: Clinical Procedure,Appointment,Imenovanje
apps/erpnext/erpnext/config/buying.py,Other Reports,Druga poročila
apps/erpnext/erpnext/public/js/setup_wizard.js,Please select at least one domain.,Izberite vsaj eno domeno.
DocType: Dependent Task,Dependent Task,Odvisna Task
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to UIN holders,Potrebščine za imetnike UIN
DocType: Shopify Settings,Shopify Tax Account,Nakup davčnega računa
apps/erpnext/erpnext/stock/doctype/item/item.py,Conversion factor for default Unit of Measure must be 1 in row {0},"Faktor pretvorbe za privzeto mersko enoto, mora biti 1 v vrstici {0}"
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave of type {0} cannot be longer than {1},Dopust tipa {0} ne more biti daljši od {1}
DocType: Delivery Trip,Optimize Route,Optimizirajte pot
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Poskusite načrtovanju operacij za X dni vnaprej.
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,"{0} vacancies and {1} budget for {2} already planned for subsidiary companies of {3}. \
				You can only plan for upto {4} vacancies and and budget {5} as per staffing plan {6} for parent company {3}.","{0} prosta delovna mesta in {1} proračun za {2}, ki je že načrtovan za hčerinske družbe {3}. \ Načrtujete lahko le do {4} prostih mest in proračuna {5}, skladno s kadrovskim načrtom {6} za matično podjetje {3}."
DocType: HR Settings,Stop Birthday Reminders,Stop Birthday opomniki
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,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: Pricing Rule Brand,Pricing Rule Brand,Blagovna znamka
DocType: Amazon MWS Settings,Get financial breakup of Taxes and charges data by Amazon ,"Get finančno razčlenitev davkov in zaračunavanje podatkov, ki jih Amazon"
DocType: SMS Center,Receiver List,Sprejemnik Seznam
DocType: Pricing Rule,Rule Description,Opis pravila
apps/erpnext/erpnext/accounts/page/pos/pos.js,Search Item,Iskanje Item
DocType: Program,Allow Self Enroll,Dovoli samovpis
DocType: Payment Schedule,Payment Amount,Znesek Plačila
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Datum poldnevnega dneva mora biti med delovnim časom in končnim datumom dela
DocType: Healthcare Settings,Healthcare Service Items,Točke zdravstvenega varstva
apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Neveljavna črtna koda. Na tej črtni kodi ni nobenega predmeta.
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Porabljeni znesek
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Neto sprememba v gotovini
DocType: Assessment Plan,Grading Scale,Ocenjevalna lestvica
apps/erpnext/erpnext/stock/doctype/item/item.py,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Merska enota {0} je v pretvorbeni faktor tabeli vpisana več kot enkrat
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock In Hand,Zaloga v roki
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"Please add the remaining benefits {0} to the application as \
				pro-rata component","Prosimo, dodajte preostale ugodnosti {0} v aplikacijo kot \ pro-rata komponento"
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the public administration '%s',"Prosimo, nastavite davčni zakonik za javno upravo &#39;% s&#39;"
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Issued Items,Strošek izdanih postavk
DocType: Healthcare Practitioner,Hospital,Bolnišnica
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Quantity must not be more than {0},Količina ne sme biti več kot {0}
DocType: Travel Request Costing,Funded Amount,"Znesek, ki ga financira"
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Previous Financial Year is not closed,Prejšnja Proračunsko leto ni zaprt
DocType: Practitioner Schedule,Practitioner Schedule,Urnik zdravnikov
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Age (Days),Starost (dnevi)
DocType: Instructor,EDU-INS-.YYYY.-,EDU-INS-.YYYY.-
DocType: Additional Salary,Additional Salary,Dodatna plača
DocType: Quotation Item,Quotation Item,Postavka ponudbe
DocType: Customer,Customer POS Id,ID POS stranka
apps/erpnext/erpnext/education/utils.py,Student with email {0} does not exist,Študent z e-pošto {0} ne obstaja
DocType: Account,Account Name,Ime računa
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,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,Serial No {0} quantity {1} cannot be a fraction,Serijska št {0} količina {1} ne more biti del
DocType: Pricing Rule,Apply Discount on Rate,Uporabite popust na ceno
DocType: Tally Migration,Tally Debtors Account,Račun dolžnikov Tally
DocType: Pricing Rule,Promotional Scheme,Promocijska shema
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter Woocommerce Server URL,Vnesite URL strežnika Woocommerce
DocType: GSTR 3B Report,September,Septembra
DocType: Purchase Order Item,Supplier Part Number,Dobavitelj Številka dela
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Conversion rate cannot be 0 or 1,Menjalno razmerje ne more biti 0 ali 1
apps/erpnext/erpnext/accounts/page/bank_reconciliation/linked_payment_header.html,Payment Name,Ime plačila
DocType: Share Balance,To No,Na št
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,All the mandatory Task for employee creation hasn't been done yet.,Vsa obvezna naloga za ustvarjanje zaposlenih še ni bila opravljena.
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled or stopped,{0} {1} je preklican ali ustavljen
DocType: Accounts Settings,Credit Controller,Credit Controller
DocType: Loan,Applicant Type,Vrsta vlagatelja
DocType: Purchase Invoice,03-Deficiency in services,03-Pomanjkanje storitev
DocType: Healthcare Settings,Default Medical Code Standard,Privzeti standard za medicinsko kodo
DocType: Purchase Invoice Item,HSN/SAC,TARIC
DocType: Project Template Task,Project Template Task,Naloga predloge projekta
DocType: Accounts Settings,Over Billing Allowance (%),Nadomestilo za obračun (%)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,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,"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"
DocType: Purchase Receipt,MAT-PRE-.YYYY.-,MAT-PRE-.YYYY.-
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Billed,{0}% zaračunano
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Reserved Qty,Rezervirano Kol
DocType: Party Account,Party Account,Račun Party
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,Please select Company and Designation,Izberite podjetje in določitev
apps/erpnext/erpnext/config/settings.py,Human Resources,Človeški viri
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Upper Income,Zgornja Prihodki
DocType: Item Manufacturer,Item Manufacturer,Element Proizvajalec
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Create New Lead,Ustvari nov potencial
DocType: BOM Operation,Batch Size,Velikost serije
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Reject,Zavrni
DocType: Journal Entry Account,Debit in Company Currency,Debetno v podjetju valuti
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Import Successfull,Uvozi uspešno
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Material Request not created, as quantity for Raw Materials already available.","Prošnja za material ni ustvarjena, ker količina za Surove materiale zadostna."
DocType: BOM Item,BOM Item,BOM Postavka
DocType: Appraisal,For Employee,Za zaposlenega
DocType: Leave Control Panel,Designation (optional),Oznaka (neobvezno)
apps/erpnext/erpnext/stock/stock_ledger.py,"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting / cancelling this entry.","Stopnja vrednotenja ni postavljena za postavko {0}, ki mora opraviti računovodske vnose za {1} {2}. Če izdelek v postavki {1} deluje kot ničelna stopnja vrednotenja, to navedite v tabeli {1} Postavka. V nasprotnem primeru ustvarite dohodno transakcijo z zalogami ali navedite stopnjo vrednotenja v zapisu izdelka in poskusite vnesti / preklicati ta vnos."
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Supplier must be debit,Vrstica {0}: Advance zoper dobavitelja mora biti v breme
DocType: Company,Default Values,Privzete vrednosti
DocType: Certification Application,INR,INR
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Party Addresses,Naslovi obdelovalnih strank
DocType: Woocommerce Settings,Creation User,Uporabnik ustvarjanja
DocType: Quality Procedure,Quality Procedure,Postopek kakovosti
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Please check the error log for details about the import errors,Preverite dnevnik napak za podrobnosti o napakah pri uvozu
DocType: Bank Transaction,Reconciled,Pomirjen
DocType: Expense Claim,Total Amount Reimbursed,"Skupnega zneska, povrnjenega"
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py,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/hr/doctype/additional_salary/additional_salary.py,Payroll date can not be less than employee's joining date,"Datum plačevanja ne sme biti manjši od datuma, ko se zaposleni včlani"
DocType: Pick List,Item Locations,Lokacije postavk
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.py,{0} {1} created,{0} {1} ustvarjeno
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,"Job Openings for designation {0} already open \
					or hiring completed as per Staffing Plan {1}",Odprti posli za oznako {0} so že odprti \ ali najem zaključeni v skladu s kadrovskim načrtom {1}
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,You can publish upto 200 items.,Objavite lahko do 200 elementov.
DocType: Vital Signs,Constipated,Zaprta
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,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,Asset Movement record {0} created,zapis Gibanje sredstvo {0} ustvaril
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,"Ne, ne moreš brisati poslovnega leta {0}. Poslovno leto {0} je privzet v globalnih nastavitvah"
DocType: Share Transfer,Equity/Liability Account,Račun kapitala / obveznost
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py,A customer with the same name already exists,Kupec z istim imenom že obstaja
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,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 Order,Order Confirmation No,Potrditev št
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Net Profit,Čisti dobiček
DocType: Purchase Invoice,Eligibility For ITC,Upravičenost do ITC
DocType: Student Applicant,EDU-APP-.YYYY.-,EDU-APP-YYYY-
DocType: Journal Entry,Entry Type,Začetek Type
,Customer Credit Balance,Stranka Credit Balance
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Accounts Payable,Neto sprememba obveznosti do dobaviteljev
apps/erpnext/erpnext/selling/doctype/customer/customer.py,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,Customer required for 'Customerwise Discount',Stranka zahteva za &quot;Customerwise popust&quot;
apps/erpnext/erpnext/config/accounting.py,Update bank payment dates with journals.,Posodobite rok plačila banka s revijah.
,Billed Qty,Število računov
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Pricing,Cenitev
DocType: Employee,Attendance Device ID (Biometric/RF tag ID),ID naprave za udeležbo (ID biometrične / RF oznake)
DocType: Quotation,Term Details,Izraz Podrobnosti
DocType: Item,Over Delivery/Receipt Allowance (%),Nadomestilo za dostavo / prejem (%)
DocType: Employee Incentive,Employee Incentive,Spodbujanje zaposlenih
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,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,Total (Without Tax),Skupaj (brez davka)
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Lead Count,svinec Štetje
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Lead Count,svinec Štetje
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,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,Procurement,Javna naročila
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,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,Mandatory field - Program,Obvezno polje - Program
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Program,Obvezno polje - Program
DocType: Special Test Template,Result Component,Komponenta rezultata
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js,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: Share Transfer,Asset Account,Račun sredstev
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Nov datum izida bi moral biti v prihodnosti
DocType: Purchase Invoice,End date of current invoice's period,Končni datum obdobja tekočega faktura je
DocType: Lab Test,Technician Name,Ime tehnika
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
					Item {0} is added with and without Ensure Delivery by \
					Serial No.","Dostava ni mogoče zagotoviti s serijsko številko, ker se \ Item {0} doda z in brez Zagotoviti dostavo z \ Serial No."
DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Prekinitev povezave med Plačilo na Izbris računa
DocType: Bank Reconciliation,From Date,Od datuma
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,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}
,Purchase Order Items To Be Received or Billed,"Nabavni predmeti, ki jih je treba prejeti ali plačati"
DocType: Restaurant Reservation,No Show,Ni predstave
apps/erpnext/erpnext/regional/india/utils.py,You must be a registered supplier to generate e-Way Bill,Za generiranje e-poti morate biti registrirani dobavitelj
DocType: Shipping Rule Country,Shipping Rule Country,Država dostavnega pravila
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Leave and Attendance,Pusti in postrežbo
DocType: Asset,Comprehensive Insurance,Celovito zavarovanje
DocType: Maintenance Visit,Partially Completed,Delno Dopolnil
apps/erpnext/erpnext/public/js/event.js,Add Leads,Dodaj jezike
apps/erpnext/erpnext/healthcare/setup.py,Moderate Sensitivity,Zmerna občutljivost
DocType: Leave Type,Include holidays within leaves as leaves,Vključite počitnice v listih kot listja
DocType: Loyalty Program,Redemption,Odkup
DocType: Sales Invoice,Packed Items,Pakirane Items
DocType: Tally Migration,Vouchers,Vavčerji
DocType: Tax Withholding Category,Tax Withholding Rates,Davčne odtegljaje
DocType: Contract,Contract Period,Pogodbeno obdobje
apps/erpnext/erpnext/config/support.py,Warranty Claim against Serial No.,Garancija zahtevek zoper Serial No.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,'Total',&quot;Skupaj&quot;
DocType: Shopping Cart Settings,Enable Shopping Cart,Omogoči Košarica
DocType: Employee,Permanent Address,stalni naslov
DocType: Loyalty Program,Collection Tier,Zbirni list
apps/erpnext/erpnext/hr/utils.py,From date can not be less than employee's joining date,Od datuma ne more biti krajši od datuma pridružitve zaposlenega
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"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,Please select item code,"Prosimo, izberite postavko kodo"
DocType: Student Sibling,Studying in Same Institute,Študij v istem inštitutu
DocType: Leave Type,Earned Leave,Zasluženi dopust
apps/erpnext/erpnext/erpnext_integrations/connectors/shopify_connection.py,Tax Account not specified for Shopify Tax {0},Davčni račun ni določen za Shopify Tax {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,The following serial numbers were created: <br> {0},Izdelane so bile naslednje serijske številke: <br> {0}
DocType: Employee,Salary Details,Podrobnosti o plačah
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/setup/setup_wizard/data/industry_type.py,Online Auctions,Online Dražbe
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,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,Fulfillment,izpolnitev
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,View in Cart,Poglej v košarico
DocType: Employee Checkin,Shift Actual Start,Dejanski začetek premika
DocType: Tally Migration,Is Day Book Data Imported,Ali so uvoženi podatki o dnevnikih
,Purchase Order Items To Be Received or Billed1,"Nabavni predmeti, ki jih je treba prejeti ali plačati1"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Marketing Expenses,Stroški trženja
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.py,{0} units of {1} is not available.,{0} enot od {1} ni na voljo.
,Item Shortage Report,Postavka Pomanjkanje Poročilo
DocType: Bank Transaction Payments,Bank Transaction Payments,Bančna transakcijska plačila
apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py,Can't create standard criteria. Please rename the criteria,Ne morem ustvariti standardnih meril. Preimenujte merila
apps/erpnext/erpnext/stock/doctype/item/item.js,"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
DocType: Hub User,Hub Password,Hub geslo
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
,Sales Partner Target Variance based on Item Group,Ciljna varianta prodajnega partnerja na podlagi skupine izdelkov
apps/erpnext/erpnext/config/support.py,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
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Allocated Leaves,Dodeljeni listi
DocType: Drug Prescription,Dosage by time interval,Odmerjanje po časovnem intervalu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Total Taxable Value,Skupna obdavčljiva vrednost
DocType: Cash Flow Mapper,Section Header,Naslov glave
,Student Fee Collection,Študent Fee Collection
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,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/public/js/setup_wizard.js,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
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Pick List,Izberi seznam
,Sales Person Commission Summary,Povzetek Komisije za prodajno osebo
DocType: Material Request,Transferred,Preneseni
DocType: Vehicle,Doors,vrata
DocType: Healthcare Settings,Collect Fee for Patient Registration,Zberi pristojbino za registracijo pacientov
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,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: Employee,Joining Details,Povezovanje Podrobnosti
DocType: Member,Non Profit Member,Neprofitni član
DocType: Email Digest,Bank Credit Balance,Kreditno stanje banke
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,"{0} {1}: Stroškovno mesto je 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,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: Location,Area,Območje
apps/erpnext/erpnext/public/js/templates/contact_list.html,New Contact,Nov kontakt
DocType: Company,Company Description,Opis podjetja
DocType: Territory,Parent Territory,Parent Territory
DocType: Purchase Invoice,Place of Supply,Kraj dobave
DocType: Quality Inspection Reading,Reading 2,Branje 2
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Employee {0} already submited an apllication {1} for the payroll period {2},Zaposleni {0} je že podaljšal aplikacijo {1} za obdobje plačevanja {2}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Material Receipt,Material Prejem
DocType: Bank Statement Transaction Entry,Submit/Reconcile Payments,Pošljite / uskladite plačila
DocType: Campaign,SAL-CAM-.YYYY.-,SAL-CAM-.LLLL.-
DocType: Homepage,Products,Izdelki
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invoices based on Filters,Pridobite račune na podlagi filtrov
DocType: Announcement,Instructor,inštruktor
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Select Item (optional),Izberite postavko (neobvezno)
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,The Loyalty Program isn't valid for the selected company,Program zvestobe ni veljaven za izbrano podjetje
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: Products Settings,Hide Variants,Skrij variante
DocType: Lead,Next Contact By,Naslednja Kontakt Z
DocType: Compensatory Leave Request,Compensatory Leave Request,Zahtevek za kompenzacijski odhod
apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Za postavko {0} v vrstici {1} več kot {2} ni mogoče preplačati. Če želite dovoliti preplačilo, nastavite dovoljenje v nastavitvah računov"
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,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,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: Blanket Order,Order Type,Tip naročila
,Item-wise Sales Register,Elementni Prodajni register
DocType: Asset,Gross Purchase Amount,Bruto znesek nakupa
apps/erpnext/erpnext/utilities/user_progress.py,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/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Total Target,Skupaj Target
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Perception Analysis,Analiza percepcije
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Integrated Tax,Integrirani davek
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/accounts/page/bank_reconciliation/bank_reconciliation.js,Automatic Reconciliation,Samodejna uskladitev
DocType: Purchase Invoice,Release Date,Datum izdaje
DocType: Stock Reconciliation,Reconciliation JSON,Uskladitev JSON
apps/erpnext/erpnext/accounts/report/financial_statements.html,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: Marketplace Settings,Hub Seller Name,Ime prodajalca vozlišča
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Employee Advances,Napredek zaposlenih
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,Guardian2 Mobile No,Skrbnika2 Mobile No
apps/erpnext/erpnext/setup/doctype/company/company.py,Main,Main
DocType: GSTR 3B Report,July,Julija
apps/erpnext/erpnext/controllers/buying_controller.py,Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Po elementu {0} ni označen kot {1} element. Lahko jih omogočite kot {1} element iz glavnega elementa
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant,Variant
apps/erpnext/erpnext/controllers/status_updater.py,"For an item {0}, quantity must be negative number",Za element {0} mora biti količina negativna
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,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?
DocType: Email Digest,Annual Expenses,letni stroški
DocType: Item,Variants,Variante
DocType: SMS Center,Send To,Pošlji
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,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
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Manufactured,Izdelano
DocType: Sales Invoice Item,Customer's Item Code,Koda artikla stranke
DocType: Stock Reconciliation,Stock Reconciliation,Uskladitev zalog
DocType: Territory,Territory Name,Territory Name
DocType: Email Digest,Purchase Orders to Receive,Naročila za nakup
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work-in-Progress Warehouse is required before Submit,Work-in-Progress Warehouse je pred potreben Submit
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,You can only have Plans with the same billing cycle in a Subscription,V naročnini lahko imate samo načrte z enakim obračunskim ciklom
DocType: Bank Statement Transaction Settings Item,Mapped Data,Mapirani podatki
DocType: Purchase Order Item,Warehouse and Reference,Skladišče in Reference
DocType: Payroll Period Date,Payroll Period Date,Datum roka plačila
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,Student Group Strength,Študent Skupina moč
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Student Group Strength,Študent Skupina moč
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Against Journal Entry {0} does not have any unmatched {1} entry,Proti listu Začetek {0} nima neprimerljivo {1} vnos
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,"Subsidiary companies have already planned for {1} vacancies at a budget of {2}. \
				Staffing Plan for {0} should allocate more vacancies and budget for {3} than planned for its subsidiary companies","Pomožne družbe so že načrtovale {1} prosta delovna mesta v proračunu {2}. \ Kadrovski načrt za {0} bi moral dodeliti več prostih delovnih mest in proračuna za {3}, kot je bilo načrtovano za njene hčerinske družbe"
apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py,Training Events,Dogodki za usposabljanje
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Duplicate Serial No entered for Item {0},Podvajati Zaporedna številka vpisana v postavko {0}
DocType: Quality Review Objective,Quality Review Objective,Cilj pregleda kakovosti
apps/erpnext/erpnext/config/crm.py,Track Leads by Lead Source.,Sledite navodilom po viru.
DocType: Shipping Rule Condition,A condition for a Shipping Rule,Pogoj za Pravilo pošiljanja
DocType: Sales Invoice,e-Way Bill No.,račun za e-poti št.
DocType: GSTR 3B Report,JSON Output,Izhod JSON
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please enter ,vnesite
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Maintenance Log,Dnevnik vzdrževanja
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Please set filter based on Item or Warehouse,"Prosim, nastavite filter, ki temelji na postavki ali skladišče"
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,Discount amount cannot be greater than 100%,Znesek popusta ne sme biti večji od 100%
DocType: Opportunity,CRM-OPP-.YYYY.-,CRM-OPP-YYYY.-
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,"Number of new Cost Center, it will be included in the cost center name as a prefix",Število novih stroškovnih centrov bo vključeno v nabavno ime kot predpono
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
DocType: Stock Entry,Receive at Warehouse,Prejem v skladišču
DocType: Communication Medium,Voice,Glas
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} must be submitted,Surovino {0} je potrebno predložiti
apps/erpnext/erpnext/config/accounting.py,Share Management,Deljeno upravljanje
DocType: Authorization Control,Authorization Control,Pooblastilo za nadzor
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Vrstica # {0}: zavrnitev Skladišče je obvezno proti zavrnil postavki {1}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Received Stock Entries,Prejeti vpisi v zaloge
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Payment,Plačilo
apps/erpnext/erpnext/controllers/stock_controller.py,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Skladišče {0} ni povezano z nobenim računom, navedite račun v evidenco skladišče ali nastavite privzeto inventarja račun v družbi {1}."
apps/erpnext/erpnext/utilities/activation.py,Manage your orders,Upravljajte naročila
DocType: Work Order Operation,Actual Time and Cost,Dejanski čas in stroški
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Material Zahteva za največ {0} se lahko izvede za postavko {1} proti Sales Order {2}
DocType: Amazon MWS Settings,DE,DE
DocType: Crop,Crop Spacing,Razmik rastlin
DocType: Budget,Action if Annual Budget Exceeded on PO,"Ukrep, če je letni proračun presegel PO"
DocType: Issue,Service Level,Raven storitev
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,"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,Employee {0} on Half day on {1},Zaposlenih {0} v pol dneva na {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,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}
DocType: Asset Settings,Disable CWIP Accounting,Onemogoči CWIP računovodstvo
apps/erpnext/erpnext/templates/pages/task_info.html,On,na
apps/erpnext/erpnext/config/buying.py,Bundle items at time of sale.,Bundle predmeti v času prodaje.
DocType: Products Settings,Product Page,Stran izdelka
DocType: Delivery Settings,Dispatch Settings,Nastavitve pošiljanja
DocType: Material Request Plan Item,Actual Qty,Dejanska Količina
DocType: Sales Invoice Item,References,Reference
DocType: Quality Inspection Reading,Reading 10,Branje 10
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Serial nos {0} does not belongs to the location {1},Serijski nos {0} ne pripada lokaciji {1}
DocType: Item,Barcodes,Črtne kode
DocType: Hub Tracked Item,Hub Node,Vozliščna točka
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,You have entered duplicate items. Please rectify and try again.,"Vnesli ste podvojene elemente. Prosimo, popravite in poskusite znova."
DocType: Tally Migration,Is Master Data Imported,Ali so uvoženi glavni podatki
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Associate,Sodelavec
DocType: Asset Movement,Asset Movement,Gibanje sredstvo
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0} must be submitted,Delovni nalog {0} mora biti predložen
apps/erpnext/erpnext/accounts/page/pos/pos.js,New Cart,Nova košarico
DocType: Taxable Salary Slab,From Amount,Od zneska
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Item {0} is not a serialized Item,Postavka {0} ni serialized postavka
DocType: Leave Type,Encashment,Pritrditev
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.js,Select a company,Izberite podjetje
DocType: Delivery Settings,Delivery Settings,Nastavitve dostave
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Fetch Data,Pridobi podatke
apps/erpnext/erpnext/hr/doctype/leave_policy/leave_policy.py,Maximum leave allowed in the leave type {0} is {1},Največji dovoljeni dopust v tipu dopusta {0} je {1}
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Publish 1 Item,Objavite 1 kos
DocType: SMS Center,Create Receiver List,Ustvarite sprejemnik seznam
DocType: Student Applicant,LMS Only,Samo LMS
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available-for-use Date should be after purchase date,"Datum, ki je na voljo za uporabo, mora biti po datumu nakupa"
DocType: Vehicle,Wheels,kolesa
DocType: Packing Slip,To Package No.,Če želite Paket No.
DocType: Patient Relation,Family,Družina
DocType: Invoice Discounting,Invoice Discounting,Popust na račune
DocType: Sales Invoice Item,Deferred Revenue Account,Odloženi prihodki
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,Telecommunications,Telekomunikacije
apps/erpnext/erpnext/setup/doctype/company/test_company.py,No Account matched these filters: {},Noben račun se ni ujemal s temi filtri: {}
apps/erpnext/erpnext/accounts/party.py,Billing currency must be equal to either default company's currency or party account currency,Valuta za obračun mora biti enaka 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)"
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,Closing Balance,Zaključni saldo
DocType: Soil Texture,Loam,Loam
apps/erpnext/erpnext/controllers/accounts_controller.py,Row {0}: Due Date cannot be before posting date,Vrstica {0}: Datum roka ne more biti pred datumom objavljanja
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,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/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,For,Za
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Lahko 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
DocType: Leave Type,Earned Leave Frequency,Pogostost oddanih dopustov
apps/erpnext/erpnext/config/accounting.py,Tree of financial Cost Centers.,Drevo centrov finančnih stroškov.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Sub Type,Pod tip
DocType: Serial No,Delivery Document No,Dostava dokument št
DocType: Sales Order Item,Ensure Delivery Based on Produced Serial No,Zagotovite dostavo na podlagi izdelane serijske številke
DocType: Vital Signs,Furry,Furry
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,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}
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Add to Featured Item,Dodaj med predstavljene izdelke
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Dobili predmetov iz nakupa Prejemki
DocType: Serial No,Creation Date,Datum nastanka
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Target Location is required for the asset {0},Ciljna lokacija je potrebna za sredstvo {0}
DocType: GSTR 3B Report,November,Novembra
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,"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
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Material Consumption is not set in Manufacturing Settings.,Poraba materiala ni nastavljena v proizvodnih nastavitvah.
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,View all issues from {0},Oglejte si vse težave od {0}
DocType: Quality Inspection,MAT-QA-.YYYY.-,MAT-QA-YYYY-
DocType: Quality Meeting Table,Quality Meeting Table,Kakovostna tabela za sestanke
apps/erpnext/erpnext/templates/pages/help.html,Visit the forums,Obiščite forume
DocType: Student,Student Mobile Number,Študent mobilno številko
DocType: Item,Has Variants,Ima različice
DocType: Employee Benefit Claim,Claim Benefit For,Claim Benefit For
apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Posodobi odgovor
apps/erpnext/erpnext/public/js/utils.js,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
DocType: Quality Procedure Process,Quality Procedure Process,Postopek kakovosti postopka
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Batch ID is mandatory,Serija ID je obvezen
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Batch ID is mandatory,Serija ID je obvezen
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.js,Please select Customer first,Najprej izberite stranko
DocType: Sales Person,Parent Sales Person,Nadrejena Sales oseba
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,No items to be received are overdue,"Predmeti, ki jih želite prejeti, niso zapadli"
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The seller and the buyer cannot be the same,Prodajalec in kupec ne moreta biti isti
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,No views yet,Še ni ogledov
DocType: Project,Collect Progress,Zberite napredek
DocType: Delivery Note,MAT-DN-.YYYY.-,MAT-DN-YYYY-
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Select the program first,Najprej izberite program
DocType: Patient Appointment,Patient Age,Pacientova doba
apps/erpnext/erpnext/config/help.py,Managing Projects,Upravljanje projektov
DocType: Quiz,Latest Highest Score,Zadnji najvišji rezultat
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial no {0} has been already returned,Serijski št. {0} je bil že vrnjen
DocType: Supplier,Supplier of Goods or Services.,Dobavitelj blaga ali storitev.
DocType: Budget,Fiscal Year,Poslovno leto
DocType: Asset Maintenance Log,Planned,Načrtovano
apps/erpnext/erpnext/hr/utils.py,A {0} exists between {1} and {2} (,A {0} obstaja med {1} in {2} (
DocType: Vehicle Log,Fuel Price,gorivo Cena
DocType: BOM Explosion Item,Include Item In Manufacturing,Vključi izdelek v proizvodnjo
DocType: Bank Guarantee,Margin Money,Denar od razlike
DocType: Budget,Budget,Proračun
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Set Open,Nastavi odprto
apps/erpnext/erpnext/stock/doctype/item/item.py,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,"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"
DocType: Quality Review Table,Achieved,Doseženi
DocType: Student Admission,Application Form Route,Prijavnica pot
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,End Date of Agreement can't be less than today.,Končni datum sporazuma ne sme biti krajši kot danes.
apps/erpnext/erpnext/public/js/hub/components/CommentInput.vue,Ctrl + Enter to submit,Ctrl + Enter za oddajo
DocType: Healthcare Settings,Patient Encounters in valid days,Pacientovo srečanje v veljavnih dneh
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,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,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
apps/erpnext/erpnext/accounts/report/financial_statements.py,Cost Center: {0} does not exist,Mestno mesto: {0} ne obstaja
DocType: Item,Is Sales Item,Je Sales Postavka
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,Item Group Tree,Element Group Tree
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,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"
DocType: Asset,Insurance Start Date,Začetni datum zavarovanja
DocType: Salary Component,Flexible Benefits,Fleksibilne prednosti
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,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,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/setup/doctype/company/company.js,There were errors.,Tam so bile napake.
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Pin Code,PIN koda
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup defaults,Nastavitve privzetih nastavitev ni bilo mogoče
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,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
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Name / Number,Posodobi ime računa / številka
DocType: Naming Series,Current Value,Trenutna vrednost
apps/erpnext/erpnext/controllers/accounts_controller.py,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_plan/production_plan.py,{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,"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,This is based on stock movement. See {0} for details,Ta temelji na gibanju zalog. Glej {0} za podrobnosti
DocType: Pricing Rule,Selling,Prodaja
DocType: Payment Entry,Payment Order Status,Stanje plačilnega naloga
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} deducted against {2},Znesek {0} {1} odšteti pred {2}
DocType: Sales Person,Name and Employee ID,Ime in zaposlenih ID
DocType: Promotional Scheme,Promotional Scheme Product Discount,Popust na izdelke promocijske sheme
DocType: Website Item Group,Website Item Group,Spletna stran Element Group
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,No salary slip found to submit for the above selected criteria OR salary slip already submitted,"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_with_account_number.py,Duties and Taxes,Dajatve in davki
DocType: Projects Settings,Projects Settings,Nastavitve projektov
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,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,{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: Clinical Procedure,HLC-CPR-.YYYY.-,HLC-CPR-.GGGG.-
DocType: Purchase Order Item,Material Request Item,Material Zahteva Postavka
apps/erpnext/erpnext/config/buying.py,Tree of Item Groups.,Drevo skupin artiklov.
DocType: Production Plan,Total Produced Qty,Skupno število proizvedenih količin
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,No reviews yet,Še ni mnenja
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Cannot refer row number greater than or equal to current row number for this Charge type,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,Elementna Zgodovina nakupov
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,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
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Vehicle Type,Vrsta vozila
DocType: Sales Invoice Payment,Base Amount (Company Currency),Osnovna Znesek (družba Valuta)
DocType: Purchase Invoice,Registered Regular,Registrirano redno
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,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
DocType: Shopify Settings,status html,status html
apps/erpnext/erpnext/setup/doctype/company/company.js,Delete all the Transactions for this Company,Izbriši vse transakcije za to družbo
DocType: Designation,Required Skills,Zahtevane veščine
DocType: Inpatient Record,O Positive,O Pozitivno
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Investments,Naložbe
DocType: Issue,Resolution Details,Resolucija Podrobnosti
DocType: Leave Ledger Entry,Transaction Type,Vrsta transakcije
DocType: Item Quality Inspection Parameter,Acceptance Criteria,Merila sprejemljivosti
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Material Requests in the above table,Vnesite Material Prošnje v zgornji tabeli
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments available for Journal Entry,Za vnose v dnevnik ni na voljo vračil
DocType: Hub Tracked Item,Image List,Seznam slik
DocType: Item Attribute,Attribute Name,Ime atributa
DocType: Subscription,Generate Invoice At Beginning Of Period,Ustvarite račun na začetku obdobja
DocType: BOM,Show In Website,Pokaži V Website
DocType: 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/accounts/doctype/budget/budget.py,Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},Drugi proračunski zapis &#39;{0}&#39; že obstaja {1} &#39;{2}&#39; in račun &#39;{3}&#39; za proračunsko leto {4}
apps/erpnext/erpnext/config/projects.py,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,{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
DocType: Woocommerce Settings,Tax Account,Davčni račun
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,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,Make Payment,Izvedi plačilo
DocType: Room,Room Name,soba Ime
DocType: Prescription Duration,Prescription Duration,Trajanje recepta
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","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,Customer Addresses And Contacts,Naslovi strank in kontakti
DocType: Homepage Section,Section Cards,Karte oddelka
,Campaign Efficiency,kampanja Učinkovitost
DocType: Discussion,Discussion,Diskusija
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Sales Order Submission,Ob oddaji prodajnega naročila
DocType: Bank Transaction,Transaction ID,Transaction ID
DocType: Payroll Entry,Deduct Tax For Unsubmitted Tax Exemption Proof,Davek od odbitka za neosnovan dokaz o davčni oprostitvi
DocType: Volunteer,Anytime,Kadarkoli
DocType: Bank Account,Bank Account No,Bančni račun št
DocType: Employee Tax Exemption Proof Submission,Employee Tax Exemption Proof Submission,Predložitev dokazila o oprostitvi davka na zaposlene
DocType: Patient,Surgical History,Kirurška zgodovina
DocType: Bank Statement Settings Item,Mapped Header,Mapped Header
DocType: Employee,Resignation Letter Date,Odstop pismo Datum
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Pricing Rules are further filtered based on quantity.,Cenovne Pravila so dodatno filtriran temelji na količini.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,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,Please set the Date Of Joining for employee {0},"Prosimo, da določi datum Vstop za zaposlenega {0}"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Please enter Difference Account,Vnesite račun za razlike
DocType: Inpatient Record,Discharge,praznjenje
DocType: Task,Total Billing Amount (via Time Sheet),Skupni znesek plačevanja (preko Čas lista)
apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js,Create Fee Schedule,Ustvari urnik pristojbin
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customer Revenue,Ponovite Customer Prihodki
DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
DocType: Quiz,Enter 0 to waive limit,Vnesite 0 za omejitev omejitve
DocType: Bank Statement Settings,Mapped Items,Kartirani elementi
DocType: Amazon MWS Settings,IT,IT
DocType: Chapter,Chapter,Poglavje
,Fixed Asset Register,Register nepremičnega premoženja
apps/erpnext/erpnext/utilities/user_progress.py,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,Select BOM and Qty for Production,Izberite BOM in Količina za proizvodnjo
DocType: Asset,Depreciation Schedule,Amortizacija Razpored
DocType: Bank Reconciliation Detail,Against Account,Proti račun
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,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,Please set the Default Cost Center in {0} company.,Center za privzete stroške nastavite v {0} podjetju.
apps/erpnext/erpnext/projects/doctype/project/project.py,Daily Project Summary for {0},Dnevni povzetek projekta za {0}
DocType: Item,Has Batch No,Ima številko serije
apps/erpnext/erpnext/public/js/utils.js,Annual Billing: {0},Letni obračun: {0}
DocType: Shopify Webhook Detail,Shopify Webhook Detail,Nakup podrobnosti nakupa
apps/erpnext/erpnext/config/accounting.py,Goods and Services Tax (GST India),Davčna blago in storitve (DDV Indija)
DocType: Delivery Note,Excise Page Number,Trošarinska Številka strani
DocType: Asset,Purchase Date,Datum nakupa
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Could not generate Secret,Ni mogoče ustvariti Skrivnosti
DocType: Volunteer,Volunteer Type,Volunteer Type
DocType: Payment Request,ACC-PRQ-.YYYY.-,ACC-PRQ-.YYYY.-
DocType: Shift Assignment,Shift Type,Vrsta premika
DocType: Student,Personal Details,Osebne podrobnosti
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,Export E-Invoices,Izvozi e-račune
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,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: Pricing Rule,Apply Rule On Brand,Uporabi pravilo o blagovni znamki
DocType: Task,Actual End Date (via Time Sheet),Dejanski končni datum (preko Čas lista)
apps/erpnext/erpnext/projects/doctype/task/task.py,Cannot close task {0} as its dependant task {1} is not closed.,"Naloge ni mogoče zapreti {0}, ker njena odvisna naloga {1} ni zaprta."
DocType: Soil Texture,Soil Type,Vrsta tal
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} against {2} {3},Znesek {0} {1} proti {2} {3}
,Quotation Trends,Trendi ponudb
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Item Group not mentioned in item master for item {0},"Element Group, ki niso navedeni v točki mojster za postavko {0}"
DocType: GoCardless Mandate,GoCardless Mandate,GoCardless mandat
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To account must be a Receivable account,Bremenitev računa mora biti Terjatve račun
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Select finance book for the item {0} at row {1},Izberite knjigo financ za postavko {0} v vrstici {1}
DocType: Shipping Rule,Shipping Amount,Znesek Dostave
DocType: Supplier Scorecard Period,Period Score,Obdobje obdobja
apps/erpnext/erpnext/public/js/event.js,Add Customers,Dodaj stranke
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Pending Amount,Dokler Znesek
DocType: Lab Test Template,Special,Poseben
DocType: Loyalty Program,Conversion Factor,Faktor pretvorbe
DocType: Purchase Order,Delivered,Dostavljeno
,Vehicle Expenses,Stroški vozil
DocType: Healthcare Settings,Create Lab Test(s) on Sales Invoice Submit,Ustvari laboratorijske teste na računu za prodajo
DocType: Serial No,Invoice Details,Podrobnosti na računu
apps/erpnext/erpnext/regional/india/utils.py,Salary Structure must be submitted before submission of Tax Ememption Declaration,Strukturo plače je treba predložiti pred predložitvijo izjave o oprostitvi davka
DocType: Grant Application,Show on Website,Prikaži na spletni strani
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Start on,Začni
DocType: Hub Tracked Item,Hub Category,Kategorija vozlišča
DocType: Purchase Invoice,SEZ,SEZ
DocType: Purchase Receipt,Vehicle Number,Število vozil
DocType: Loan,Loan Amount,Znesek posojila
DocType: Student Report Generation Tool,Add Letterhead,Dodaj pisemsko glavo
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,Row {0}: Bill of Materials not found for the Item {1},Vrstica {0}: Kosovnica nismo našli v postavki {1}
DocType: Contract Fulfilment Checklist,Requirement,Zahteva
DocType: Journal Entry,Accounts Receivable,Terjatve
DocType: Quality Goal,Objectives,Cilji
DocType: Travel Itinerary,Meal Preference,Prednost hrane
,Supplier-Wise Sales Analytics,Dobavitelj-Wise Prodajna Analytics
apps/erpnext/erpnext/accounts/doctype/subscription_plan/subscription_plan.py,Billing Interval Count cannot be less than 1,Interval števila računov ne sme biti manjši od 1
DocType: Purchase Invoice,Availed ITC Central Tax,Uporabil centralni davčni sistem za ITC
DocType: Sales Invoice,Company Address Name,Naslov podjetja Ime
DocType: Work Order,Use Multi-Level BOM,Uporabite Multi-Level BOM
DocType: Bank Reconciliation,Include Reconciled Entries,Vključi usklajene vnose
apps/erpnext/erpnext/accounts/doctype/bank_transaction/bank_transaction.py,The total allocated amount ({0}) is greated than the paid amount ({1}).,Skupni dodeljeni znesek ({0}) je podmazan od plačanega zneska ({1}).
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
apps/erpnext/erpnext/config/accounting.py,Accounting Masters,Mojstri računovodstva
DocType: Salary Slip,net pay info,net info plačilo
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CESS Amount,CESS Znesek
DocType: Woocommerce Settings,Enable Sync,Omogoči sinhronizacijo
DocType: Tax Withholding Rate,Single Transaction Threshold,Enotni transakcijski prag
DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Ta vrednost se posodablja na seznamu Privzeta prodajna cena.
apps/erpnext/erpnext/templates/pages/cart.html,Your cart is Empty,Vaš nakupovalni voziček je prazen
DocType: Email Digest,New Expenses,Novi stroški
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Cannot Optimize Route as Driver Address is Missing.,"Ne morem optimizirati poti, ker manjka naslov gonilnika."
DocType: Shareholder,Shareholder,Delničar
DocType: Purchase Invoice,Additional Discount Amount,Dodatni popust Količina
DocType: Cash Flow Mapper,Position,Položaj
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Get Items from Prescriptions,Pridobi elemente iz receptov
DocType: Patient,Patient Details,Podrobnosti bolnika
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Nature Of Supplies,Narava blaga
DocType: Inpatient Record,B Positive,B Pozitivni
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of previous claimed\
			amount",Najvišja korist zaposlenega {0} presega {1} za vsoto {2} prejšnje zahtevane količine
apps/erpnext/erpnext/buying/report/subcontracted_raw_materials_to_be_transferred/subcontracted_raw_materials_to_be_transferred.py,Transferred Quantity,Prenesena količina
apps/erpnext/erpnext/controllers/accounts_controller.py,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","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,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
DocType: Quality Meeting Agenda,Quality Meeting Agenda,Agenda o kakovostnem srečanju
apps/erpnext/erpnext/accounts/doctype/account/account.js,Group to Non-Group,Skupina Non-Group
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Sports,Šport
DocType: Leave Control Panel,Employee (optional),Zaposleni (neobvezno)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Material Request {0} submitted.,Prošnja za material {0} vložena.
DocType: Loan Type,Loan Name,posojilo Ime
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Actual,Skupaj Actual
DocType: Chart of Accounts Importer,Chart Preview,Predogled grafikona
DocType: Attendance,Shift,Shift
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,Enter API key in Google Settings.,V Googlove nastavitve vnesite ključ API.
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Create Journal Entry,Ustvari vnos v časopis
DocType: Student Siblings,Student Siblings,Študentski Bratje in sestre
DocType: Subscription Plan Detail,Subscription Plan Detail,Podrobnosti o naročniškem načrtu
DocType: Quality Objective,Unit,Enota
apps/erpnext/erpnext/stock/get_item_details.py,Please specify Company,"Prosimo, navedite Company"
,Customer Acquisition and Loyalty,Stranka Pridobivanje in zvestobe
DocType: Issue,Response By Variance,Odziv po različici
DocType: Asset Maintenance Task,Maintenance Task,Vzdrževalna naloga
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Please set B2C Limit in GST Settings.,Nastavite omejitev B2C v nastavitvah GST.
DocType: Marketplace Settings,Marketplace Settings,Nastavitve tržnice
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,"Skladišče, kjer ste vzdrževanje zalog zavrnjenih predmetov"
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Publish {0} Items,Objavite {0} Artikle
apps/erpnext/erpnext/setup/utils.py,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,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,{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,Expense Claims,Odhodkov Terjatve
DocType: Issue,Support,Podpora
DocType: Employee Tax Exemption Declaration,Total Exemption Amount,Skupni znesek oprostitve
DocType: Content Question,Question Link,Povezava z vprašanji
,BOM Search,BOM Iskanje
DocType: Accounting Dimension Detail,Mandatory For Balance Sheet,Obvezno za bilanco stanja
DocType: Project,Total Consumed Material Cost  (via Stock Entry),Skupni stroški porabljenega materiala (preko zaloge na borzi)
DocType: Subscription,Subscription Period,Obdobje naročnine
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js,To Date cannot be less than From Date,Datum ne sme biti krajši od datuma
,Delayed Order Report,Poročilo o zamudnem naročilu
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,Please specify currency in Company,"Prosimo, navedite valuto v družbi"
DocType: Workstation,Wages per hour,Plače na uro
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfigurirajte {0}
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Stranka&gt; Skupina kupcev&gt; Ozemlje
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,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,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
apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Račun {0} ni veljaven. Valuta računa mora biti {1}
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,From Date {0} cannot be after employee's relieving Date {1},Od datuma {0} ne more biti po razrešitvi delavca Datum {1}
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Create Payment Entries,Ustvari plačilne vnose
DocType: Supplier,Is Internal Supplier,Je notranji dobavitelj
DocType: Employee,Create User Permission,Ustvarite dovoljenje za uporabnika
DocType: Employee Benefit Claim,Employee Benefit Claim,Zahtevek za zaposlene
DocType: Healthcare Settings,Remind Before,Opomni pred
apps/erpnext/erpnext/buying/utils.py,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,"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: Loyalty Program,1 Loyalty Points = How much base currency?,1 Točke za zvestobe = Koliko osnovna valuta?
DocType: Salary Component,Deduction,Odbitek
DocType: Item,Retain Sample,Ohrani vzorec
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,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/public/js/hub/pages/Buying.vue,This page keeps track of items you want to buy from sellers.,"Ta stran spremlja predmete, ki jih želite kupiti pri prodajalcih."
apps/erpnext/erpnext/stock/get_item_details.py,Item Price added for {0} in Price List {1},Postavka Cena dodana za {0} v Ceniku {1}
DocType: Delivery Stop,Order Information,Informacije o naročilu
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js,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,In Production,V izdelavi
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Difference Amount must be zero,Razlika Znesek mora biti nič
DocType: Project,Gross Margin,Gross Margin
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} applicable after {1} working days,{0} po {1} delovnih dneh
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Please enter Production Item first,"Prosimo, da najprej vnesete Production artikel"
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,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,disabled user,onemogočena uporabnik
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Quotation,Ponudba
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Cannot set a received RFQ to No Quote,Prejeti RFQ ni mogoče nastaviti na nobeno ceno
DocType: Salary Slip,Total Deduction,Skupaj Odbitek
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Select an account to print in account currency,"Izberite račun, ki ga želite natisniti v valuti računa"
DocType: BOM,Transfer Material Against,Prenesite gradivo proti
,Production Analytics,proizvodne Analytics
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py,This is based on transactions against this Patient. See timeline below for details,To temelji na transakcijah proti temu bolniku. Podrobnosti si oglejte spodaj
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.py,Loan Start Date and Loan Period are mandatory to save the Invoice Discounting,Datum začetka posojila in obdobje posojila sta obvezna za varčevanje s popustom na računu
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Cost Updated,Stroškovno Posodobljeno
apps/erpnext/erpnext/regional/india/utils.py,Vehicle Type is required if Mode of Transport is Road,"Vrsta vozila je potrebna, če je način prevoza cestni"
DocType: Inpatient Record,Date of Birth,Datum rojstva
DocType: Quality Action,Resolutions,Ločljivosti
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,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
DocType: Customer Credit Limit,Customer Credit Limit,Omejitev kupca
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Assessment Plan Name,Ime načrta ocenjevanja
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Target Details,Podrobnosti cilja
apps/erpnext/erpnext/regional/italy/setup.py,"Applicable if the company is SpA, SApA or SRL","Uporablja se, če je podjetje SpA, SApA ali SRL"
DocType: Work Order Operation,Work Order Operation,Delovni nalog
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid SSL certificate on attachment {0},Opozorilo: Neveljavno potrdilo SSL za pritrditev {0}
apps/erpnext/erpnext/regional/italy/setup.py,Set this if the customer is a Public Administration company.,"To nastavite, če je stranka podjetje javne uprave."
apps/erpnext/erpnext/utilities/activation.py,"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: Work 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,Job Description,Opis dela
DocType: Student Applicant,Applied,Applied
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Details of Outward Supplies and inward supplies liable to reverse charge,"Podrobnosti o zunanjih potrebščinah in notranjih zalogah, za katere je mogoče povratno polnjenje"
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,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,Guardian2 Name,Ime skrbnika2
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Root Company,Root Company
DocType: Attendance,Attendance Request,Zahteva za udeležbo
DocType: Purchase Invoice,02-Post Sale Discount,Popust za prodajo po pošti
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."
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,You can't redeem Loyalty Points having more value than the Grand Total.,"Točke zvestobe ne morete izkoristiti, če imajo večjo vrednost kot Grand Total."
DocType: Department Approver,Approver,Odobritelj
apps/erpnext/erpnext/selling/report/pending_so_items_for_purchase_request/pending_so_items_for_purchase_request.py,SO Qty,SO Kol
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,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: Employee,Health Insurance,Zdravstveno zavarovanje
DocType: Asset Repair,Manufacturing Manager,Upravnik proizvodnje
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,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,User {0} already exists,Uporabnik {0} že obstaja
apps/erpnext/erpnext/hooks.py,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,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/accounts/doctype/bank_account/bank_account.py,Company is manadatory for company account,Podjetje je manipulativno za račun podjetja
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,"Item Code, warehouse, quantity are required on row","Koda postavke, skladišče, količina sta potrebna v vrstici"
DocType: Bank Guarantee,Supplier,Dobavitelj
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Get From,Get From
apps/erpnext/erpnext/hr/doctype/department/department.js,This is a root department and cannot be edited.,To je korenski oddelek in ga ni mogoče urejati.
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show Payment Details,Prikaži podatke o plačilu
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Duration in Days,Trajanje v dnevih
DocType: C-Form,Quarter,Quarter
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Miscellaneous Expenses,Razni stroški
DocType: Global Defaults,Default Company,Privzeto Podjetje
DocType: Company,Transactions Annual History,Letno zgodovino transakcij
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Bank account '{0}' has been synchronized,Bančni račun &quot;{0}&quot; je bil sinhroniziran
apps/erpnext/erpnext/controllers/stock_controller.py,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: Bank,Bank Name,Ime Banke
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Leave the field empty to make purchase orders for all suppliers,"Pustite polje prazno, da boste lahko naročili naročila za vse dobavitelje"
DocType: Healthcare Practitioner,Inpatient Visit Charge Item,Bolniška obtočna obrestna točka
DocType: Vital Signs,Fluid,Tekočina
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,Number of Interaction,Število interakcij
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Number of Interaction,Število interakcij
DocType: GSTR 3B Report,February,Februarja
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant Settings,Nastavitve različice postavke
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Company...,Izberite Company ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} is mandatory for Item {1},{0} je obvezen za postavko {1}
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"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/eway_bill/eway_bill.py,Please set GST Accounts in GST Settings,Nastavite GST račune v nastavitvah GST
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Type of Business,Vrsta podjetja
DocType: Sales Invoice,Consumer,Potrošniški
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,"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,Cost of New Purchase,Stroški New Nakup
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,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),Stopnja (Valuta podjetja)
DocType: Student Guardian,Others,Drugi
DocType: Subscription,Discounts,Popusti
DocType: Bank Transaction,Unallocated Amount,nerazporejena Znesek
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,"Prosimo, omogočite veljavno naročilo in veljavne stroške rezervacije"
apps/erpnext/erpnext/templates/includes/product_page.js,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,No more updates,Nič več posodobitve
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Ne morete izbrati vrsto naboja kot &quot;On prejšnje vrstice Znesek&quot; ali &quot;Na prejšnje vrstice Total&quot; za prvi vrsti
DocType: Purchase Order,PUR-ORD-.YYYY.-,PUR-ORD-YYYY-
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py,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,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,Banking,Bančništvo
apps/erpnext/erpnext/utilities/activation.py,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
DocType: Payment Request,Transaction Details,Podrobnosti transakcije
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule' to get schedule,"Prosimo, kliknite na &quot;ustvarjajo Seznamu&quot;, da bi dobili razpored"
DocType: Item,"Purchase, Replenishment Details","Podrobnosti o nakupu, dopolnitvi"
DocType: Products Settings,Enable Field Filters,Omogoči filtre polja
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot be Purchase Item also","&quot;Artikel, ki ga zagotavlja stranka&quot;, tudi ni mogoče kupiti"
DocType: Blanket Order Item,Ordered Quantity,Naročeno Količina
apps/erpnext/erpnext/public/js/setup_wizard.js,"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/regional/india/utils.py,Invalid {0}! The check digit validation has failed. ,Neveljaven {0}! Validacija kontrolne številke ni uspela.
DocType: Item Default,Purchase Defaults,Nakup privzete vrednosti
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Samodejno ustvarjanje kreditne kartice ni bilo mogoče samodejno ustvariti, počistite potrditveno polje »Issue Credit Credit« in znova pošljite"
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Added to Featured Items,Dodano med predstavljenimi predmeti
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py,Profit for the year,Dobiček za leto
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: računovodski 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/accounting.py,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,{0} against Sales Order {1},{0} za Naročilnico {1}
DocType: Account,Fixed Asset,Osnovno sredstvo
DocType: Amazon MWS Settings,After Date,Po datumu
apps/erpnext/erpnext/config/help.py,Serialized Inventory,Zaporednimi Inventory
,Department Analytics,Oddelek Analytics
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Email not found in default contact,V privzetem stiku ni mogoče najti e-pošte
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Generate Secret,Ustvari skrivnost
DocType: Question,Question,Vprašanje
DocType: 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,{0} Student Groups created.,{0} skupine študentov ustvarjene
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,{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,Program in the Fee Structure and Student Group {0} are different.,Program v strukturi pristojbin in študentski skupini {0} je drugačen.
DocType: Bank Statement Transaction Entry,Receivable Account,Terjatev račun
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Valid From Date must be lesser than Valid Upto Date.,Velja od datuma mora biti manjši od veljavnega datuma uveljavitve.
DocType: Employee Skill,Evaluation Date,Datum ocenjevanja
apps/erpnext/erpnext/controllers/accounts_controller.py,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/help.py,Sales Order to Payment,Sales Order do plačila
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,CEO,direktor
DocType: Purchase Invoice,With Payment of Tax,S plačilom davka
DocType: Expense Claim Detail,Expense Claim Detail,Expense Zahtevek Detail
apps/erpnext/erpnext/education/utils.py,You are not allowed to enroll for this course,Nimate dovoljenja za vpis na ta tečaj
DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,Trojnih dobavitelja
DocType: Exchange Rate Revaluation Account,New Balance In Base Currency,Nova bilanca v osnovni valuti
DocType: Location,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,Please select correct account,"Prosimo, izberite ustrezen račun"
DocType: Salary Structure Assignment,Salary Structure Assignment,Dodelitev strukture plač
DocType: Purchase Invoice Item,Weight UOM,Teža UOM
apps/erpnext/erpnext/config/accounting.py,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,Show Variant Attributes,Prikaži lastnosti različic
DocType: Student,Blood Group,Blood Group
DocType: Purchase Invoice Item,Page Break,Page Break
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,The payment gateway account in plan {0} is different from the payment gateway account in this payment request,Račun plačilnega prehoda v načrtu {0} se razlikuje od računa prehoda plačila v tej zahtevi za plačilo
DocType: Course,Course Name,Ime predmeta
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py,No Tax Withholding data found for the current Fiscal Year.,"Ni podatkov o davčnem primanjkljaju, ugotovljenem za tekoče poslovno leto."
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_with_account_number.py,Office Equipments,Pisarniška oprema
DocType: Pricing Rule,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,Electronics,Electronics
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Debit ({0}),Debet ({0})
DocType: BOM,Allow Same Item Multiple Times,Dovoli isti predmet večkrat
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,Full-time,Polni delovni čas
DocType: Payroll Entry,Employees,zaposleni
DocType: Question,Single Correct Answer,Enotni pravilen odgovor
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
apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html,Payment Confirmation,Potrdilo plačila
apps/erpnext/erpnext/regional/india/utils.py,Unsupported GST Category for e-Way Bill JSON generation,Nepodprta kategorija GST za e-Way Bill JSON generacije
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: Material Request Item,Received Quantity,Prejeta količina
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,To Date must be greater than From Date,Do datuma mora biti večje od datuma
DocType: Stock Entry,Total Incoming Value,Skupaj Dohodni Vrednost
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To is required,Bremenitev je potrebno
DocType: Clinical Procedure,Inpatient Record,Hišni bolezen
apps/erpnext/erpnext/utilities/activation.py,"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,Purchase Price List,Nakup Cenik
DocType: Communication Medium Timeslot,Employee Group,Skupina zaposlenih
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Date of Transaction,Datum transakcije
apps/erpnext/erpnext/config/buying.py,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: Employee,Default Shift,Privzeti premik
DocType: Payment Reconciliation,Payment Reconciliation,Uskladitev plačil
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select Incharge Person's name,"Prosimo, izberite ime zadolžen osebe"
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Technology,Tehnologija
apps/erpnext/erpnext/public/js/utils.js,Total Unpaid: {0},Skupaj neplačano: {0}
DocType: BOM Website Operation,BOM Website Operation,BOM Spletna stran Operacija
DocType: Bank Statement Transaction Payment Item,outstanding_amount,izstopajoč_števek
DocType: Supplier Scorecard,Supplier Score,Ocen dobavitelja
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Admission,Sprejem razporeda
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Total Payment Request amount cannot be greater than {0} amount,Skupni znesek zahtevka za plačilo ne sme biti večji od {0} zneska
DocType: Tax Withholding Rate,Cumulative Transaction Threshold,Skupni prag transakcij
DocType: Promotional Scheme Price Discount,Discount Type,Vrsta popusta
DocType: Purchase Invoice Item,Is Free Item,Je brezplačen izdelek
DocType: Buying Settings,Percentage you are allowed to transfer more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to transfer 110 units.,"Odstotek, ki ga lahko prenesete več glede na naročeno količino. Na primer: Če ste naročili 100 enot. in vaš dodatek znaša 10%, potem vam je dovoljeno prenašati 110 enot."
DocType: Supplier,Warn RFQs,Opozori RFQs
apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Explore,Razišči
DocType: BOM,Conversion Rate,Stopnja konverzije
apps/erpnext/erpnext/www/all-products/index.html,Product Search,Iskanje
,Bank Remittance,Bančno nakazilo
DocType: Cashier Closing,To Time,Time
DocType: Invoice Discounting,Loan End Date,Končni datum posojila
apps/erpnext/erpnext/hr/utils.py,) for {0},) za {0}
DocType: Authorization Rule,Approving Role (above authorized value),Odobritvi vloge (nad pooblaščeni vrednosti)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Payable account,Credit Za računu mora biti plačljivo račun
DocType: Loan,Total Amount Paid,Skupni znesek plačan
DocType: Asset,Insurance End Date,Končni datum zavarovanja
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,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"
DocType: Pick List,STO-PICK-.YYYY.-,STO-PICK-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,Budget List,Proračunski seznam
DocType: Campaign,Campaign Schedules,Časovni razpored akcij
DocType: Job Card Time Log,Completed Qty,Končano število
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"For {0}, only debit accounts can be linked against another credit entry","Za {0}, lahko le debetne račune povezati proti drugemu knjiženje"
DocType: Manufacturing Settings,Allow Overtime,Dovoli Nadurno delo
DocType: Training Event Employee,Training Event Employee,Dogodek usposabljanje zaposlenih
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,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/practitioner_schedule/practitioner_schedule.js,Add Time Slots,Dodaj časovne reže
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,{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
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Number of root accounts cannot be less than 4,Število korenskih računov ne sme biti manjše od 4
DocType: Training Event,Advance,Napredovanje
apps/erpnext/erpnext/config/integrations.py,GoCardless payment gateway settings,GoCardless nastavitve plačilnih prehodov
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Exchange Gain/Loss,Exchange dobiček / izguba
DocType: Opportunity,Lost Reason,Razlog za izgubljeno
DocType: Amazon MWS Settings,Enable Amazon,Omogoči Amazon
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Account {1} does not belong to company {2},Vrstica # {0}: Račun {1} ne pripada podjetju {2}
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Unable to find DocType {0},Datoteke DocType {0} ni mogoče najti
apps/erpnext/erpnext/public/js/templates/address_list.html,New Address,New Naslov
DocType: Quality Inspection,Sample Size,Velikost vzorca
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Please enter Receipt Document,Vnesite Prejem dokumenta
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,All items have already been invoiced,Vsi predmeti so bili že obračunano
apps/erpnext/erpnext/hr/report/employee_leave_balance_summary/employee_leave_balance_summary.py,Leaves Taken,Odvzeti listi
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,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,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/hr/doctype/leave_allocation/leave_allocation.py,Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,Skupno dodeljeni listi so več dni kot največja dodelitev {0} tipa dopusta za zaposlenega {1} v obdobju
DocType: Branch,Branch,Podružnica
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Other outward supplies(Nil rated,Exempted)","Druge zunanje dobave (ničelno, oproščeno)"
DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
DocType: Delivery Trip,Fulfillment User,Uporabnik izpolnjevanja
apps/erpnext/erpnext/config/settings.py,Printing and Branding,Tiskanje in Branding
DocType: Company,Total Monthly Sales,Skupna mesečna prodaja
DocType: Course Activity,Enrollment,Vpis
DocType: Payment Request,Subscription Plans,Naročni načrti
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,Serial No {0} not found,Serijska št {0} ni bilo mogoče najti
DocType: Fee Schedule Program,Fee Schedule Program,Program urnika
DocType: Fee Schedule Program,Student Batch,študent serije
DocType: Pricing Rule,Advanced Settings,Napredne nastavitve
DocType: Supplier Scorecard Scoring Standing,Min Grade,Min razred
DocType: Healthcare Service Unit Type,Healthcare Service Unit Type,Vrsta enote zdravstvenega varstva
DocType: Training Event Employee,Feedback Submitted,povratne informacije Objavil
apps/erpnext/erpnext/projects/doctype/project/project.py,You have been invited to collaborate on the project: {0},Ti so bili povabljeni k sodelovanju na projektu: {0}
DocType: Supplier Group,Parent Supplier Group,Matična skupina dobaviteljev
DocType: Email Digest,Purchase Orders to Bill,Naročila za nakup
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Accumulated Values in Group Company,Akumulirane vrednosti v družbi v skupini
DocType: Leave Block List Date,Block Date,Block Datum
DocType: Item,You can use any valid Bootstrap 4 markup in this field. It will be shown on your Item Page.,V tem polju lahko uporabite katero koli veljavno oznako Bootstrap 4. To bo prikazano na strani izdelka.
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Outward taxable supplies(other than zero rated, nil rated and exempted","Dobavne obdavčljive dobave (razen ničelne, nične in oproščene)"
DocType: Crop,Crop,Pridelek
DocType: Purchase Receipt,Supplier Delivery Note,Opomba: dobavitelj dostava
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Apply Now,Prijavi se zdaj
DocType: Employee Tax Exemption Proof Submission Detail,Type of Proof,Vrsta dokazila
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html,Actual Qty {0} / Waiting Qty {1},Dejanska Kol {0} / čakajoči Kol {1}
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html,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/settings.py,"Create and manage daily, weekly and monthly email digests.","Ustvarjanje in upravljanje dnevne, tedenske in mesečne email prebavlja."
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_dashboard.py,This is based on transactions against this Sales Person. See timeline below for details,To temelji na transakcijah proti tej prodajni osebi. Podrobnosti si oglejte spodaj
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_with_account_number.py,Buildings,zgradbe
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Leaves has been granted sucessfully,Listi so bili uspešno dodeljeni
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Invoice,Nov račun
DocType: Products Settings,Enable Attribute Filters,Omogoči filtre atributov
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,Submit Salary Slip,Predloži plačilni list
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Na čakanju
apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Karakter mora imeti vsaj eno pravilno možnost
apps/erpnext/erpnext/hooks.py,Purchase Orders,Naročila
DocType: Account,Inter Company Account,Inter Company račun
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Uvoz v večjih količinah
DocType: Sales Partner,Address & Contacts,Naslov &amp; Kontakti
DocType: SMS Log,Sender Name,Sender Name
DocType: Vital Signs,Very Hyper,Zelo Hyper
DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Kriteriji za analizo kmetijstva
DocType: HR Settings,Leave Approval Notification Template,Zapusti predlogo za odobritev odobritve
DocType: POS Profile,[Select],[Izberite]
DocType: Staffing Plan Detail,Number Of Positions,Število položajev
DocType: Vital Signs,Blood Pressure (diastolic),Krvni tlak (diastolični)
apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Izberite stranko.
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_with_account_number.py,Softwares,Programska oprema
apps/erpnext/erpnext/crm/doctype/lead/lead.py,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/accounts/page/pos/pos.js,Select Batch No,Izberite Serija št
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Invalid {0}: {1},Neveljavna {0}: {1}
,GSTR-1,GSTR-1
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
DocType: Asset,Policy number,Številka politike
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,'From Date' is required,"Zahtevano je ""Od datuma"""
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign to Employees,Dodeljeno zaposlenim
DocType: Bank Transaction,Reference Number,Referenčna številka
DocType: Employee,New Workplace,Novo delovno mesto
DocType: Retention Bonus,Retention Bonus,Zadrževalni bonus
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Material Consumption,Poraba materiala
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Closed,Nastavi kot Zaprto
apps/erpnext/erpnext/stock/get_item_details.py,No Item with Barcode {0},Ne Postavka s črtno kodo {0}
DocType: Normal Test Items,Require Result Value,Zahtevajte vrednost rezultata
DocType: Purchase Invoice,Pricing Rules,Pravila cen
DocType: Item,Show a slideshow at the top of the page,Prikaži diaprojekcijo na vrhu strani
DocType: Tax Withholding Rate,Tax Withholding Rate,Davčna stopnja zadržanja
DocType: Pricing Rule,Max Amt,Max Amt
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Boms,Boms
apps/erpnext/erpnext/stock/doctype/item/item.py,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,Ageing Based On,"Staranje, ki temelji na"
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Appointment cancelled,Imenovanje je preklicano
DocType: Item,End of Life,End of Life
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Travel,Potovanja
DocType: Student Report Generation Tool,Include All Assessment Group,Vključi vse ocenjevalne skupine
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,No active or default Salary Structure found for employee {0} for the given dates,"Ni 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
DocType: Leave Type,Calculated in days,Izračunano v dneh
DocType: Call Log,Received By,Prejeto od
DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Podrobnosti o predlogi za kartiranje denarnega toka
apps/erpnext/erpnext/config/non_profit.py,Loan Management,Upravljanje posojil
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,Update Cost,Posodobitev Stroški
DocType: Item Reorder,Item Reorder,Postavka Preureditev
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,GSTR3B-Form,Obrazec GSTR3B
DocType: Sales Invoice,Mode of Transport,Način prevoza
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Show Salary Slip,Prikaži Plača listek
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Transfer Material,Prenos Material
DocType: Fees,Send Payment Request,Pošiljanje zahtevka za plačilo
DocType: Travel Request,Any other details,Kakšne druge podrobnosti
DocType: Water Analysis,Origin,Izvor
apps/erpnext/erpnext/controllers/status_updater.py,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,"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,Please set recurring after saving,"Prosim, nastavite ponavljajočih se po shranjevanju"
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,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
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.js,Show Warehouse-wise Stock,Pokaži skladišče
DocType: Soil Texture,Clay,Glina
DocType: Course Topic,Topic,tema
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Financing,Denarni tok iz financiranja
DocType: Budget Account,Budget Account,proračun računa
DocType: Quality Inspection,Verified By,Verified by
DocType: Travel Request,Name of Organizer,Ime organizatorja
apps/erpnext/erpnext/setup/doctype/company/company.py,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","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: Clinical Procedure,Is Invoiced,Je fakturiran
apps/erpnext/erpnext/setup/doctype/company/company.js,Create Tax Template,Ustvari davčno predlogo
DocType: Stock Entry,Purchase Receipt No,Potrdilo o nakupu Ne
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Earnest Money,Kapara
DocType: Sales Invoice, Shipping Bill Number,Številka naročila
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Salary Slip,Ustvarite plačilnega lista
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Traceability,sledljivost
DocType: Asset Maintenance Log,Actions performed,Izvedeni ukrepi
DocType: Cash Flow Mapper,Section Leader,Oddelek Leader
DocType: Sales Invoice,Transport Receipt No,Prevozni list št
DocType: Quiz Activity,Pass,Prehod
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Please add the account to root level Company - ,Dodajte račun na korensko raven Podjetje -
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Source of Funds (Liabilities),Vir sredstev (obveznosti)
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Source and Target Location cannot be same,Izvorna in ciljna lokacija ne moreta biti enaka
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Količina v vrstici {0} ({1}) mora biti enaka kot je bila proizvedena količina {2}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Difference Account must be a Asset/Liability type account, since this Stock Entry is an Opening Entry","Račun za razliko mora biti račun vrste sredstev / obveznosti, saj je ta vnos zaloga odprt"
DocType: Supplier Scorecard Scoring Standing,Employee,Zaposleni
DocType: Bank Guarantee,Fixed Deposit Number,Fiksna številka depozita
DocType: Asset Repair,Failure Date,Datum odpovedi
DocType: Support Search Source,Result Title Field,Polje naslova rezultata
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Summary,Povzetek klicev
DocType: Sample Collection,Collected Time,Zbrani čas
DocType: Employee Skill Map,Employee Skills,Spretnosti zaposlenih
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,Fuel Expense,Odhodki za gorivo
DocType: Company,Sales Monthly History,Mesečna zgodovina prodaje
apps/erpnext/erpnext/regional/italy/utils.py,Please set at least one row in the Taxes and Charges Table,V tabelo davkov in dajatev nastavite vsaj eno vrstico
DocType: Asset Maintenance Task,Next Due Date,Naslednji datum roka
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch,Izberite Serija
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is fully billed,{0} {1} je v celoti zaračunano
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Vital Signs,Življenjski znaki
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/settings.py,Standard contract terms for Sales or Purchase.,Standardni pogodbeni pogoji za prodajo ali nakup.
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Rows Removed in {0},Vrstice so odstranjene v {0}
DocType: Shift Type,Begin check-in before shift start time (in minutes),Začnite prijavo pred začetkom izmene (v minutah)
DocType: BOM Item,Item operation,Operacija elementa
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Voucher,Skupina kupon
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Are you sure you want to cancel this appointment?,"Ali ste prepričani, da želite preklicati ta sestanek?"
DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Paket hotelskih cen
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Sales Pipeline,prodaja Pipeline
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,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,Required On,Zahtevani Na
DocType: Rename Tool,File to Rename,Datoteka za preimenovanje
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please select BOM for Item in Row {0},Izberite BOM za postavko v vrstici {0}
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Fetch Subscription Updates,Prenesi posodobitve naročnine
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py,Account {0} does not match with Company {1} in Mode of Account: {2},Račun {0} ne ujema z družbo {1} v načinu račun: {2}
apps/erpnext/erpnext/controllers/buying_controller.py,Specified BOM {0} does not exist for Item {1},Določeno BOM {0} ne obstaja za postavko {1}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Course: ,Tečaj:
DocType: Soil Texture,Sandy Loam,Sandy Loam
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Vzdrževanje Urnik {0} je treba odpovedati pred preklicem te Sales Order
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py,Student LMS Activity,Aktivnost študentskih učencev
DocType: POS Profile,Applicable for Users,Uporabno za uporabnike
DocType: Supplier Quotation,PUR-SQTN-.YYYY.-,PUR-SQTN-.GGGG.-
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Project and all Tasks to status {0}?,Nastavite stanje Projekta in vseh opravil {0}?
DocType: Purchase Invoice,Set Advances and Allocate (FIFO),Nastavi predujme in dodelitev (FIFO)
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No Work Orders created,Št delovnih nalogov ustvarjenih
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,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,Pharmaceutical,Pharmaceutical
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,You can only submit Leave Encashment for a valid encashment amount,Leave Encashment lahko oddate samo za veljaven znesek obračuna
apps/erpnext/erpnext/public/js/hub/pages/SellerItems.vue,Items by ,Izdelki do
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Purchased Items,Vrednost kupljenih artiklov
DocType: Employee Separation,Employee Separation Template,Predloga za ločevanje zaposlenih
DocType: Selling Settings,Sales Order Required,Zahtevano je naročilo
apps/erpnext/erpnext/public/js/hub/marketplace.js,Become a Seller,Postanite prodajalec
,Procurement Tracker,Sledilnik javnih naročil
DocType: Purchase Invoice,Credit To,Kredit
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Reversed,ITC obrnjen
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid authentication error,Napačna avtentikacija
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Active Leads / Customers,Aktivne ponudbe / Stranke
DocType: Delivery Settings,Leave blank to use the standard Delivery Note format,"Pustite prazno, da uporabite standardno obliko zapisa za dostavo"
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year End Date should be one year after Fiscal Year Start Date,Končni datum proračunskega leta mora biti eno leto po datumu začetka fiskalnega leta
DocType: Employee Education,Post Graduate,Post Graduate
DocType: Quality Meeting,Agenda,Dnevni red
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
apps/erpnext/erpnext/config/integrations.py,Connect your Exotel Account to ERPNext and track call logs,Povežite svoj račun Exotel z ERPNext in spremljajte dnevnike klicev
DocType: Supplier,Is Frozen,Je zamrznjena
DocType: Tally Migration,Processed Files,Obdelane datoteke
apps/erpnext/erpnext/stock/utils.py,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: Support Search Source,Post Title Key,Ključ za objavo naslova
DocType: Issue,Issue Split From,Izdaja Split Od
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Job Card,Za delovno kartico
DocType: Warranty Claim,Raised By,Raised By
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Prescriptions,Predpisi
DocType: Payment Gateway Account,Payment Account,Plačilo računa
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Please specify Company to proceed,"Prosimo, navedite Company nadaljevati"
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Accounts Receivable,Neto sprememba terjatev do kupcev
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Compensatory Off,Kompenzacijske Off
DocType: Job Applicant,Accepted,Sprejeto
DocType: POS Closing Voucher,Sales Invoices Summary,Povzetek prodajnih računov
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Party Name,Ime stranke
DocType: Grant Application,Organization,organizacija
DocType: Grant Application,Organization,organizacija
DocType: BOM Update Tool,BOM Update Tool,Orodje za posodobitev BOM
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Party,Skupina po pogodbenici
DocType: SG Creation Tool Course,Student Group Name,Ime študent Group
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Show exploded view,Pokaži eksplodiran pogled
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Creating Fees,Ustvarjanje pristojbin
apps/erpnext/erpnext/setup/doctype/company/company.js,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,"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,Search Results,Rezultati iskanja
DocType: Homepage Section,Number of Columns,Število stolpcev
DocType: Room,Room Number,Številka sobe
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Price not found for item {0} in price list {1},Ni cene za izdelek {0} v ceniku {1}
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requestor,Prosilec
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid reference {0} {1},Neveljavna referenčna {0} {1}
apps/erpnext/erpnext/config/buying.py,Rules for applying different promotional schemes.,Pravila za uporabo različnih promocijskih shem.
DocType: Shipping Rule,Shipping Rule Label,Oznaka dostavnega pravila
DocType: Journal Entry Account,Payroll Entry,Vnos plače
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,View Fees Records,Oglejte si zapisi o prispevkih
apps/erpnext/erpnext/public/js/conf.js,User Forum,Uporabniški forum
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Raw Materials cannot be blank.,Surovine ne more biti prazno.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0} (Payment Table): Amount must be negative,Vrstica # {0} (Tabela plačil): znesek mora biti negativen
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,"Could not update stock, invoice contains drop shipping item.","Ni mogel posodobiti vozni park, faktura vsebuje padec element ladijskega prometa."
DocType: Contract,Fulfilment Status,Status izpolnjevanja
DocType: Lab Test Sample,Lab Test Sample,Vzorec laboratorijskega testa
DocType: Item Variant Settings,Allow Rename Attribute Value,Dovoli preimenovanje vrednosti atributa
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Quick Journal Entry,Hitro Journal Entry
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Amount,Prihodnji znesek plačila
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,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
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Number / Name,Posodobi številko računa / ime
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign Salary Structure,Dodeli strukturo plač
DocType: Support Settings,Response Key List,Seznam odzivnih ključev
DocType: Job Card,For Quantity,Za Količino
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Planned Qty for Item {0} at row {1},Vnesite načrtovanih Količina za postavko {0} v vrstici {1}
DocType: Support Search Source,API,API
DocType: Support Search Source,Result Preview Field,Polje za predogled rezultatov
apps/erpnext/erpnext/templates/generators/item/item_configure.js,{0} items found.,{0} najdenih elementov.
DocType: Item Price,Packing Unit,Pakirna enota
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} ni vložen
DocType: Subscription,Trialling,Trialling
DocType: Sales Invoice Item,Deferred Revenue,Odloženi prihodki
DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Gotovinski račun se bo uporabil za ustvarjanje prodajne fakture
DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Podskupina za izvzetje
DocType: Member,Membership Expiry Date,Datum prenehanja članstva
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,{0} must be negative in return document,{0} mora biti negativno na povratnem dokumentu
DocType: Employee Tax Exemption Proof Submission,Submission Date,Datum oddaje
,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,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/manufacturing/doctype/bom_update_tool/bom_update_tool.js,Latest price updated in all BOMs,Najnovejša cena posodobljena v vseh BOM
DocType: Project User,Project Status,Stanje projekta
DocType: UOM,Check this to disallow fractions. (for Nos),"Preverite, da je to prepoveste frakcij. (za številkami)"
DocType: Student Admission Program,Naming Series (for Student Applicant),Poimenovanje Series (za Student prijavitelja)
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py,Bonus Payment Date cannot be a past date,Datum plačila bonusa ne more biti pretekli datum
DocType: Travel Request,Copy of Invitation/Announcement,Kopija vabila / obvestila
DocType: Practitioner Service Unit Schedule,Practitioner Service Unit Schedule,Urnik službe zdravnika
DocType: Sales Invoice,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,Total Absent,Skupaj Odsoten
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,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/hr/report/loan_repayment/loan_repayment.py,Payable Amount,Plačljivi znesek
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,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,Opportunity,Priložnost
DocType: Options,Option,Možnost
apps/erpnext/erpnext/accounts/general_ledger.py,You can't create accounting entries in the closed accounting period {0},V zaprtem obračunskem obdobju ne morete ustvariti računovodskih vnosov {0}
DocType: Operation,Default Workstation,Privzeto Workstation
DocType: Payment Entry,Deductions or Loss,Odbitki ali izguba
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{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,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,Tree of Bill of Materials,Drevo Bill of Materials
DocType: BOM,Exploded Items,Eksplodirani predmeti
DocType: Student,Joining Date,Vstop Datum
,Employees working on a holiday,Zaposleni na počitnice
,TDS Computation Summary,Povzetek izračunov TDS
DocType: Share Balance,Current State,Trenutno stanje
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Present,Označi sedanjost
DocType: Share Transfer,From Shareholder,Od delničarja
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Greater Than Amount,Večji od zneska
DocType: Project,% Complete Method,% končano
apps/erpnext/erpnext/healthcare/setup.py,Drug,Zdravilo
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance start date can not be before delivery date for Serial No {0},Datum začetka vzdrževanje ne more biti pred datumom dostave za serijsko št {0}
DocType: Work 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: Authorization Rule,Applicable To (Role),Ki se uporabljajo za (vloga)
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Pending Leaves,Čakajoči listi
DocType: BOM Update Tool,Replace BOM,Zamenjajte BOM
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Code {0} already exist,Koda {0} že obstaja
DocType: Patient Encounter,Procedures,Postopki
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Sales orders are not available for production,Prodajna naročila niso na voljo za proizvodnjo
DocType: Asset Movement,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: HR Settings,Hiring Settings,Nastavitve najema
DocType: Work Order,Manufacture against Material Request,Izdelava proti Material zahtevo
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Group: ,Ocenjevalna skupina:
DocType: Item Reorder,Request for,Prošnja za
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,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,Leave Without Pay does not match with approved Leave Application records,Pusti brez plačila ne ujema z odobrenimi evidence Leave aplikacij
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Next Steps,Naslednji koraki
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Saved Items,Shranjeni predmeti
DocType: Travel Request,Domestic,Domači
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Please supply the specified items at the best possible rates,"Prosimo, da določene elemente na najboljših možnih cenah"
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Employee Transfer cannot be submitted before Transfer Date ,Prenos zaposlencev ni mogoče predati pred datumom prenosa
DocType: Certification Application,USD,ameriški dolar
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,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,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,Barcode {0} is not a valid {1} code,Črtna koda {0} ni veljavna {1} koda
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,End Year,Leto zaključka
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot/Lead %,Quot / svinec%
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot/Lead %,Quot / svinec%
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Contract End Date must be greater than Date of Joining,Naročilo Končni datum mora biti večja od Datum pridružitve
DocType: Sales Invoice,Driver,Voznik
DocType: Vital Signs,Nutrition Values,Prehranske vrednosti
DocType: Lab Test Template,Is billable,Je zaračunljiv
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,{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,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,Ageing Range 1,Staranje Razpon 1
DocType: Shopify Settings,Enable Shopify,Omogoči Shopify
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,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
DocType: Grant Application,Grant Application Details ,Podrobnosti o aplikaciji za dodelitev sredstev
DocType: Employee Separation,Employee Separation,Razdelitev zaposlenih
DocType: BOM Item,Original Item,Izvirna postavka
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Date,Doc Datum
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py,Fee Records Created - {0},Fee Records Created - {0}
DocType: Asset Category Account,Asset Category Account,Sredstvo Kategorija račun
apps/erpnext/erpnext/controllers/item_variant.py,The value {0} is already assigned to an exisiting Item {2}.,Vrednost {0} je že dodeljena obstoječi postavki {2}.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0} (Payment Table): Amount must be positive,Vrstica # {0} (Tabela plačil): znesek mora biti pozitiven
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Cannot produce more Item {0} than Sales Order quantity {1},Ne more proizvajati več item {0} od prodaje kol {1}
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Nothing is included in gross,Nič ni vključeno v bruto
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill already exists for this document,Ta dokument že obstaja
apps/erpnext/erpnext/stock/doctype/item/item.js,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,Stock Entry {0} is not submitted,Stock Začetek {0} ni predložila
DocType: Payment Reconciliation,Bank / Cash Account,Banka / Gotovinski račun
DocType: Bank Transaction,ACC-BTN-.YYYY.-,ACC-BTN-.YYYY.-
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Next Contact By cannot be same as the Lead Email Address,Naslednja Kontakt Po ne more biti enaka kot vodilni e-poštni naslov
DocType: Tax Rule,Billing City,Zaračunavanje Mesto
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is an Individual or a Proprietorship,"Uporablja se, če je podjetje posameznik ali lastnik"
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,Log Type is required for check-ins falling in the shift: {0}.,Vrsta dnevnika je potrebna za prijave pri padcu: {0}.
DocType: Asset,Manual,Ročno
DocType: Tally Migration,Is Master Data Processed,Ali so glavni podatki obdelani
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,Donor information.,Podatki o donatorju.
apps/erpnext/erpnext/config/accounting.py,"e.g. Bank, Cash, Credit Card","npr Bank, gotovini, Kreditna kartica"
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;"
DocType: Journal Entry,Credit Note,Dobropis
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Finished Good Item Code,Končana koda dobrega izdelka
apps/erpnext/erpnext/config/desktop.py,Quality,Kakovost
DocType: Projects Settings,Ignore Employee Time Overlap,Prezri čas prekrivanja zaposlenih
DocType: Warranty Claim,Service Address,Storitev Naslov
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Master Data,Uvozi glavne podatke
DocType: Asset Maintenance Task,Calibration,Praznovanje
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} is a company holiday,{0} je praznik podjetja
apps/erpnext/erpnext/projects/report/billing_summary.py,Billable Hours,Obračunske ure
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Status Notification,Pustite obvestilo o stanju
DocType: Patient Appointment,Procedure Prescription,Postopek Predpis
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Furnitures and Fixtures,Pohištvo in Fixtures
DocType: Travel Request,Travel Type,Vrsta potovanja
DocType: Purchase Invoice Item,Manufacture,Izdelava
DocType: Blanket Order,MFG-BLR-.YYYY.-,MFG-BLR-.YYYY.-
apps/erpnext/erpnext/utilities/user_progress.py,Setup Company,Setup Company
,Lab Test Report,Poročilo o laboratorijskem testu
DocType: Employee Benefit Application,Employee Benefit Application,Application Employee Benefit
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.py,Row({0}): {1} is already discounted in {2},Vrstica ({0}): {1} je že znižana v {2}
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Additional Salary Component Exists.,Dodatne komponente plače obstajajo.
DocType: Purchase Invoice,Unregistered,Neregistrirani
DocType: Student Applicant,Application Date,uporaba Datum
DocType: Salary Component,Amount based on formula,"Znesek, ki temelji na formuli"
DocType: Purchase Invoice,Currency and Price List,Gotovina in Cenik
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Create Maintenance Visit,Ustvari obisk vzdrževanja
DocType: Opportunity,Customer / Lead Name,Stranka / Ime ponudbe
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date not mentioned,Potrditev Datum ni omenjena
DocType: Payroll Period,Taxable Salary Slabs,Obdavčljive pločevine
apps/erpnext/erpnext/config/manufacturing.py,Production,Proizvodnja
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! The input you've entered doesn't match the format of GSTIN.,Neveljaven GSTIN! Vneseni vnos ne ustreza formatu GSTIN.
DocType: Guardian,Occupation,poklic
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Quantity must be less than quantity {0},Količina mora biti manjša od količine {0}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Row {0}:Start Date must be before End Date,Vrstica {0}: Začetni datum mora biti pred končnim datumom
DocType: Salary Component,Max Benefit Amount (Yearly),Znesek maksimalnega zneska (letno)
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,TDS Rate %,TDS Stopnja%
DocType: Crop,Planting Area,Območje sajenja
apps/erpnext/erpnext/controllers/trends.py,Total(Qty),Skupaj (Kol)
DocType: Installation Note Item,Installed Qty,Nameščen Kol
apps/erpnext/erpnext/utilities/user_progress.py,You added ,Dodali ste
,Product Bundle Balance,Bilanca izdelka
DocType: Purchase Taxes and Charges,Parenttype,Parenttype
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Central Tax,Centralni davek
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,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/controllers/accounts_controller.py, or ,ali
apps/erpnext/erpnext/public/js/purchase_trends_filters.js,Billing Date,Datum obračuna
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be negative,Dodeljeni znesek ne more biti negativen
DocType: Sales Order,Billing Status,Status zaračunavanje
apps/erpnext/erpnext/public/js/conf.js,Report an Issue,Prijavi težavo
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"If you {0} {1} quantities of the item <b>{2}</b>, the scheme <b>{3}</b>
			will be applied on the item.","Če {0} {1} količine izdelka <b>{2}</b> , bo na izdelku uporabljena shema <b>{3}</b> ."
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Utility Expenses,Pomožni Stroški
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,90-Above,90-Nad
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,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
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Account: {0} is not permitted under Payment Entry,Račun: {0} ni dovoljen pri vnosu plačila
DocType: Production Plan,Ignore Existing Projected Quantity,Ignorirajte obstoječo predvideno količino
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Approval Notification,Pustite obvestilo o odobritvi
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,Buying Rate,Nakupna cena
apps/erpnext/erpnext/controllers/buying_controller.py,Row {0}: Enter location for the asset item {1},Vrstica {0}: vnesite lokacijo za postavko sredstva {1}
DocType: Employee Checkin,Attendance Marked,Število udeležencev
DocType: Request for Quotation,PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-
apps/erpnext/erpnext/public/js/hub/pages/Seller.vue,About the Company,O podjetju
apps/erpnext/erpnext/config/settings.py,"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,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,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: Asset Maintenance Log,ACC-AML-.YYYY.-,ACC-AML-YYYY-
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,No gain or loss in the exchange rate,Dobiček ali izguba v menjalnem tečaju ni
DocType: Leave Control Panel,Select Employees,Izberite Zaposleni
DocType: Shopify Settings,Sales Invoice Series,Serija prodajnih računov
DocType: Bank Reconciliation,To Date,Če želite Datum
DocType: Opportunity,Potential Sales Deal,Potencialni Sales Deal
DocType: Complaint,Complaints,Pritožbe
DocType: Employee Tax Exemption Declaration,Employee Tax Exemption Declaration,Izjava o davčni oprostitvi za zaposlene
DocType: Payment Entry,Cheque/Reference Date,Ček / Referenčni datum
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials.,Ni predmetov z gradivom.
apps/erpnext/erpnext/portal/doctype/homepage/homepage.js,Customize Homepage Sections,Prilagodite odseke domače strani
DocType: Purchase Invoice,Total Taxes and Charges,Skupaj davki in dajatve
DocType: Payment Entry,Company Bank Account,Bančni račun podjetja
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,Ledger,Ledger
DocType: Drug Prescription,Drug Code,Koda zdravil
DocType: Target Detail,Target  Amount,Ciljni znesek
apps/erpnext/erpnext/education/utils.py,Quiz {0} does not exist,Kviz {0} ne obstaja
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
DocType: Job Card Time Log,Job Card Time Log,Dnevni dnevnik delovne kartice
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Če je izbrano 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«."
DocType: Journal Entry,Paid Loan,Plačano posojilo
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,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
DocType: Issue,Resolution By,Resolucija avtorja
DocType: Leave Type,Applicable After (Working Days),Velja za (delovne dni)
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,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,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: Shopify Settings,Webhooks Details,Podrobnosti o spletnih urah
apps/erpnext/erpnext/templates/pages/projects.html,No time sheets,Ni listami
DocType: GoCardless Mandate,GoCardless Customer,GoCardless stranka
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,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,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
DocType: Leave Encashment,Payroll,izplačane plače
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Za vrstico {0} v {1}. Če želite vključiti {2} v stopnji Element, {3}, mora biti vključena tudi vrstice"
DocType: Healthcare Service Unit,Parent Service Unit,Enota starševske službe
DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikacija paketu za dostavo (za tisk)
apps/erpnext/erpnext/support/doctype/issue/issue.js,Service Level Agreement was reset.,Sporazum o ravni storitev je bil ponastavljen.
DocType: Bin,Reserved Quantity,Rezervirano Količina
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Please enter valid email address,Vnesite veljaven e-poštni naslov
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Please enter valid email address,Vnesite veljaven e-poštni naslov
DocType: Volunteer Skill,Volunteer Skill,Sposobnost prostovoljcev
DocType: Bank Reconciliation,Include POS Transactions,Vključite POS transakcije
DocType: Quality Action,Corrective/Preventive,Korektivno / preventivno
DocType: Purchase Invoice,Inter Company Invoice Reference,Sklic na račun družbe
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,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/regional/italy/utils.py,Please set Tax ID for the customer '%s',"Prosimo, nastavite davčno številko za stranko &#39;% s&#39;"
apps/erpnext/erpnext/config/help.py,Customizing Forms,Prilagajanje Obrazci
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Arrear,arrear
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Amount during the period,Amortizacija Znesek v obdobju
DocType: Sales Invoice,Is Return (Credit Note),Je donos (kreditna opomba)
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Start Job,Začni opravilo
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Serial no is required for the asset {0},Serijsko št. Se zahteva za sredstvo {0}
DocType: Leave Control Panel,Allocate Leaves,Dodelite liste
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py,Disabled template must not be default template,Onemogočeno predloga ne sme biti kot privzeto
DocType: Pricing Rule,Price or Product Discount,Cena ali popust na izdelke
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,For row {0}: Enter planned qty,Za vrstico {0}: vnesite načrtovani qty
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,Delivery,Dostava
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Assigning Structures...,Dodeljujem strukture...
DocType: Stock Reconciliation Item,Current Qty,Trenutni Kol
DocType: Restaurant Menu,Restaurant Menu,Restavracija Meni
apps/erpnext/erpnext/public/js/event.js,Add Suppliers,Dodaj dobavitelje
DocType: Sales Invoice,ACC-SINV-.YYYY.-,ACC-SINV-.YYYY.-
DocType: Loyalty Program,Help Section,Oddelek za pomoč
apps/erpnext/erpnext/www/all-products/index.html,Prev,prejšnja
DocType: Appraisal Goal,Key Responsibility Area,Key Odgovornost Area
DocType: Delivery Trip,Distance UOM,Razdalja UOM
apps/erpnext/erpnext/utilities/activation.py,"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,Set default inventory account for perpetual inventory,Privzeta nastavitev popis račun za stalne inventarizacije
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot deliver Serial No {0} of item {1} as it is reserved to \
												fullfill Sales Order {2}","Ne more dostaviti zaporednega št. {0} elementa {1}, ker je rezerviran za \ polnjenje prodajnega naročila {2}"
DocType: Material Request Plan Item,Material Request Type,Material Zahteva Type
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js,Send Grant Review Email,Pošlji e-pošto za pregled e-pošte
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full, did not save","Lokalno shrambo je polna, ni rešil"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}: UOM Conversion Factor is mandatory,Vrstica {0}: UOM Conversion Factor je obvezna
DocType: Employee Benefit Claim,Claim Date,Datum zahtevka
apps/erpnext/erpnext/utilities/user_progress.py,Room Capacity,Zmogljivost sob
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field Asset Account cannot be blank,Polje Račun sredstva ne sme biti prazno
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Already record exists for the item {0},Že obstaja zapis za postavko {0}
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Ref,Ref
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,You will lose records of previously generated invoices. Are you sure you want to restart this subscription?,"Izgubili boste zapise o že ustvarjenih računih. Ali ste prepričani, da želite znova zagnati to naročnino?"
DocType: Lab Test,LP-,LP-
DocType: Healthcare Settings,Registration Fee,Kotizacija
DocType: Loyalty Program Collection,Loyalty Program Collection,Zbirka programa zvestobe
DocType: Stock Entry Detail,Subcontracted Item,Postavka s podizvajalci
apps/erpnext/erpnext/education/__init__.py,Student {0} does not belong to group {1},Študent {0} ne pripada skupini {1}
DocType: Budget,Cost Center,Stroškovno Center
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Voucher #,Voucher #
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
DocType: Purchase Invoice,Total Quantity,Skupna količina
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Cen Pravilo je narejen prepisati Cenik / določiti diskontno odstotek, na podlagi nekaterih kriterijev."
apps/erpnext/erpnext/support/doctype/issue/issue.py,Service Level Agreement has been changed to {0}.,Pogodba o ravni storitve je spremenjena na {0}.
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
DocType: Shopify Settings,Shopify Settings,Nakup nastavitev
DocType: Amazon MWS Settings,Market Place ID,ID tržne točke
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Head of Marketing and Sales,Vodja marketinga in prodaje
DocType: Video,Vimeo,Vimeo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Income Tax,Davek na prihodek
DocType: HR Settings,Check Vacancies On Job Offer Creation,Preverite prosta delovna mesta pri ustvarjanju ponudbe delovnih mest
apps/erpnext/erpnext/utilities/user_progress.py,Go to Letterheads,Pojdite v Letterheads
DocType: Subscription,Cancel At End Of Period,Prekliči ob koncu obdobja
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Property already added,Lastnost že dodana
DocType: Item Supplier,Item Supplier,Postavka Dobavitelj
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please enter Item Code to get batch no,Vnesite Koda dobiti serijo no
apps/erpnext/erpnext/public/js/utils.js,Loyalty Points: {0},Točke zvestobe: {0}
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js,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,No Items selected for transfer,Ni izbranih elementov za prenos
apps/erpnext/erpnext/config/buying.py,All Addresses.,Vsi naslovi.
DocType: Company,Stock Settings,Nastavitve Stock
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","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_with_account_number.py,Gain/Loss on Asset Disposal,Dobiček / izgube pri prodaji premoženja
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js,"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",V spodnji tabeli bo izbran samo kandidat s statusom »Odobreno«.
DocType: Tax Withholding Category,Rates,Cene
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py,Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Številka računa za račun {0} ni na voljo. <br> Pravilno nastavite svoj račun.
DocType: Task,Depends on Tasks,Odvisno od Opravila
apps/erpnext/erpnext/config/crm.py,Manage Customer Group Tree.,Upravljanje drevesa skupine kupcev.
DocType: Normal Test Items,Result Value,Vrednost rezultata
DocType: Hotel Room,Hotels,Hoteli
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,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/generators/item/item_add_to_cart.html,Not in Stock,Ni na zalogi
DocType: Volunteer,Volunteer Skills,Prostovoljne spretnosti
DocType: Additional Salary,HR User,Uporabnik človeških virov
DocType: Bank Guarantee,Reference Document Name,Referenčno ime dokumenta
DocType: Purchase Invoice,Taxes and Charges Deducted,Davki in dajatve Odbitek
DocType: Support Settings,Issues,Vprašanja
DocType: Loyalty Program,Loyalty Program Name,Ime programa zvestobe
apps/erpnext/erpnext/controllers/status_updater.py,Status must be one of {0},Stanje mora biti eno od {0}
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Reminder to update GSTIN Sent,Opomnik za posodobitev GSTIN Poslano
DocType: Discounted 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
,Pending SO Items For Purchase Request,Dokler SO Točke za nakup dogovoru
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Student Admissions,Študentski Sprejemi
DocType: Supplier,Billing Currency,Zaračunavanje Valuta
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Extra Large,Extra Large
DocType: Loan,Loan Application,Loan Application
DocType: Crop,Scientific Name,Znanstveno ime
DocType: Healthcare Service Unit,Service Unit Type,Vrsta enote storitev
DocType: Bank Account,Branch Code,Koda podružnice
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,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: Quality Procedure,Parent Procedure,Starševski postopek
DocType: Patient Encounter,In print,V tisku
DocType: Accounting Dimension,Accounting Dimension,Računovodska razsežnost
,Profit and Loss Statement,Izkaz poslovnega izida
DocType: Bank Reconciliation Detail,Cheque Number,Ček Število
apps/erpnext/erpnext/healthcare/utils.py,The item referenced by {0} - {1} is already invoiced,"Element, na katerega se sklicuje {0} - {1}, je že zaračunan"
,Sales Browser,Prodaja Browser
DocType: Journal Entry,Total Credit,Skupaj Credit
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,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,Local,Lokalno
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Loans and Advances (Assets),Posojila in predujmi (sredstva)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Debtors,Dolžniki
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Large,Velika
DocType: Bank Statement Settings,Bank Statement Settings,Nastavitve bančne izjave
DocType: Shopify Settings,Customer Settings,Nastavitve stranke
DocType: Homepage Featured Product,Homepage Featured Product,Domača stran izbranega izdelka
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,View Orders,Ogled naročil
DocType: Marketplace Settings,Marketplace URL (to hide and update label),URL tržišča (za skrivanje in posodobitev oznake)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Assessment Groups,Vse skupine za ocenjevanje
apps/erpnext/erpnext/regional/india/utils.py,{} is required to generate e-Way Bill JSON,{} je potreben za izdelavo e-Way Bill JSON
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,New Warehouse Name,Novo skladišče Ime
DocType: Shopify Settings,App Type,Vrsta aplikacije
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py,Total {0} ({1}),Skupno {0} ({1})
DocType: C-Form Invoice Detail,Territory,Ozemlje
DocType: Pricing Rule,Apply Rule On Item Code,Uporabi pravilo za kodo predmeta
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Navedite ni obiskov zahtevanih
apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Poročilo o stanju zalog
DocType: Stock Settings,Default Valuation Method,Način Privzeto Vrednotenje
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Fee
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Prikaži skupni znesek
apps/erpnext/erpnext/setup/doctype/company/company.js,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: Work Order Operation,Planned Start Time,Načrtovano Start Time
DocType: Course,Assessment,ocena
DocType: Payment Entry Reference,Allocated,Razporejeni
apps/erpnext/erpnext/config/accounting.py,Close Balance Sheet and book Profit or Loss.,Zapri Bilanca stanja in rezervirajte poslovnem izidu.
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,ERPNext could not find any matching payment entry,ERPNext ni mogel najti nobenega ustreznega vnosa za plačilo
DocType: Student Applicant,Application Status,Status uporaba
DocType: Additional Salary,Salary Component Type,Vrsta plačne komponente
DocType: Sensitivity Test Items,Sensitivity Test Items,Testi preizkusov občutljivosti
DocType: Website Attribute,Website Attribute,Atributi spletnega mesta
DocType: Project Update,Project Update,Posodobitev projekta
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,Quotation {0} is cancelled,Ponudba {0} je odpovedana
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,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,Please register the SIREN number in the company information file,"Prosimo, registrirajte številko SIREN v podatkovni datoteki podjetja"
DocType: Quality Action Table,Responsible,Odgovorni
DocType: Email Digest,Sales Orders to Bill,Prodajna naročila za Bill
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."
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Link to Material Request,Povezava z zahtevo za material
DocType: Quiz,Score out of 100,Rezultat od 100
apps/erpnext/erpnext/templates/pages/help.html,Forum Activity,Forumska dejavnost
DocType: Quiz,Grading Basis,Osnove za ocenjevanje
apps/erpnext/erpnext/selling/report/pending_so_items_for_purchase_request/pending_so_items_for_purchase_request.py,S.O. No.,SO No.
DocType: Bank Statement Transaction Settings Item,Bank Statement Transaction Settings Item,Postavka postavk transakcije za bankovce
apps/erpnext/erpnext/hr/utils.py,To date can not greater than employee's relieving date,Do danes ne more biti večji od datuma razrešitve zaposlenih
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Please create Customer from Lead {0},"Prosimo, da ustvarite strank iz svinca {0}"
apps/erpnext/erpnext/healthcare/page/patient_history/patient_history.html,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/hr/doctype/leave_application/leave_application.py,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Pustite samo aplikacije s statusom &quot;Approved&quot; in &quot;Zavrnjeno&quot; se lahko predloži
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py,Creating Dimensions...,Ustvarjanje dimenzij ...
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,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"
DocType: HR Settings,Password Policy,Politika gesla
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js,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-
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Total completed qty must be greater than zero,Število vseh opravljenih količin mora biti večje od nič
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on PO,"Ukrep, če je bil akumuliran mesečni proračun prekoračen na PO"
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Place,Na mestu
DocType: Stock Entry,Stock Entry (Outward GIT),Vnos zalog (zunanji GIT)
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation,Prevrednotenje deviznega tečaja
DocType: POS Profile,Ignore Pricing Rule,Ignoriraj pravilo Cenitve
DocType: Employee Education,Graduate,Maturirati
DocType: Leave Block List,Block Days,Block dnevi
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,"Shipping Address does not have country, which is required for this Shipping Rule","Naslov za dostavo nima države, ki je potrebna za to pravilo o pošiljanju"
DocType: Journal Entry,Excise Entry,Trošarina Začetek
DocType: Bank,Bank Transaction Mapping,Kartiranje bančnih transakcij
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,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: Homepage Section,Section Based On,Oddelek temelji na
DocType: Shopping Cart Settings,Show Apply Coupon Code,Prikaži Uporabi kodo kupona
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 praznike
apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Dodaj / uredite pogoje kupona
apps/erpnext/erpnext/controllers/stock_controller.py,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: Stock Entry Detail,Stock Entry Child,Zaloga Otrok
DocType: Project,Copied From,Kopirano iz
DocType: Project,Copied From,Kopirano iz
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,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,Name error: {0},Ime napaka: {0}
DocType: Healthcare Service Unit Type,Item Details,Podrobni podatki
DocType: Cash Flow Mapping,Is Finance Cost,Je strošek financiranja
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,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,Please set default customer in Restaurant Settings,Privzeto stran nastavite v nastavitvah restavracij
,Salary Register,plača Registracija
DocType: Company,Default warehouse for Sales Return,Privzeto skladišče za vračilo prodaje
DocType: Pick List,Parent Warehouse,Parent Skladišče
DocType: Subscription,Net Total,Neto Skupaj
apps/erpnext/erpnext/stock/doctype/batch/batch.py,"Set item's shelf life in days, to set expiry based on manufacturing date plus shelf-life.","Nastavite rok uporabe izdelka v dnevih, da nastavite rok uporabnosti glede na datum izdelave in rok uporabnosti."
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Default BOM not found for Item {0} and Project {1},Privzeti BOM nismo našli v postavki {0} in projektno {1}
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the Mode of Payment in Payment Schedule,Vrstica {0}: v plačilni shemi nastavite način plačila
apps/erpnext/erpnext/config/non_profit.py,Define various loan types,Opredeliti različne vrste posojil
DocType: Bin,FCFS Rate,FCFS Rate
DocType: Bank Statement Transaction Invoice Item,Outstanding Amount,Neporavnani znesek
apps/erpnext/erpnext/templates/generators/bom.html,Time(in mins),Čas (v minutah)
DocType: Task,Working,Delovna
DocType: Stock Ledger Entry,Stock Queue (FIFO),Stock Queue (FIFO)
DocType: Homepage Section,Section HTML,Odsek HTML
apps/erpnext/erpnext/public/js/setup_wizard.js,Financial Year,Finančno leto
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,{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,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,Cost as on,Stane na
DocType: Healthcare Settings,Out Patient Settings,Out Patient Settings
DocType: Account,Round Off,Zaokrožite
DocType: Service Level Priority,Resolution Time,Čas ločljivosti
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Quantity must be positive,Količina mora biti pozitivna
DocType: Job Card,Requested Qty,Zahteval Kol
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The fields From Shareholder and To Shareholder cannot be blank,Polja Od delničarja in delničarja ne morejo biti prazna
DocType: Cashier Closing,Cashier Closing,Zaprta blagajna
DocType: Tax Rule,Use for Shopping Cart,Uporabite za Košarica
DocType: Homepage,Homepage Slideshow,Diaprojekcija domače strani
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Serial Numbers,Izberite serijsko številko
DocType: BOM Item,Scrap %,Ostanki%
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Dajatve bodo razdeljeni sorazmerno na podlagi postavka Kol ali znesek, glede na vašo izbiro"
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Create Supplier Quotation,Ustvari ponudbo
DocType: Travel Request,Require Full Funding,Zahtevati polno financiranje
DocType: Maintenance Visit,Purposes,Nameni
DocType: Stock Entry,MAT-STE-.YYYY.-,MAT-STE-YYYY-
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Atleast one item should be entered with negative quantity in return document,"Atleast en element, se vpiše z negativnim količino v povratni dokument"
DocType: Shift Type,Grace Period Settings For Auto Attendance,Nastavitve časovnega obdobja za samodejno udeležbo
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","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
DocType: Travel Itinerary,Lodging Required,Potrebna namestitev
DocType: Promotional Scheme,Price Discount Slabs,Plošče s popustom na cene
DocType: Stock Reconciliation Item,Current Serial No,Trenutna serijska št
DocType: Employee,Attendance and Leave Details,Podrobnosti o udeležbi in odhodih
,BOM Comparison Tool,Orodje za primerjavo BOM
,Requested,Zahteval
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,No Remarks,Ni Opombe
DocType: Asset,In Maintenance,V vzdrževanju
DocType: Amazon MWS Settings,Click this button to pull your Sales Order data from Amazon MWS.,"Kliknite ta gumb, da povlečete podatke o prodajnem naročilu iz Amazon MWS."
DocType: Vital Signs,Abdomen,Trebuh
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,No outstanding invoices require exchange rate revaluation,Nobena neporavnana faktura ne zahteva prevrednotenja tečaja
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,Root Account must be a group,Root račun mora biti skupina
DocType: Drug Prescription,Drug Prescription,Predpis o drogah
DocType: Service Level,Support and Resolution,Podpora in ločljivost
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Free item code is not selected,Brezplačna koda izdelka ni izbrana
DocType: Loan,Repaid/Closed,Povrne / Zaprto
DocType: Amazon MWS Settings,CA,CA
DocType: Item,Total Projected Qty,Skupne projekcije Kol
DocType: Monthly Distribution,Distribution Name,Porazdelitev Name
DocType: Chart of Accounts Importer,Chart Tree,Drevesno lestvico
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Include UOM,Vključi UOM
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Material Request No,Material Zahteva Ne
DocType: Service Level Agreement,Default Service Level Agreement,Sporazum o ravni privzetih storitev
DocType: SG Creation Tool Course,Course Code,Koda predmeta
apps/erpnext/erpnext/hr/utils.py,More than one selection for {0} not allowed,Več kot en izbor za {0} ni dovoljen
DocType: Pick List,Qty of raw materials will be decided based on the qty of the Finished Goods Item,Količina surovin se bo določila na podlagi količine postavke končnega blaga
DocType: Location,Parent Location,Lokacija matere
DocType: POS Settings,Use POS in Offline Mode,Uporabite POS v načinu brez povezave
apps/erpnext/erpnext/support/doctype/issue/issue.py,Priority has been changed to {0}.,Prednost je spremenjena na {0}.
apps/erpnext/erpnext/accounts/page/pos/pos.js,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2},{0} je obvezen. Morda ni zapiska za menjavo valut za {1} do {2}
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/crm.py,Manage Territory Tree.,Upravljanje Territory drevo.
apps/erpnext/erpnext/config/getting_started.py,Import Chart Of Accounts from CSV / Excel files,Uvoz računov iz datotek CSV / Excel
DocType: Patient Service Unit,Patient Service Unit,Enota za bolnike
DocType: Bank Statement Transaction Invoice Item,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,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
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Projected Quantity Formula,Formula predvidene količine
DocType: Sales Invoice,Deemed Export,Izbrisani izvoz
DocType: Pick List,Material Transfer for Manufacture,Prenos materialov za proizvodnjo
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Discount Percentage can be applied either against a Price List or for all Price List.,Popust Odstotek se lahko uporablja bodisi proti ceniku ali za vse cenik.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,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,You have already assessed for the assessment criteria {}.,Ste že ocenili za ocenjevalnih meril {}.
DocType: Vehicle Service,Engine Oil,Motorno olje
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Orders Created: {0},Ustvarjeni delovni nalogi: {0}
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,Please set an email id for the Lead {0},"Prosimo, nastavite e-poštni naslov za vodilni {0}"
DocType: Sales Invoice,Sales Team1,Prodaja TEAM1
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} does not exist,Element {0} ne obstaja
DocType: Sales Invoice,Customer Address,Naslov stranke
DocType: Loan,Loan Details,posojilo Podrobnosti
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup post company fixtures,Naprave za namestitev objav ni uspelo
DocType: Company,Default Inventory Account,Privzeti Popis račun
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The folio numbers are not matching,Folio številke se ne ujemajo
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Request for {0},Zahteva za plačilo za {0}
DocType: Item Barcode,Barcode Type,Tip črtne kode
DocType: Antibiotic,Antibiotic Name,Ime antibiotika
apps/erpnext/erpnext/config/buying.py,Supplier Group master.,Poveljnik skupine dobaviteljev.
DocType: Healthcare Service Unit,Occupancy Status,Status zasedenosti
DocType: Purchase Invoice,Apply Additional Discount On,Uporabi dodatni popust na
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Type...,Izberite Vrsta ...
apps/erpnext/erpnext/templates/pages/help.html,Your tickets,Vaše vstopnice
DocType: Account,Root Type,Root Type
DocType: Item,FIFO,FIFO
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Close the POS,Zaprite POS
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Cannot return more than {1} for Item {2},Vrstica # {0}: ne more vrniti več kot {1} za postavko {2}
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,Target warehouse is mandatory for row {0},Ciljna skladišče je obvezna za vrstico {0}
apps/erpnext/erpnext/config/retail.py,Retail Operations,Maloprodajne dejavnosti
DocType: Cheque Print Template,Primary Settings,primarni Nastavitve
DocType: Attendance Request,Work From Home,Delo z doma
DocType: Purchase Invoice,Select Supplier Address,Izberite Dobavitelj naslov
apps/erpnext/erpnext/public/js/event.js,Add Employees,Dodaj Zaposleni
DocType: Purchase Invoice Item,Quality Inspection,Quality Inspection
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,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,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,Account {0} is frozen,Račun {0} je zamrznjen
DocType: Quiz Question,Quiz Question,Vprašanje za kviz
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,"Food, Beverage & Tobacco","Hrana, pijača, tobak"
DocType: Account,Account Number,Številka računa
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Can only make payment against unbilled {0},Lahko le plačilo proti neobračunano {0}
DocType: Call Log,Missed,Zgrešen
apps/erpnext/erpnext/controllers/selling_controller.py,Commission rate cannot be greater than 100,Stopnja Komisija ne more biti večja od 100
apps/erpnext/erpnext/stock/doctype/item_manufacturer/item_manufacturer.py,Duplicate entry against the item code {0} and manufacturer {1},Podvojen vnos s kodo izdelka {0} in proizvajalcem {1}
DocType: Sales Invoice,Allocate Advances Automatically (FIFO),Avtomatsko dodeljevanje napredka (FIFO)
DocType: Volunteer,Volunteer,Prostovoljka
DocType: Buying Settings,Subcontract,Podizvajalska pogodba
apps/erpnext/erpnext/public/js/utils/party.js,Please enter {0} first,Vnesite {0} najprej
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,No replies from,Ni odgovorov
DocType: Work Order Operation,Actual End Time,Dejanski Končni čas
DocType: Production Plan,Download Materials Required,"Naložite materialov, potrebnih"
DocType: Purchase Invoice Item,Manufacturer Part Number,Številka dela proizvajalca
DocType: Taxable Salary Slab,Taxable Salary Slab,Obdavčljive plače
DocType: Work Order Operation,Estimated Time and Cost,Predvideni čas in stroški
apps/erpnext/erpnext/controllers/stock_controller.py,Quality Inspection: {0} is not submitted for the item: {1} in row {2},Pregled kakovosti: {0} za izdelek ni: {1} v vrsti {2}
DocType: Bin,Bin,Bin
DocType: Bank Transaction,Bank Transaction,Bančna transakcija
DocType: Crop,Crop Name,Ime pridelka
apps/erpnext/erpnext/hub_node/api.py,Only users with {0} role can register on Marketplace,V Marketplace se lahko registrirajo samo uporabniki z vlogo {0}
DocType: SMS Log,No of Sent SMS,Število poslanih SMS
DocType: Leave Application,HR-LAP-.YYYY.-,HR-LAP-.GGGG.-
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py,Appointments and Encounters,Imenovanja in srečanja
DocType: Antibiotic,Healthcare Administrator,Skrbnik zdravstva
apps/erpnext/erpnext/utilities/user_progress.py,Set a Target,Nastavite cilj
DocType: Dosage Strength,Dosage Strength,Odmerek
DocType: Healthcare Practitioner,Inpatient Visit Charge,Bolnišnični obisk na obisku
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,Published Items,Objavljeni predmeti
DocType: Account,Expense Account,Expense račun
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Software,Programska oprema
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Colour,Barva
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Merila načrt ocenjevanja
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Transakcije
DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Preprečevanje nakupnih naročil
DocType: Coupon Code,Coupon Name,Ime kupona
apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Občutljivo
DocType: Email Campaign,Scheduled,Načrtovano
DocType: Shift Type,Working Hours Calculation Based On,Izračun delovnega časa na podlagi
apps/erpnext/erpnext/config/buying.py,Request for quotation.,Zahteva za ponudbo.
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Prosimo, izberite 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,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,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,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})
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Code,Spremeni kodo
DocType: Purchase Invoice Item,Valuation Rate,Oceni Vrednotenje
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Ustvari različice
DocType: Vehicle,Diesel,Diesel
apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Cenik Valuta ni izbran
DocType: Quick Stock Balance,Available Quantity,Količina na voljo
DocType: Purchase Invoice,Availed ITC Cess,Uporabil ITC Cess
apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Nastavite sistem poimenovanja inštruktorjev v izobraževanju&gt; Nastavitve za izobraževanje
,Student Monthly Attendance Sheet,Študent Mesečni Udeležba Sheet
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Pravilo o dostavi velja samo za prodajo
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Amortizacijski vrstici {0}: Naslednji amortizacijski datum ne more biti pred datumom nakupa
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Start Date,Projekt Start Date
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Until,Do
DocType: Rename Tool,Rename Log,Preimenovanje Prijava
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,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,Student Group or Course Schedule is mandatory,Študent skupine ali tečaj Urnik je obvezna
DocType: Maintenance Visit Purpose,Against Document No,Proti dokument št
DocType: BOM,Scrap,Odpadno
apps/erpnext/erpnext/utilities/user_progress.py,Go to Instructors,Pojdi na Inštruktorje
apps/erpnext/erpnext/config/selling.py,Manage Sales Partners.,Upravljanje prodajne partnerje.
DocType: Quality Inspection,Inspection Type,Tip pregleda
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,All bank transactions have been created,Vse bančne transakcije so bile ustvarjene
DocType: Fee Validity,Visited yet,Obiskal še
apps/erpnext/erpnext/public/js/hub/pages/FeaturedItems.vue,You can Feature upto 8 items.,Predstavite lahko do 8 elementov.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,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
DocType: Selling Settings,How often should project and company be updated based on Sales Transactions.,Kako pogosto je treba posodobiti projekt in podjetje na podlagi prodajnih transakcij.
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expires On,Poteče
apps/erpnext/erpnext/utilities/user_progress.py,Add Students,Dodaj Študente
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js,Please select {0},"Prosimo, izberite {0}"
DocType: C-Form,C-Form No,C-forma
DocType: Delivery Stop,Distance,Razdalja
apps/erpnext/erpnext/utilities/user_progress.py,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: Sales Order,SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-
DocType: Employee Attendance Tool,Unmarked Attendance,neoznačena in postrežbo
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Creating Payment Entries......,Ustvarjanje plačilnih vnosov ......
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Researcher,Raziskovalec
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid public token error,Napaka v javnem žetonu
DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Program Vpis Orodje Student
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py,Start date should be less than end date for task {0},Začetni datum mora biti krajši od končnega datuma za opravilo {0}
,Consolidated Financial Statement,Konsolidirani računovodski izkazi
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py,Name or Email is mandatory,Ime ali E-pošta je obvezna
DocType: Instructor,Instructor Log,Dnevnik inštruktorja
DocType: Clinical Procedure,Clinical Procedure,Klinični postopek
DocType: Shopify Settings,Delivery Note Series,Serija opombe o dostavi
DocType: Purchase Order Item,Returned Qty,Vrnjeno Kol
DocType: Student,Exit,Izhod
DocType: Communication Medium,Communication Medium,Sporočilo Medium
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root Type is mandatory,Root Tip je obvezna
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to install presets,Namestitev prednastavitev ni uspela
DocType: Healthcare Service Unit Type,UOM Conversion in Hours,Pretvorba UOM v urah
DocType: Contract,Signee Details,Podrobnosti o označevanju
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.",{0} ima trenutno {1} oceno dobavitelja in naročila temu dobavitelju je treba izdajati s previdnostjo
DocType: Certified Consultant,Non Profit Manager,Neprofitni menedžer
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,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,Suplier Name,Ime suplier
apps/erpnext/erpnext/accounts/report/financial_statements.py,Could not retrieve information for {0}.,Podatkov za {0} ni bilo mogoče pridobiti.
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py,Opening Entry Journal,Otvoritveni dnevnik
DocType: Contract,Fulfilment Terms,Izpolnjevanje pogojev
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,Probationary Period,Poskusna doba
DocType: Purchase Taxes and Charges Template,Is Inter State,Je država Inter
apps/erpnext/erpnext/config/hr.py,Shift Management,Shift Management
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: Department,Expense Approver,Expense odobritelj
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Vrstica {0}: Advance proti naročniku mora biti kredit
DocType: Quality Meeting,Quality Meeting,Kakovostno srečanje
apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-Group skupini
DocType: Employee,ERPNext User,Uporabnik ERPNext
DocType: Coupon Code,Coupon Description,Opis kupona
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,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,Batch is mandatory in row {0},Serija je obvezna v vrstici {0}
DocType: Company,Default Buying Terms,Privzeti pogoji nakupa
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Potrdilo o nakupu Postavka Priložena
DocType: Amazon MWS Settings,Enable Scheduled Synch,Omogoči načrtovano sinhronizacijo
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py,To Datetime,Da datetime
apps/erpnext/erpnext/config/crm.py,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/controllers/item_variant.py,Please do not create more than 500 items at a time,Ne ustvarite več kot 500 elementov hkrati
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Printed On,Tiskano na
DocType: Clinical Procedure Template,Clinical Procedure Template,Klinična proceduralna predloga
DocType: Item,Inspection Required before Delivery,Pregled Zahtevan pred dostavo
apps/erpnext/erpnext/config/education.py,Content Masters,Vsebine
DocType: Item,Inspection Required before Purchase,Pregled Zahtevan pred nakupom
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Pending Activities,Čakanju Dejavnosti
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Lab Test,Ustvari laboratorijski test
DocType: Patient Appointment,Reminded,Opomniti
DocType: Homepage Section,Cards,Karte
apps/erpnext/erpnext/public/js/setup_wizard.js,View Chart of Accounts,Oglejte si Chart of Accounts
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,Your Organization,Vaša organizacija
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,"Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}","Preskočite dodelitev dodelitve za naslednje zaposlene, saj zanje obstajajo zapise o zapustitvi dodelitve. {0}"
DocType: Fee Component,Fees Category,pristojbine Kategorija
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please enter relieving date.,Vnesite lajšanje datum.
apps/erpnext/erpnext/controllers/trends.py,Amt,Amt
DocType: Travel Request,"Details of Sponsor (Name, Location)","Podrobnosti o sponzorju (ime, lokacija)"
DocType: Supplier Scorecard,Notify Employee,Obvesti delavca
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Enter value betweeen {0} and {1},Vnesite vrednost betweeen {0} in {1}
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,Newspaper Publishers,Newspaper Publishers
apps/erpnext/erpnext/hr/utils.py,Future dates not allowed,Prihodnji datumi niso dovoljeni
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,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,Reorder Level,Preureditev Raven
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Chart Of Accounts Template,Graf Of predlogo računov
DocType: Attendance,Attendance Date,Udeležba Datum
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Update stock must be enable for the purchase invoice {0},Posodobitev zaloge mora biti omogočena za račun za nakup {0}
apps/erpnext/erpnext/stock/get_item_details.py,Item Price updated for {0} in Price List {1},Kos Cena posodabljati za {0} v ceniku {1}
,DATEV,DATEV
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,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/accounts/doctype/loyalty_program/loyalty_program.js,One customer can be part of only single Loyalty Program.,Ena stranka je lahko del samo enega programa zvestobe.
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Half Day,Označi pol dneva
DocType: Sales Invoice,Sales Team,Sales Team
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Duplicate entry,Dvojnik vnos
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the name of the Beneficiary before submittting.,Vnesite ime upravičenca pred predložitvijo.
DocType: Program Enrollment Tool,Get Students,Get Študenti
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Bank Data mapper doesn't exist,Bančni podatkovni zemljevid ne obstaja
DocType: Serial No,Under Warranty,Pod garancijo
DocType: Homepage Section,Number of columns for this section. 3 cards will be shown per row if you select 3 columns.,"Število stolpcev za ta razdelek. Če izberete 3 stolpce, bodo v vsaki vrstici prikazane 3 kartice."
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,[Error],[Error]
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Reconcile Entries,Usklajevanje vnosov
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,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,Limit Crossed,Limit navzkrižnim
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js,Scheduled Upto,Načrtovani Upto
apps/erpnext/erpnext/hr/doctype/shift_type/shift_type.js,Attendance has been marked as per employee check-ins,Udeležba je označena kot pri prijavah zaposlenih
DocType: Woocommerce Settings,Secret,Skrivnost
DocType: Plaid Settings,Plaid Secret,Plaid Secret
DocType: Company,Date of Establishment,Datum ustanavljanja
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Venture Capital,Tveganega kapitala
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,"Akademski izraz s tem &quot;študijskem letu &#39;{0} in&quot; Trajanje Ime&#39; {1} že obstaja. Prosimo, spremenite te vnose in poskusite znova."
apps/erpnext/erpnext/stock/doctype/item/item.py,"As there are existing transactions against item {0}, you can not change the value of {1}","Kot že obstajajo transakcije proti zapisu {0}, ki jih ne more spremeniti vrednosti {1}"
DocType: UOM,Must be Whole Number,Mora biti celo število
DocType: Campaign Email Schedule,Send After (days),Pošlji po (dnevih)
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/maintenance/doctype/maintenance_visit/maintenance_visit.py,Serial No {0} does not exist,Serijska št {0} ne obstaja
DocType: Sales Invoice Item,Customer Warehouse (Optional),Skladišče stranka (po želji)
DocType: Blanket Order Item,Blanket Order Item,Blanket naročilo
DocType: Pricing Rule,Discount Percentage,Popust Odstotek
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sub contracting,Rezervirano za podizvajalce
DocType: Payment Reconciliation Invoice,Invoice Number,Številka računa
DocType: Shopping Cart Settings,Orders,Naročila
DocType: Travel Request,Event Details,Podrobnosti dogodka
DocType: Department,Leave Approver,Pustite odobritelju
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select a batch,Izberite serijo
DocType: Sales Invoice,Redemption Cost Center,Center za odkupne stroške
DocType: QuickBooks Migrator,Scope,Področje uporabe
DocType: Assessment Group,Assessment Group Name,Ime skupine ocena
DocType: Manufacturing Settings,Material Transferred for Manufacture,Material Preneseno za Izdelava
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Add to Details,Dodaj v podrobnosti
DocType: Travel Itinerary,Taxi,Taxi
DocType: Shopify Settings,Last Sync Datetime,Last Sync Datetime
DocType: Landed Cost Item,Receipt Document Type,Prejem Vrsta dokumenta
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal/Price Quote,Cenik ponudbe / cen
DocType: Antibiotic,Healthcare,Zdravstvo
DocType: Target Detail,Target Detail,Ciljna Detail
apps/erpnext/erpnext/stock/doctype/item/item.js,Single Variant,Enotna varianta
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,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/regional/doctype/gstr_3b_report/gstr_3b_report.html,"From a supplier under composition scheme, Exempt and Nil rated","Od dobavitelja po sestavi sheme, izvzeto in nično"
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Period Closing Entry,Obdobje Closing Začetek
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Department...,Izberite oddelek ...
DocType: Pricing Rule,Free Item,Brezplačni artikel
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Suppliies made to Composition Taxable Persons,Dobave za sestave davčnih zavezancev
apps/erpnext/erpnext/regional/india/utils.py,Distance cannot be greater than 4000 kms,Razdalja ne sme biti večja od 4000 km
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cost Center with existing transactions can not be converted to group,Stroškovno Center z obstoječimi transakcij ni mogoče pretvoriti v skupini
DocType: QuickBooks Migrator,Authorization URL,URL avtorizacije
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} {2} {3},Znesek {0} {1} {2} {3}
DocType: Account,Depreciation,Amortizacija
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,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,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,Avg. Selling Price List Rate,Povpr. Prodajna cenik tečaja
DocType: Loyalty Program Collection,Collection Factor (=1 LP),Zbirni faktor (= 1 LP)
DocType: Additional Salary,Salary Component,plača Component
apps/erpnext/erpnext/accounts/utils.py,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
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Workday {0} has been repeated.,Delovni dan {0} se je ponovil.
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"You can claim only an amount of {0}, the rest amount {1} should be in the application \
				as pro-rata component","Zahtevate lahko le znesek {0}, znesek ostanka {1} mora biti v aplikaciji \ kot pro-rata komponenta"
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Employee A/C Number,Številka zaposlenega / C
DocType: Amazon MWS Settings,Customer Type,Vrsta stranke
DocType: Compensatory Leave Request,Leave Allocation,Pustite Dodelitev
DocType: Payment Request,Recipient Message And Payment Details,Prejemnik sporočila in način plačila
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Please select a Delivery Note,Izberite dobavnico
DocType: Support Search Source,Source DocType,Vir DocType
apps/erpnext/erpnext/templates/pages/help.html,Open a new ticket,Odprite novo karto
DocType: Training Event,Trainer Email,Trainer Email
DocType: Sales Invoice,Transporter,Transporter
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Day Book Data,Uvozi podatke o knjigah na dan
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Priority {0} has been repeated.,Prednost {0} se je ponovila.
DocType: Restaurant Reservation,No of People,Število ljudi
apps/erpnext/erpnext/config/buying.py,Template of terms or contract.,Predloga izrazov ali pogodbe.
DocType: Bank Account,Address and Contact,Naslov in Stik
DocType: Vital Signs,Hyper,Hyper
DocType: Cheque Print Template,Is Account Payable,Je računa plačljivo
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Stock cannot be updated against Purchase Receipt {0},Stock ni mogoče posodobiti proti Nakup prejemu {0}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Create Delivery Trip,Ustvari dostavo
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,"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,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)
DocType: Program Enrollment Tool,Student Applicant,študent Prijavitelj
DocType: Hub Tracked Item,Hub Tracked Item,Hub Gosenica Postavka
DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINAL ZA PREJEMNIKA
DocType: Asset Category Account,Accumulated Depreciation Account,Bilančni Amortizacija račun
DocType: Certified Consultant,Discuss ID,Pogovorite se o ID-ju
DocType: Stock Settings,Freeze Stock Entries,Freeze Stock Vnosi
DocType: Program Enrollment,Boarding Student,Boarding Študent
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Booking Actual Expenses,"Omogočite veljavne stroške, ki se uporabljajo pri rezervaciji"
DocType: Asset Finance Book,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
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Disbursement Entry,Ustvari vnos izplačil
DocType: Amazon MWS Settings,Amazon will synch data updated after this date,"Amazon bo sinhroniziral podatke, posodobljene po tem datumu"
,Stock Analytics,Analiza zaloge
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Operations cannot be left blank,Operacije se ne sme ostati prazno
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Select a Default Priority.,Izberite privzeto prioriteto.
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,Lab Test(s) ,Laboratorijski testi
DocType: Maintenance Visit Purpose,Against Document Detail No,Proti Podrobnosti dokumenta št
apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Brisanje ni dovoljeno za državo {0}
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Vrsta Party je obvezen
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Uporabi kodo kupona
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",Za delovno izkaznico {0} lahko vnesete samo zalogo vrste &quot;Prenos materiala za proizvodnjo&quot;
DocType: Quality Inspection,Outgoing,Odhodni
DocType: Customer Feedback Table,Customer Feedback Table,Tabela povratnih informacij kupcev
apps/erpnext/erpnext/config/support.py,Service Level Agreement.,Sporazum o ravni storitev.
DocType: Material Request,Requested For,Zaprosila za
DocType: Quotation Item,Against Doctype,Proti DOCTYPE
apps/erpnext/erpnext/controllers/selling_controller.py,{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,Net Cash from Investing,Čisti denarni tok iz naložbenja
DocType: Purchase Invoice,Import Of Capital Goods,Uvoz kapitalskih dobrin
DocType: Work Order,Work-in-Progress Warehouse,Work-in-Progress Warehouse
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,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,Attendance Record {0} exists against Student {1},Šivih {0} obstaja proti Študent {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference #{0} dated {1},Referenčna # {0} dne {1}
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Eliminated due to disposal of assets,Amortizacija je izpadlo zaradi odprodaje premoženja
DocType: Employee Transfer,New Employee ID,Novo zaposlitveno ime
DocType: Loan,Member,Član
DocType: Work Order Item,Work Order Item,Postavka delovnega naloga
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js,Show Opening Entries,Prikaži uvodne vnose
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.js,Unlink external integrations,Prekini povezavo zunanjih integracij
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Choose a corresponding payment,Izberite ustrezno plačilo
DocType: Pricing Rule,Item Code,Oznaka
DocType: Student,EDU-STU-.YYYY.-,EDU-STU-.YYYY.-
DocType: Serial No,Warranty / AMC Details,Garancija / AMC Podrobnosti
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,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: Travel Itinerary,Non Diary,Ne Dnevnik
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py,Cannot create Retention Bonus for left Employees,Ne morete ustvariti zadrževalnega bonusa za leve zaposlene
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,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,Closing (Dr),Zapiranje (Dr)
DocType: Cheque Print Template,Cheque Size,Ček Velikost
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} not in stock,Serijska št {0} ni na zalogi
apps/erpnext/erpnext/config/accounting.py,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,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/public/js/pos/pos.html,Qty Total,Količina skupaj
DocType: Landed Cost Item,Receipt Document,prejem dokumenta
DocType: Employee Education,School/University,Šola / univerza
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,Billed Amount,Zaračunavajo Znesek
DocType: Share Transfer,(including),(vključno)
DocType: Quality Review Table,Yes/No,Da / Ne
DocType: Asset,Double Declining Balance,Double Upadanje Balance
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Closed order cannot be cancelled. Unclose to cancel.,Zaprta naročila ni mogoče preklicati. Unclose za preklic.
DocType: Amazon MWS Settings,Synch Products,Synch Izdelki
DocType: Loyalty Point Entry,Loyalty Program,Program zvestobe
DocType: Student Guardian,Father,oče
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Support Tickets,Podporne vstopnice
apps/erpnext/erpnext/controllers/accounts_controller.py,'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,Get Updates,Dobite posodobitve
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: račun {2} ne pripada družbi {3}
apps/erpnext/erpnext/stock/doctype/item/item.js,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,Material Request {0} is cancelled or stopped,Material Zahteva {0} je odpovedan ali ustavi
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Dispatch State,Država odpreme
apps/erpnext/erpnext/config/help.py,Leave Management,Pustite upravljanje
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Groups,Skupine
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Account,"Skupina, ki jo račun"
DocType: Purchase Invoice,Hold Invoice,Držite račun
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Please select Employee,Izberite zaposleni
DocType: Sales Order,Fully Delivered,Popolnoma Delivered
DocType: Promotional Scheme Price Discount,Min Amount,Minimalni znesek
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Lower Income,Nižji od dobička
DocType: Restaurant Order Entry,Current Order,Trenutni naročilo
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Number of serial nos and quantity must be the same,Število serijskih številk in količine mora biti enako
DocType: Delivery Trip,Driver Address,Naslov voznika
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Source and target warehouse cannot be same for row {0},Vir in cilj skladišče ne more biti enaka za vrstico {0}
DocType: Account,Asset Received But Not Billed,"Prejeta sredstva, vendar ne zaračunana"
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Razlika računa mora biti tip Asset / Liability račun, saj je ta Stock Sprava je Entry Otvoritev"
apps/erpnext/erpnext/hr/doctype/loan/loan.py,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,Go to Programs,Pojdite v programe
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,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,Purchase Order number required for Item {0},Naročilnica zahtevanega števila za postavko {0}
DocType: Leave Allocation,Carry Forwarded Leaves,Carry Posredovano Leaves
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,'From Date' must be after 'To Date','Od datuma' mora biti za 'Do datuma '
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.js,No Staffing Plans found for this Designation,Za ta naziv ni bilo mogoče najti nobenega kadrovskega načrta
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Batch {0} of Item {1} is disabled.,Paket {0} postavke {1} je onemogočen.
DocType: Leave Policy Detail,Annual Allocation,Letno dodeljevanje
DocType: Travel Request,Address of Organizer,Naslov organizatorja
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Healthcare Practitioner...,Izberite zdravstvenega zdravnika ...
DocType: Employee Boarding Activity,Applicable in the case of Employee Onboarding,Velja za zaposlene na vozilu
apps/erpnext/erpnext/config/accounting.py,Tax template for item tax rates.,Predloga davka za davčne stopnje na postavke.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods Transferred,Preneseno blago
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,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,Customer {0} does not belong to project {1},"Stranka {0} ne pripada, da projekt {1}"
DocType: Employee Attendance Tool,Marked Attendance HTML,Zabeležena Udeležba HTML
apps/erpnext/erpnext/utilities/activation.py,"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: Clinical Procedure,Patient,Bolnik
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Bypass credit check at Sales Order ,Bypass preverjanje kredita na prodajnem naročilu
DocType: Employee Onboarding Activity,Employee Onboarding Activity,Aktivnost vkrcanja zaposlenih
DocType: Location,Check if it is a hydroponic unit,"Preverite, ali gre za hidroponično enoto"
DocType: Pick List Item,Serial No and Batch,Serijska številka in serije
DocType: Warranty Claim,From Company,Od družbe
DocType: GSTR 3B Report,January,Januarja
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,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,Please set Number of Depreciations Booked,"Prosim, nastavite Število amortizacije Rezervirano"
DocType: Supplier Scorecard Period,Calculations,Izračuni
apps/erpnext/erpnext/public/js/stock_analytics.js,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,Productions Orders cannot be raised for:,Produkcije Naročila ni mogoče povečati za:
DocType: Quality Meeting Minutes,Minute,Minute
DocType: Purchase Invoice,Purchase Taxes and Charges,Nakup davki in dajatve
DocType: Chapter,Meetup Embed HTML,Meetup Vstavi HTML
DocType: Asset,Insured value,Zavarovana vrednost
apps/erpnext/erpnext/utilities/user_progress.py,Go to Suppliers,Pojdi na dobavitelje
DocType: POS Closing Voucher Taxes,POS Closing Voucher Taxes,POS Closing Davčne takse
,Qty to Receive,Količina za prejemanje
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Začetni in končni datumi, ki niso v veljavnem plačilnem obdobju, ne morejo izračunati {0}."
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,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
DocType: Healthcare Service Unit Type,Rate / UOM,Oceni / UOM
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py,All Warehouses,Vse Skladišča
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,No {0} found for Inter Company Transactions.,Št. {0} je bil najden za transakcije podjetja Inter.
DocType: Travel Itinerary,Rented Car,Najem avtomobila
apps/erpnext/erpnext/public/js/hub/components/profile_dialog.js,About your Company,O vaši družbi
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Show Stock Ageing Data,Prikaži podatke o staranju zalog
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Balance Sheet account,Credit Za računu mora biti bilanca računa
DocType: Donor,Donor,Darovalec
DocType: Global Defaults,Disable In Words,"Onemogoči ""z besedami"""
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,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,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: Skill,Skill Name,Ime spretnosti
DocType: Patient,Medical History,Zdravstvena zgodovina
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Bank Overdraft Account,Bančnem računu računa
DocType: Patient,Patient ID,ID bolnika
DocType: Practitioner Schedule,Schedule Name,Ime seznama
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.py,Please enter GSTIN and state for the Company Address {0},Vnesite GSTIN in navedite naslov podjetja {0}
DocType: Currency Exchange,For Buying,Za nakup
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Ob oddaji naročilnice
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Dodaj vse dobavitelje
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Vrstica # {0}: Razporejeni vrednosti ne sme biti večja od neplačanega zneska.
DocType: Tally Migration,Parties,Pogodbenice
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Prebrskaj BOM
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,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,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: Call Log,Call Duration in seconds,Trajanje klica v sekundah
DocType: Academic Term,Academic Year,Študijsko leto
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Available Selling,Razpoložljiva prodaja
DocType: Loyalty Point Entry Redemption,Loyalty Point Entry Redemption,Odkup vstopnice točke zvestobe
apps/erpnext/erpnext/config/accounting.py,Cost Center and Budgeting,Mesto stroškov in oblikovanje proračuna
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Opening Balance Equity,Otvoritev Balance Equity
DocType: Campaign Email Schedule,CRM,CRM
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Payment Schedule,"Prosimo, nastavite plačilni načrt"
DocType: Pick List,Items under this warehouse will be suggested,Predmeti v tem skladišču bodo predlagani
DocType: Purchase Invoice,N,N
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Remaining,preostala
DocType: Appraisal,Appraisal,Cenitev
DocType: Loan,Loan Account,Kreditni račun
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from and valid upto fields are mandatory for the cumulative,Veljavna in veljavna upto polja so obvezna za kumulativno
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.py,"For item {0} at row {1}, count of serial numbers does not match with the picked quantity",Za postavko {0} v vrstici {1} se število serijskih številk ne ujema z izbrano količino
DocType: Purchase Invoice,GST Details,Podrobnosti o GST
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,This is based on transactions against this Healthcare Practitioner.,To temelji na transakcijah proti temu zdravniku.
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,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,Academic Year: ,Študijsko leto:
DocType: Inpatient Record,Admission Schedule Date,Datum vstopnice
DocType: Subscription,Past Due Date,Pretekli rok
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Ne dovolite nastavitve nadomestnega elementa za predmet {0}
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Datum se ponovi
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Pooblaščeni podpisnik
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Neto razpoložljivi ITC (A) - (B)
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Ustvari pristojbine
DocType: Project,Total Purchase Cost (via Purchase Invoice),Skupaj Nakup Cost (via računu o nakupu)
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Select Quantity,Izberite Količina
DocType: Loyalty Point Entry,Loyalty Points,Točke zvestobe
DocType: Customs Tariff Number,Customs Tariff Number,Carinska tarifa številka
DocType: Employee Tax Exemption Proof Submission Detail,Maximum Exemption Amount,Najvišji znesek oprostitve
DocType: Products Settings,Item Fields,Polja predmeta
DocType: Patient Appointment,Patient Appointment,Imenovanje pacienta
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,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,Unsubscribe from this Email Digest,Odjaviti iz te Email Digest
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Get Suppliers By,Pridobite dobavitelje po
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,{0} not found for Item {1},{0} ni najden za postavko {1}
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Value must be between {0} and {1},Vrednost mora biti med {0} in {1}
apps/erpnext/erpnext/utilities/user_progress.py,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,"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,Message Sent,Sporočilo je bilo poslano
apps/erpnext/erpnext/accounts/doctype/account/account.py,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
apps/erpnext/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py,Vendor Name,Ime prodajalca
DocType: Quiz Result,Wrong,Napačno
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)
DocType: Sales Partner,Referral Code,napotitvena koda
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Skupni znesek predplačila ne more biti večji od skupnega sankcioniranega zneska
DocType: Salary Slip,Hour Rate,Urna postavka
apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Omogoči samodejno ponovno naročilo
DocType: Stock Settings,Item Naming By,Postavka Poimenovanje S
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Another Period Closing Entry {0} has been made after {1},Drug zaključnem obdobju Začetek {0} je bil dosežen po {1}
DocType: Work Order,Material Transferred for Manufacturing,Material Preneseno za Manufacturing
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Account {0} does not exists,Račun {0} ne obstaja
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Select Loyalty Program,Izberite program zvestobe
DocType: Project,Project Type,Projekt Type
apps/erpnext/erpnext/projects/doctype/task/task.py,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/setup/doctype/sales_person/sales_person.py,Either target qty or target amount is mandatory.,Bodisi ciljna kol ali ciljna vrednost je obvezna.
apps/erpnext/erpnext/config/projects.py,Cost of various activities,Stroške različnih dejavnosti
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Nastavitev dogodkov na {0}, 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,Source and target warehouse must be different,Vir in cilj skladišče mora biti drugačen
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Failed. Please check your GoCardless Account for more details,Plačilo ni uspelo. Preverite svoj GoCardless račun za več podrobnosti
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Not allowed to update stock transactions older than {0},"Ni dovoljeno, da posodobite transakcije zalog starejši od {0}"
DocType: BOM,Inspection Required,Pregled Zahtevan
DocType: Purchase Invoice Item,PR Detail,PR Detail
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the Bank Guarantee Number before submittting.,Vnesti bančno garancijsko številko pred predložitvijo.
DocType: Driving License Category,Class,Razred
DocType: Sales Order,Fully Billed,Popolnoma zaračunavajo
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work Order cannot be raised against a Item Template,Delovnega reda ni mogoče dvigniti glede na predlogo postavke
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,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_with_account_number.py,Cash In Hand,Denarna sredstva v blagajni
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,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: Plaid Settings,Plaid Environment,Plaid okolje
,Project Billing Summary,Povzetek obračunavanja za projekt
DocType: Vital Signs,Cuts,Kosi
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,"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,"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: Expense Claim,Approval Status,Stanje odobritve
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,From value must be less than to value in row {0},Iz mora biti vrednost manj kot na vrednosti v vrstici {0}
DocType: Program,Intro Video,Intro video
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Wire Transfer,Wire Transfer
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,From Date must be before To Date,Od datuma mora biti pred Do Datum
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Check all,Preveri vse
,Issued Items Against Work Order,Izdane predmete proti delovnemu nalogu
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.js,Vacancies cannot be lower than the current openings,Prosta delovna mesta ne smejo biti nižja od trenutnih
,BOM Stock Calculated,Izračun BOM
DocType: Vehicle Log,Invoice Ref,Ref na računu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non-GST outward supplies,Zunanje zaloge brez GST
DocType: Company,Default Income Account,Privzeto Prihodki račun
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Patient History,Zgodovina bolnikov
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Unclosed Fiscal Years Profit / Loss (Credit),Nezaprt proračunskih let dobiček / izguba (Credit)
DocType: Sales Invoice,Time Sheets,čas listi
DocType: Healthcare Service Unit Type,Change In Item,Spremeni v postavki
DocType: Payment Gateway Account,Default Payment Request Message,Privzeto Sporočilo Plačilnega Naloga
DocType: Retention Bonus,Bonus Amount,Bonus znesek
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,Balance ({0}),Stanje ({0})
DocType: Loyalty Point Entry,Redeem Against,Odkup proti
apps/erpnext/erpnext/config/accounting.py,Banking and Payments,Bančništvo in plačila
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Key,Vnesite uporabniški ključ API
DocType: Issue,Service Level Agreement Fulfilled,Izpolnjena pogodba o ravni storitve
,Welcome to ERPNext,Dobrodošli na ERPNext
apps/erpnext/erpnext/config/crm.py,Lead to Quotation,Privede do Kotacija
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,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: Project,Twice Daily,Dvakrat dnevno
DocType: Inpatient Record,A Negative,Negativno
apps/erpnext/erpnext/templates/includes/product_list.js,Nothing more to show.,Nič več pokazati.
DocType: Lead,From Customer,Od kupca
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Calls,Poziva
apps/erpnext/erpnext/utilities/user_progress.py,A Product,Izdelek
DocType: Employee Tax Exemption Declaration,Declarations,Izjave
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batches,Paketi
DocType: Article,LMS User,Uporabnik LMS
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Place Of Supply (State/UT),Kraj dobave (država / UT)
DocType: Purchase Order Item Supplied,Stock UOM,Stock UOM
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Purchase Order {0} is not submitted,Naročilnica {0} ni predložila
DocType: Account,Expenses Included In Asset Valuation,Vključeni stroški v vrednotenje premoženja
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)
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Set Response Time and Resolution for Priority {0} at index {1}.,Nastavite odzivni čas in ločljivost za prednost {0} v indeksu {1}.
DocType: Customs Tariff Number,Tariff Number,tarifna številka
DocType: Work Order Item,Available Qty at WIP Warehouse,Na voljo Količina na WIP Warehouse
apps/erpnext/erpnext/stock/doctype/item/item.js,Projected,Predvidoma
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Warehouse {1},Serijska št {0} ne pripada Warehouse {1}
apps/erpnext/erpnext/controllers/status_updater.py,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Opomba: Sistem ne bo preveril čez povzetju in over-rezervacije za postavko {0} kot količina ali znesek je 0
DocType: Issue,Opening Date,Otvoritev Datum
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please save the patient first,Najprej shranite bolnika
apps/erpnext/erpnext/education/api.py,Attendance has been marked successfully.,Udeležba je bila uspešno označena.
DocType: Program Enrollment,Public Transport,Javni prevoz
DocType: Sales Invoice,GST Vehicle Type,Vrsta vozila
DocType: Soil Texture,Silt Composition (%),Siltova sestava (%)
DocType: Journal Entry,Remark,Pripomba
DocType: Healthcare Settings,Avoid Confirmation,Izogibajte se potrditvi
DocType: Bank Account,Integration Details,Podrobnosti integracije
DocType: Purchase Receipt Item,Rate and Amount,Stopnja in znesek
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Account Type for {0} must be {1},Vrsta računa za {0} mora biti {1}
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Cannot Calculate Arrival Time as Driver Address is Missing.,"Časa prihoda ni mogoče izračunati, ker manjka naslov gonilnika."
DocType: Education Settings,Current Academic Term,Trenutni Academic Term
DocType: Education Settings,Current Academic Term,Trenutni Academic Term
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Item added,Vrstica # {0}: Element je dodan
DocType: Sales Order,Not Billed,Ne zaračunavajo
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Both Warehouse must belong to same Company,Oba Skladišče mora pripadati isti družbi
DocType: Employee Grade,Default Leave Policy,Privzeti pravilnik o zapustitvi
DocType: Shopify Settings,Shop URL,URL trgovine
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,The selected payment entry should be linked with a debtor bank transaction,Izbrani vnos plačila mora biti povezan s bančno transakcijo dolžnika
apps/erpnext/erpnext/public/js/templates/contact_list.html,No contacts added yet.,Ni stikov še dodal.
DocType: Communication Medium Timeslot,Communication Medium Timeslot,Srednja časovna komunikacija
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Pristali Stroški bon Znesek
,Item Balance (Simple),Postavka Balance (Enostavno)
apps/erpnext/erpnext/config/accounting.py,Bills raised by Suppliers.,"Računi, ki jih dobavitelji postavljeno."
DocType: POS Profile,Write Off Account,Odpišite račun
DocType: Patient Appointment,Get prescribed procedures,Pridobite predpisane postopke
DocType: Sales Invoice,Redemption Account,Račun odkupa
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.js,First add items in the Item Locations table,Najprej dodajte elemente v tabelo Lokacije postavk
DocType: Pricing Rule,Discount Amount,Popust Količina
DocType: Pricing Rule,Period Settings,Nastavitve obdobja
DocType: Purchase Invoice,Return Against Purchase Invoice,Vrni proti Račun za nakup
DocType: Item,Warranty Period (in days),Garancijski rok (v dnevih)
DocType: Shift Type,Enable Entry Grace Period,Omogoči časovno obdobje vnosa
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian1,Povezava z Guardian1
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},"Prosimo, izberite BOM proti elementu {0}"
DocType: Shopping Cart Settings,Show Stock Quantity,Prikaži dodatke skladno z RoHS
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Čisti denarni tok iz poslovanja
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Vrstica # {0}: za popust na računu mora biti stanje {1} {2}
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Faktor konverzije za UOM ({0} -&gt; {1}) za element: {2}
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,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,Sub-contracting,Podizvajalcem
DocType: Journal Entry Account,Journal Entry Account,Journal Entry račun
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js,Student Group,Študentska skupina
DocType: Shopping Cart Settings,Quotation Series,Zaporedje ponudb
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py,"An item exists with same name ({0}), please change the item group name or rename the item","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
DocType: Pricing Rule Detail,Pricing Rule Detail,Podrobnosti o cenah
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create BOM,Ustvari BOM
DocType: Pricing Rule,Apply Rule On Item Group,Uporabi pravilo za skupino izdelkov
apps/erpnext/erpnext/accounts/page/pos/pos.js,Please select customer,Izberite stranko
DocType: Employee Tax Exemption Declaration,Total Declared Amount,Skupni prijavljeni znesek
DocType: C-Form,I,jaz
DocType: Company,Asset Depreciation Cost Center,Asset Center Amortizacija Stroški
apps/erpnext/erpnext/templates/generators/item/item_configure.js,{0} item found.,{0} element je najden.
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
DocType: Travel Request,Fully Sponsored,Popolnoma sponzorirani
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Reverse Journal Entry
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Ustvari Job Card
DocType: Quotation,Referral Sales Partner,Referral Sales Partner
DocType: Quality Procedure Process,Process Description,Opis postopka
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Stranka {0} je ustvarjena.
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, 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
apps/erpnext/erpnext/education/doctype/question/question.py,No correct answer is set for {0},Za {0} ni nastavljen pravilen odgovor
DocType: Issue,Response By,Odgovor avtor
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Birthday Reminder,Opomnik za rojstni dan
DocType: Chart of Accounts Importer,Chart Of Accounts Importer,Kazalnik računov Uvoznik
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,Missing Currency Exchange Rates for {0},Manjka Menjalni tečaji za {0}
DocType: Employee Health Insurance,Health Insurance Name,Ime zdravstvenega zavarovanja
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: Subscription Plan,"Number of intervals for the interval field e.g if Interval is 'Days' and Billing Interval Count is 3, invoices will be generated every 3 days","Število intervalov za intervalno polje, npr. Če je interval &quot;Dnevi&quot; in časovni interval obračunavanja 3, bodo računi ustvarjeni vsakih 3 dni"
DocType: Clinical Procedure Template,Allow Stock Consumption,Dovolite porabo zalog
DocType: Asset,Insurance Details,Zavarovanje Podrobnosti
DocType: Account,Payable,Plačljivo
DocType: Share Balance,Share Type,Vrsta delnice
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter Repayment Periods,Vnesite roki odplačevanja
apps/erpnext/erpnext/shopping_cart/cart.py,Debtors ({0}),Dolžniki ({0})
DocType: Pricing Rule,Margin,Razlika
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,New Customers,Nove stranke
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Gross Profit %,Bruto dobiček %
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Appointment {0} and Sales Invoice {1} cancelled,Imenovanje {0} in račun za prodajo {1} sta bila preklicana
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Opportunities by lead source,"Možnosti, ki jih ponujajo svinec"
DocType: Appraisal Goal,Weightage (%),Weightage (%)
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Change POS Profile,Spremenite profil POS
DocType: Bank Reconciliation Detail,Clearance Date,Potrditev Datum
DocType: Delivery Settings,Dispatch Notification Template,Predloga za odpošiljanje
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Report,Ocenjevalno poročilo
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Get Employees,Pridobite zaposlene
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Add your review,Dodajte svoje mnenje
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Gross Purchase Amount is mandatory,Bruto znesek nakupa je obvezna
apps/erpnext/erpnext/setup/doctype/company/company.js,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,Party is mandatory,Party je obvezen
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.py,Please set account heads in GST Settings for Compnay {0},Nastavite glave računa v nastavitvah GST za podjetje {0}
DocType: Course Topic,Topic Name,Ime temo
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Approval Notification in HR Settings.,"Prosimo, nastavite privzeto predlogo za obvestilo o zavrnitvi odobritve v HR nastavitvah."
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,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,Select an employee to get the employee advance.,"Izberite zaposlenega, da zaposleni vnaprej napreduje."
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please select a valid Date,Izberite veljaven datum
apps/erpnext/erpnext/public/js/setup_wizard.js,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,Row #{0}: Duplicate entry in References {1} {2},Vrstica # {0}: Duplikat vnos v Referenčni {1} {2}
apps/erpnext/erpnext/config/manufacturing.py,Where manufacturing operations are carried.,Kjer so proizvodni postopki.
apps/erpnext/erpnext/education/doctype/instructor/instructor.js,As Examiner,Kot preizkuševalec
DocType: Company,Default Expense Claim Payable Account,Zahtevani račun za izplačilo neplačila
DocType: Appointment Type,Default Duration,Privzeto trajanje
DocType: BOM Explosion Item,Source Warehouse,Vir Skladišče
DocType: Installation Note,Installation Date,Datum vgradnje
apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js,Share Ledger,Delež knjige
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} does not belong to company {2},Row # {0}: Asset {1} ne pripada družbi {2}
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Sales Invoice {0} created,Ustvarjen je račun za prodajo {0}
DocType: Employee,Confirmation Date,Datum potrditve
DocType: Inpatient Occupancy,Check Out,Preveri
DocType: C-Form,Total Invoiced Amount,Skupaj Obračunani znesek
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,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: Payment Entry,ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-
DocType: Asset Value Adjustment,Current Asset Value,Trenutna vrednost sredstev
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM recursion: {0} cannot be parent or child of {1},BOM rekurzija: {0} ne sme biti starš ali otrok od {1}
DocType: QuickBooks Migrator,Quickbooks Company ID,ID podjetja Quickbooks
DocType: Travel Request,Travel Funding,Financiranje potovanj
DocType: Employee Skill,Proficiency,Strokovnost
DocType: Loan Application,Required by Date,Zahtevana Datum
DocType: Crop Cycle,A link to all the Locations in which the Crop is growing,"Povezava do vseh lokacij, v katerih se pridelek prideluje"
DocType: Lead,Lead Owner,Lastnik ponudbe
DocType: Production Plan,Sales Orders Detail,Prodajna naročila Podrobnosti
DocType: Bin,Requested Quantity,Zahtevana količina
DocType: Pricing Rule,Party Information,Informacije o zabavi
DocType: Fees,EDU-FEE-.YYYY.-,EDU-FEE-.YYYY.-
DocType: Patient,Marital Status,Zakonski stan
DocType: Stock Settings,Auto Material Request,Auto Material Zahteva
DocType: Woocommerce Settings,API consumer secret,API potrošnikov skrivnost
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Dostopno Serija Količina na IZ SKLADIŠČA
,Received Qty Amount,Prejeta količina v količini
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Bruto plača - Skupaj Odbitek - Posojilo Povračilo
DocType: Bank Account,Last Integration Date,Zadnji datum vključitve
DocType: Expense Claim,Expense Taxes and Charges,Davek na dajatve in dajatve
DocType: Bank Account,IBAN,IBAN
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Current BOM and New BOM can not be same,Trenutni BOM in New BOM ne more biti enaka
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py,Salary Slip ID,Plača Slip ID
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date Of Retirement must be greater than Date of Joining,Datum upokojitve mora biti večji od datuma pridružitve
apps/erpnext/erpnext/stock/doctype/item/item.js,Multiple Variants,Večkratne različice
DocType: Sales Invoice,Against Income Account,Proti dohodkov
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Delivered,{0}% Dostavljeno
DocType: Subscription,Trial Period Start Date,Začetni datum poskusnega obdobja
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Postavka {0}: Ž Kol {1} ne more biti nižja od minimalne naročila Kol {2} (opredeljeno v točki).
DocType: Certification Application,Certified,Certified
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Mesečni Distribution Odstotek
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Party can only be one of ,Zabava je lahko le eden izmed
apps/erpnext/erpnext/regional/india/utils.py,Please mention Basic and HRA component in Company,V podjetju navedite komponento Basic in HRA
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: Sales Invoice,Transporter Info,Transporter Info
apps/erpnext/erpnext/accounts/utils.py,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,Same supplier has been entered multiple times,Enako dobavitelj je bila vpisana večkrat
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py,Gross Profit / Loss,Kosmati dobiček / izguba
,Warehouse wise Item Balance Age and Value,Skladiščno pametno Postavka Balansna doba in vrednost
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Achieved ({}),Doseženo ({})
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Nakup Sklep Postavka Priložena
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Name cannot be Company,Ime podjetja ne more biti podjetje
apps/erpnext/erpnext/support/doctype/issue/issue.py,{0} parameter is invalid,{0} Parameter ni veljaven
apps/erpnext/erpnext/config/settings.py,Letter Heads for print templates.,Letter Glave za tiskane predloge.
apps/erpnext/erpnext/config/settings.py,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/quality_management/doctype/quality_review/quality_review_list.js,No Action,Brez akcije
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,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/stock/doctype/packing_slip/packing_slip.js,Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,"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: Certification Application,Payment Details,Podatki o plačilu
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM Rate
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Branje naložene datoteke
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Prenehanja delovnega naročila ni mogoče preklicati, jo najprej izključite"
DocType: Coupon Code,Coupon Code,Koda kupona
DocType: Asset,Journal Entry for Scrap,Journal Entry za pretep
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Prosimo povlecite predmete iz dobavnice
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Vrstica {0}: izberite delovno postajo proti operaciji {1}
apps/erpnext/erpnext/accounts/utils.py,Journal Entries {0} are un-linked,Revija Vnosi {0} so un-povezani
apps/erpnext/erpnext/accounts/utils.py,{0} Number {1} already used in account {2},{0} Številka {1} je že uporabljena v računu {2}
apps/erpnext/erpnext/config/crm.py,"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,Please mention Round Off Cost Center in Company,Navedite zaokrožijo stroškovno mesto v družbi
DocType: Purchase Invoice,Terms,Pogoji
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Select Days,Izberite Dnevi
DocType: Academic Term,Term Name,izraz Ime
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the correct code on Mode of Payment {1},Vrstica {0}: nastavite pravilno kodo na način plačila {1}
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Credit ({0}),Kredit ({0})
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Creating Salary Slips...,Ustvarjanje plačnih lističev ...
apps/erpnext/erpnext/hr/doctype/department/department.js,You cannot edit root node.,Rootnega vozlišča ne morete urejati.
DocType: Buying Settings,Purchase Order Required,Naročilnica obvezno
apps/erpnext/erpnext/public/js/projects/timer.js,Timer,Časovnik
,Item-wise Sales History,Elementna Prodajna Zgodovina
DocType: Expense Claim,Total Sanctioned Amount,Skupaj sankcionirano Znesek
,Purchase Analytics,Odkupne Analytics
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Total flexible benefit component amount {0} should not be less than max benefits {1},Skupni znesek komponente prožne ugodnosti {0} ne sme biti manjši od najvišjih ugodnosti {1}
DocType: Sales Invoice Item,Delivery Note Item,Dostava Opomba Postavka
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Current invoice {0} is missing,Trenuten račun {0} manjka
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,Batch number is mandatory for Item {0},Serijska številka je obvezna za postavko {0}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js,This is a root sales person and cannot be edited.,To je koren prodaje oseba in jih ni mogoče urejati.
DocType: Salary Component,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Če je izbrana, 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 Component,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Če je izbrana, 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."
,Stock Ledger,Stock Ledger
DocType: Company,Exchange Gain / Loss Account,Exchange Gain / izida
DocType: Amazon MWS Settings,MWS Credentials,MVS poverilnice
apps/erpnext/erpnext/config/selling.py,Blanket Orders from Costumers.,Odeja naročila od kupcev.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Purpose must be one of {0},Cilj mora biti eden od {0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Fill the form and save it,Izpolnite obrazec in ga shranite
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Community Forum,Forum Skupnost
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Actual qty in stock,Dejanska kol v zalogi
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,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,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: Purchase Order,Get Items from Open Material Requests,Dobili predmetov iz Odpri Material Prošnje
DocType: Hotel Room Amenity,Billable,Plačljivo
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Ordered Qty: Quantity ordered for purchase, but not received.","Naročeno Količina: Količina naročena za nakup, vendar ni prejeta."
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Chart of Accounts and Parties,Obdelava kontnega plana in strani
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,Reorder Qty,Preureditev Kol
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Vrednost amortizacije {0}: pričakovana vrednost po življenjski dobi mora biti večja ali enaka {1}
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Current Job Openings,Razpisana delovna
DocType: Company,Stock Adjustment Account,Račun prilagoditev zaloge
apps/erpnext/erpnext/public/js/payment/pos_payment.html,Write Off,Odpisati
apps/erpnext/erpnext/quality_management/doctype/quality_procedure/quality_procedure.py,{0} already has a Parent Procedure {1}.,{0} že ima nadrejeni postopek {1}.
DocType: Healthcare Service Unit,Allow Overlap,Dovoli prekrivanje
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/assets/doctype/asset/asset.py,Enter depreciation details,Vnesite podatke o amortizaciji
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,{0}: From {1},{0}: Od {1}
DocType: Bank Transaction Mapping,Column in Bank File,Stolpec v bančni datoteki
apps/erpnext/erpnext/education/doctype/student_leave_application/student_leave_application.py,Leave application {0} already exists against the student {1},Odstopni program {0} že obstaja proti študentu {1}
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Vrstni red za posodobitev najnovejše cene v vseh gradivih. Traja lahko nekaj minut.
DocType: Pick List,Get Item Locations,Pridobite lokacije
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,"Ime novega računa. Opomba: Prosimo, da ne ustvarjajo računov za kupce in dobavitelje"
DocType: POS Profile,Display Items In Stock,Prikaži elemente na zalogi
apps/erpnext/erpnext/config/settings.py,Country wise default Address Templates,Država pametno privzeti naslov Predloge
DocType: Payment Order,Payment Order Reference,Referenca za plačilni nalog
DocType: Water Analysis,Appearance,Videz
DocType: HR Settings,Leave Status Notification Template,Zapusti predlogo o statusu obvestila
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,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,Member information.,Podatki o članih.
DocType: Identification Document Type,Identification Document Type,Vrsta identifikacijskega dokumenta
apps/erpnext/erpnext/utilities/bot.py,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / Item / {0}) ni na zalogi
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Maintenance,Vzdrževanje sredstev
,Sales Payment Summary,Povzetek prodaje plačila
DocType: Restaurant,Restaurant,Restavracija
DocType: Woocommerce Settings,API consumer key,API-ključ potrošnika
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;Datum&#39; je obvezen
apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Zaradi / Referenčni datum ne more biti po {0}
apps/erpnext/erpnext/config/settings.py,Data Import and Export,Uvoz in izvoz podatkov
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",Žal je veljavnost kode kupona potekla
DocType: Bank Account,Account Details,podrobnosti računa
DocType: Crop,Materials Required,Potrebni materiali
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Najdeno študenti
DocType: Employee Tax Exemption Declaration,Monthly HRA Exemption,Mesečna oprostitev HRA
DocType: Clinical Procedure,Medical Department,Medicinski oddelek
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Early Exits,Skupni zgodnji izhodi
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,Invoice Posting Date,Račun Napotitev Datum
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Sell,Prodaja
DocType: Purchase Invoice,Rounded Total,Zaokroženo skupaj
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Slots for {0} are not added to the schedule,Reže za {0} niso dodane v razpored
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,Not permitted. Please disable the Test Template,"Ni dovoljeno. Prosimo, onemogočite preskusno predlogo"
DocType: Sales Invoice,Distance (in km),Oddaljenost (v km)
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py,Percentage Allocation should be equal to 100%,Odstotek dodelitve mora biti enaka 100%
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select Posting Date before selecting Party,Izberite datum objave pred izbiro stranko
apps/erpnext/erpnext/config/accounting.py,Payment Terms based on conditions,Plačilni pogoji glede na pogoje
DocType: Program Enrollment,School House,šola House
DocType: Serial No,Out of AMC,Od AMC
DocType: Opportunity,Opportunity Amount,Znesek priložnosti
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Your Profile,Tvoj profil
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Število amortizacije naročene ne sme biti večja od skupnega št amortizacije
DocType: Purchase Order,Order Confirmation Date,Datum potrditve naročila
DocType: Driver,HR-DRI-.YYYY.-,HR-DRI-.YYYY.-
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py,All Products,Vsi izdelki
DocType: Employee Transfer,Employee Transfer Details,Podrobnosti o prenosu zaposlenih
apps/erpnext/erpnext/selling/doctype/customer/customer.py,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
DocType: Issue,Ongoing,V teku
apps/erpnext/erpnext/config/accounting.py,Company (not Customer or Supplier) master.,Company (ne stranka ali dobavitelj) gospodar.
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py,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,No Students in,Ni Študenti
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Add more items or open full form,Dodajte več predmetov ali odprto popolno obliko
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,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,Go to Users,Pojdi na uporabnike
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,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,{0} is not a valid Batch Number for Item {1},{0} ni veljavna številka serije za postavko {1}
apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Vnesite veljavno kodo kupona !!
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Opomba: Ni dovolj bilanca dopust za dopust tipa {0}
DocType: Task,Task Description,Opis naloge
DocType: Training Event,Seminar,seminar
DocType: Program Enrollment Fee,Program Enrollment Fee,Program Vpis Fee
DocType: Item,Supplier Items,Dobavitelj Items
DocType: Material Request,MAT-MR-.YYYY.-,MAT-MR-.YYYY.-
DocType: Opportunity,Opportunity Type,Priložnost Type
DocType: Asset Movement,To Employee,Za zaposlene
DocType: Employee Transfer,New Company,Novo podjetje
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py,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,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
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Column Labels : ,Oznake stolpcev:
DocType: Bank Transaction,Settled,Naseljeni
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Disbursement Date cannot be after Loan Repayment Start Date,Datum izplačila ne more biti po datumu začetka vračila posojila
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Cess,Cess
DocType: Quality Feedback,Parameters,Parametri
DocType: Company,Create Chart Of Accounts Based On,"Ustvariti kontni okvir, ki temelji na"
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date of Birth cannot be greater than today.,"Datum rojstva ne more biti večji, od današnjega."
,Stock Ageing,Staranje zaloge
DocType: Travel Request,"Partially Sponsored, Require Partial Funding","Delno sponzorirana, zahteva delno financiranje"
apps/erpnext/erpnext/education/doctype/student/student.py,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,Timesheet,Evidenca prisotnosti
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Batch: ,Serija:
DocType: Volunteer,Afternoon,Popoldne
DocType: Loyalty Program,Loyalty Program Help,Pomoč programa zvestobe
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} '{1}' is disabled,{0} {1} &quot;je onemogočena
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Open,Nastavi kot Odpri
DocType: Cheque Print Template,Scanned Cheque,skeniranih Ček
DocType: Timesheet,Total Billable Amount,Skupaj Odgovorni Znesek
DocType: Customer,Credit Limit and Payment Terms,Kreditno omejitev in plačilni pogoji
DocType: Loyalty Program,Collection Rules,Pravila za zbiranje
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 3,Postavka 3
apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js,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,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"
DocType: Clinical Procedure,Nursing User,Uporabnik zdravstvene nege
DocType: Employee Benefit Application,Payroll Period,Obdobje plačevanja
DocType: Plant Analysis,Plant Analysis Criterias,Kriteriji za analizo rastlin
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Batch {1},Serijska številka {0} ne sodi v paket {1}
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Your email address...,Vaš email naslov...
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Responsibilities,Odgovornosti
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,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: Account,Capital Work in Progress,Kapitalsko delo v teku
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,Please enter atleast 1 invoice in the table,Vnesite atleast 1 račun v tabeli
apps/erpnext/erpnext/utilities/user_progress.py,Add Users,Dodaj uporabnike
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,No Lab Test created,Št Lab test ni ustvarjen
DocType: POS Item Group,Item Group,Element Group
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Student Group: ,Študentska skupina:
DocType: Depreciation Schedule,Finance Book Id,Id knjižne knjige
DocType: Item,Safety Stock,Varnostna zaloga
DocType: Healthcare Settings,Healthcare Settings,Nastavitve zdravstva
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Total Allocated Leaves,Skupna dodeljena lista
apps/erpnext/erpnext/projects/doctype/task/task.py,Progress % for a task cannot be more than 100.,"Napredek% za nalogo, ne more biti več kot 100."
DocType: Stock Reconciliation Item,Before reconciliation,Pred uskladitvijo
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,To {0},Za {0}
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Davki in dajatve na dodano vrednost (Company Valuta)
apps/erpnext/erpnext/accounts/doctype/item_tax_template/item_tax_template.py,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,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,Item {0} must be a Fixed Asset Item,Točka {0} mora biti osnovno sredstvo postavka
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,HSN,HSN
DocType: Item,Default BOM,Privzeta surovina
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,Debit Note Amount,Opomin Znesek
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,"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/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,You are not present all day(s) between compensatory leave request days,Niste bili prisotni ves dan med zahtevki za nadomestni dopust
apps/erpnext/erpnext/setup/doctype/company/company.js,Please re-type company name to confirm,"Prosimo, ponovno tip firma za potrditev"
DocType: Journal Entry,Printing Settings,Nastavitve tiskanja
DocType: Payment Order,Payment Order Type,Vrsta plačilnega naloga
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)
DocType: Shopify Settings,eg: frappe.myshopify.com,npr .: frappe.myshopify.com
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement tracking is not enabled.,Sledenje pogodbe na ravni storitve ni omogočeno.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,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,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,Variable,spremenljivka
apps/erpnext/erpnext/regional/italy/utils.py,"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","Davčni režim je obvezen, vljudno določite fiskalni režim v podjetju {0}"
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js,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: Cashier Closing,From Time,Od časa
DocType: Hotel Settings,Hotel Settings,Hotelske nastavitve
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html,In Stock: ,Na zalogi:
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Investment Banking,Investicijsko bančništvo
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Cash or Bank Account is mandatory for making payment entry,Gotovina ali bančnega računa je obvezen za izdelavo vnos plačila
DocType: Education Settings,LMS Settings,Nastavitve LMS
DocType: Company,Discount Allowed Account,Popust dovoljen račun
DocType: Loyalty Program,Multiple Tier Program,Večstranski program
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Address,študent Naslov
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Address,študent Naslov
DocType: Purchase Invoice,Price List Exchange Rate,Cenik Exchange Rate
apps/erpnext/erpnext/patches/v11_0/rename_supplier_type_to_supplier_group.py,All Supplier Groups,Vse skupine dobaviteljev
DocType: Employee Boarding Activity,Required for Employee Creation,Potreben za ustvarjanje zaposlenih
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account Number {0} already used in account {1},Številka računa {0} je že uporabljena v računu {1}
DocType: GoCardless Mandate,Mandate,Mandat
DocType: Hotel Room Reservation,Booked,Rezervirano
DocType: Detected Disease,Tasks Created,Ustvarjene naloge
DocType: Purchase Invoice Item,Rate,Stopnja
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Intern,Intern
DocType: Delivery Stop,Address Name,naslov Ime
DocType: Stock Entry,From BOM,Od BOM
DocType: Assessment Code,Assessment Code,Koda ocena
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Basic,Osnovni
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock transactions before {0} are frozen,Zaloga transakcije pred {0} so zamrznjeni
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule',"Prosimo, kliknite na &quot;ustvarjajo Seznamu&quot;"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference No is mandatory if you entered Reference Date,"Referenčna številka je obvezna, če ste vnesli Referenčni datum"
DocType: Bank Reconciliation Detail,Payment Document,plačilo dokumentov
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py,Error evaluating the criteria formula,Napaka pri ocenjevanju formule za merila
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date of Joining must be greater than Date of Birth,Datum pridružitva mora biti večji od datuma rojstva
DocType: Subscription,Plans,Načrti
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,Opening Balance,Odpiranje ravnotežja
DocType: Salary Slip,Salary Structure,Struktura Plače
DocType: Account,Bank,Banka
DocType: Job Card,Job Started,Začelo se je delo
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Airline,Airline
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Issue Material,Vprašanje Material
apps/erpnext/erpnext/config/integrations.py,Connect Shopify with ERPNext,Poveži Shopify z ERPNext
DocType: Production Plan,For Warehouse,Za Skladišče
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,Delivery Notes {0} updated,Opombe o dostavi {0} posodobljeni
DocType: Employee,Offer Date,Ponudba Datum
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Quotations,Ponudbe
DocType: Purchase Order,Inter Company Order Reference,Referenčna številka internih naročil
apps/erpnext/erpnext/accounts/page/pos/pos.js,You are in offline mode. You will not be able to reload until you have network.,"Ste v načinu brez povezave. Ne boste mogli naložiti, dokler imate omrežje."
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Qty increased by 1,Vrstica # {0}: Število se je povečalo za 1
DocType: Account,Include in gross,Vključi v bruto
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js,Grant,Grant
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,No Student Groups created.,ustvaril nobene skupine študentov.
DocType: Purchase Invoice Item,Serial No,Zaporedna številka
apps/erpnext/erpnext/hr/doctype/loan/loan.py,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,Please enter Maintaince Details first,"Prosimo, da najprej vnesete Maintaince Podrobnosti"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Vrstica # {0}: Pričakovani datum 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
apps/erpnext/erpnext/education/utils.py,You are not enrolled in program {0},Niste vpisani v program {0}
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/stock/doctype/stock_entry/stock_entry_list.js,Goods In Transit,Blago v tranzitu
apps/erpnext/erpnext/accounts/page/pos/pos.js,Enter value must be positive,Vnesite vrednost mora biti pozitivna
DocType: Asset,Finance Books,Finance Knjige
DocType: Employee Tax Exemption Declaration Category,Employee Tax Exemption Declaration Category,Kategorija izjave o oprostitvi davka na zaposlene
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py,All Territories,Vse Territories
DocType: Lost Reason Detail,Lost Reason Detail,Podrobnosti o izgubljenih razlogih
apps/erpnext/erpnext/hr/utils.py,Please set leave policy for employee {0} in Employee / Grade record,"Prosimo, nastavite politiko dopusta zaposlenega {0} v zapisu zaposlenih / razreda"
apps/erpnext/erpnext/public/js/controllers/transaction.js,Invalid Blanket Order for the selected Customer and Item,Neveljavna naročila za blago za izbrano stranko in postavko
apps/erpnext/erpnext/projects/doctype/task/task_tree.js,Add Multiple Tasks,Dodaj več nalog
DocType: Purchase Invoice,Items,Predmeti
apps/erpnext/erpnext/crm/doctype/contract/contract.py,End Date cannot be before Start Date.,Končni datum ne sme biti pred datumom začetka.
apps/erpnext/erpnext/education/doctype/course_enrollment/course_enrollment.py,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,There are more holidays than working days this month.,Obstaja več prazniki od delovnih dneh tega meseca.
apps/erpnext/erpnext/controllers/buying_controller.py,Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,Naslednji elementi {0} niso označeni kot {1} element. Lahko jih omogočite kot {1} element iz glavnega elementa
DocType: Production Plan Item,Product Bundle Item,Izdelek Bundle Postavka
DocType: Sales Partner,Sales Partner Name,Prodaja Partner Name
apps/erpnext/erpnext/hooks.py,Request for Quotations,Zahteva za Citati
DocType: Payment Reconciliation,Maximum Invoice Amount,Največja Znesek računa
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() failed for empty IBAN,Za prazen IBAN ni uspel BankAccount.validate_iban ()
DocType: Normal Test Items,Normal Test Items,Normalni preskusni elementi
DocType: QuickBooks Migrator,Company Settings,Nastavitve podjetja
DocType: Additional Salary,Overwrite Salary Structure Amount,Znesek nadomestila plače prepišite
DocType: Leave Ledger Entry,Leaves,Listi
DocType: Student Language,Student Language,študent jezik
DocType: Cash Flow Mapping,Is Working Capital,Je delovni kapital
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js,Submit Proof,Predložite dokazilo
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order/Quot %,Naročilo / quot%
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order/Quot %,Naročilo / quot%
apps/erpnext/erpnext/config/healthcare.py,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,From and To dates required,Od in Do datumov zahtevanih
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Securities & Commodity Exchanges,Vrednostnih papirjev in blagovne borze
apps/erpnext/erpnext/templates/pages/search_help.py,Docs Search,Iskanje dokumentov
apps/erpnext/erpnext/stock/doctype/item/item.py,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: Contract,Unfulfilled,Neizpolnjeno
DocType: Delivery Note Item,From Warehouse,Iz skladišča
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,No employees for the mentioned criteria,Za omenjena merila ni zaposlenih
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials to Manufacture,Ni Postavke z Bill materialov za Izdelava
DocType: Shopify Settings,Default Customer,Privzeta stranka
DocType: Sales Stage,Stage Name,Ime stadiona
apps/erpnext/erpnext/config/getting_started.py,Data Import and Settings,Uvoz in nastavitve podatkov
DocType: Warranty Claim,SER-WRN-.YYYY.-,SER-WRN-.YYYY.-
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"
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Ship To State,Pošiljanje v državo
DocType: Program Enrollment Course,Program Enrollment Course,Program Vpis tečaj
DocType: Program Enrollment Course,Program Enrollment Course,Program Vpis tečaj
DocType: Invoice Discounting,Bank Charges,Bančni stroški
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner.py,User {0} is already assigned to Healthcare Practitioner {1},Uporabnik {0} je že dodeljen zdravstvenemu zdravniku {1}
DocType: Purchase Taxes and Charges,Valuation and Total,Vrednotenje in Total
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Negotiation/Review,Pogajanja / pregled
DocType: Leave Encashment,Encashment Amount,Znesek nakladanja
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py,Scorecards,Oglednice
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Expired Batches,Potekli paketi
DocType: Employee,This will restrict user access to other employee records,To bo uporabniku omejilo dostop do drugih zapisov zaposlenih
DocType: Tax Rule,Shipping City,Dostava Mesto
apps/erpnext/erpnext/regional/india/utils.py,GST HSN Code does not exist for one or more items,Koda GST HSN ne obstaja za enega ali več elementov
DocType: Quality Procedure Table,Step,Korak
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Variance ({}),Variance ({})
DocType: Purchase Invoice,Import Of Service,Uvoz storitve
DocType: Education Settings,LMS Title,Naslov LMS
DocType: Sales Invoice,Ship,Ladja
DocType: Staffing Plan Detail,Current Openings,Aktualne odprtine
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Operations,Denarni tok iz poslovanja
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CGST Amount,CGST Znesek
apps/erpnext/erpnext/utilities/activation.py,Create Student,Ustvari študenta
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
DocType: Quality Action Table,Quality Action Table,Tabela kakovosti ukrepov
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Total cannot be zero,Skupaj ne more biti nič
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,'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: Plaid Settings,Plaid Client ID,Plaid ID stranke
DocType: Lab Test Template,Sensitivity,Občutljivost
DocType: Plaid Settings,Plaid Settings,Nastavitve Plaid
apps/erpnext/erpnext/erpnext_integrations/doctype/amazon_mws_settings/amazon_methods.py,Sync has been temporarily disabled because maximum retries have been exceeded,"Sinhronizacija je bila začasno onemogočena, ker so bile prekoračene največje število ponovnih poskusov"
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,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_with_account_number.py,Plants and Machineries,Rastline in stroje
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Davčna Znesek Po Popust Znesek
DocType: Patient,Inpatient Status,Bolnišnično stanje
DocType: Asset Finance Book,In Percentage,V odstotkih
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Selected Price List should have buying and selling fields checked.,Izbrani cenik bi moral imeti preverjena polja nakupa in prodaje.
apps/erpnext/erpnext/controllers/buying_controller.py,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,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,Please select Posting Date first,"Prosimo, izberite datumom knjiženja najprej"
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date should be before Closing Date,Pričetek mora biti pred Zapiranje Datum
DocType: Travel Itinerary,Flight,Polet
apps/erpnext/erpnext/public/js/hub/pages/NotFound.vue,Back to home,Nazaj domov
DocType: Leave Control Panel,Carry Forward,Carry Forward
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,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: Budget,Applicable on booking actual expenses,Veljavno pri rezervaciji dejanskih stroškov
DocType: Department,Days for which Holidays are blocked for this department.,"Dni, za katere so Holidays blokirana za ta oddelek."
DocType: Amazon MWS Settings,ERPNext Integrations,Integracije ERPNext
DocType: Crop Cycle,Detected Disease,Detektirana bolezen
,Produced,Proizvedena
DocType: Issue,Raised By (Email),Postavljeno Z (e-naslov)
DocType: Issue,Service Level Agreement,Sporazum o ravni storitev
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,Last Communication,Zadnje sporočilo
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication,Zadnje sporočilo
,TDS Payable Monthly,TDS se plača mesečno
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Vrstni red za zamenjavo BOM. Traja lahko nekaj minut.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,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/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Prosimo, nastavite sistem poimenovanja zaposlenih v kadrovski službi&gt; Nastavitve človeških virov"
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Skupna plačila
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serijska št Zahtevano za zaporednimi postavki {0}
apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Match plačila z računov
DocType: Payment Entry,Get Outstanding Invoice,Pridobite neporavnane račune
DocType: Journal Entry,Bank Entry,Banka Začetek
apps/erpnext/erpnext/stock/doctype/item/item.py,Updating Variants...,Posodobitev različic ...
DocType: Authorization Rule,Applicable To (Designation),Ki se uporabljajo za (Oznaka)
,Profitability Analysis,Analiza dobičkonosnosti
DocType: Fees,Student Email,Student Email
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Disburse Loan,Izplačilo posojila
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/item_configure.js,Add to Cart,Dodaj v voziček
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js,Group By,Skupina S
apps/erpnext/erpnext/config/accounting.py,Enable / disable currencies.,Omogoči / onemogoči valute.
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Could not submit some Salary Slips,Ne morem poslati nekaterih plačnih lističev
DocType: Project Template,Project Template,Predloga projekta
DocType: Exchange Rate Revaluation,Get Entries,Get Entries
DocType: Production Plan,Get Material Request,Get Zahteva material
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Postal Expenses,Poštni stroški
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html,Sales Summary,Povzetek prodaje
apps/erpnext/erpnext/controllers/trends.py,Total(Amt),Skupaj (Amt)
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please identify/create Account (Group) for type - {0},Opišite / ustvarite račun (skupino) za vrsto - {0}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Entertainment & Leisure,Zabava &amp; prosti čas
,Item Variant Details,Podrobnosti o elementu Variante
DocType: Quality Inspection,Item Serial No,Postavka Zaporedna številka
DocType: Payment Request,Is a Subscription,Je naročnina
apps/erpnext/erpnext/utilities/activation.py,Create Employee Records,Ustvari zaposlencev zapisov
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Present,Skupaj Present
DocType: Work Order,MFG-WO-.YYYY.-,MFG-WO-.YYYY.-
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,Please select Qty against item {0},Izberite količino proti elementu {0}
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Latest Age,Najnovejša doba
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Transfer Material to Supplier,Prenos Material za dobavitelja
apps/erpnext/erpnext/hr/report/loan_repayment/loan_repayment.py,EMI,EMI
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,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/utilities/activation.py,Create Quotation,Ustvarite predračun
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,You are not authorized to approve leaves on Block Dates,Niste pooblaščeni za odobritev liste na Block termini
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} Request for {1},{0} Zahteva za {1}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,All these items have already been invoiced,Vsi ti artikli so že bili obračunani
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,No outstanding invoices found for the {0} {1} which qualify the filters you have specified.,"Za {0} {1} ni mogoče najti neporavnanih računov, ki izpolnjujejo filtre, ki ste jih določili."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Set New Release Date,Nastavite nov datum izdaje
DocType: Company,Monthly Sales Target,Mesečni prodajni cilj
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,No outstanding invoices found,Neplačanih računov ni bilo mogoče najti
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Can be approved by {0},Mogoče odobriti {0}
DocType: Hotel Room,Hotel Room Type,Tip sobe hotela
DocType: Customer,Account Manager,Upravitelj računa
DocType: Issue,Resolution By Variance,Ločljivost po različici
DocType: Leave Allocation,Leave Period,Pustite obdobje
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,Unknown,Neznan
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order not created,Delovni nalog ni bil ustvarjen
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"An amount of {0} already claimed for the component {1},\
						 set the amount equal or greater than {2}","Količina {0}, ki je bila že zahtevana za komponento {1}, \ nastavite znesek, enak ali večji od {2}"
DocType: Shipping Rule,Shipping Rule Conditions,Pogoji dostavnega pravila
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: Bank Account,SWIFT number,SWIFT številka
DocType: Payment Entry,Party Name,Ime stranka
DocType: POS Closing Voucher,Total Collected Amount,Skupni zbrani znesek
DocType: Employee Benefit Application,Benefits Applied,"Prednosti, ki se uporabljajo"
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,Not Marked,ne Označeno
DocType: Service Level Priority,Response Time Period,Čas odziva
DocType: Contract,Signed,Podpisano
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices Summary,Povzetek povzetka računov
DocType: Member,NPO-MEM-.YYYY.-,NPO-MEM-.GGGG.-
DocType: Education Settings,Education Manager,Vodja izobraževanja
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inter-State Supplies,Meddržavne dobrine
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
DocType: Quality Inspection,Report Date,Poročilo Datum
DocType: BOM,Routing,Usmerjanje
DocType: Serial No,Asset Details,Podrobnosti o sredstvih
DocType: Employee Tax Exemption Declaration Category,Declared Amount,Deklarirani znesek
DocType: Bank Statement Transaction Payment Item,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/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Prihodnje plačilo Ref
DocType: Quotation,Additional Discount and Coupon Code,Dodatna koda popusta in kupona
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
					have been quoted. Updating the RFQ quote status.","{0} označuje, da {1} ne bo podal ponudbe, ampak cene vseh postavk so navedene. Posodabljanje statusa ponudb RFQ."
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Največji vzorci - {0} so bili že shranjeni za serijo {1} in element {2} v seriji {3}.
DocType: Manufacturing Settings,Update BOM Cost Automatically,Posodobi BOM stroškov samodejno
DocType: Lab Test,Test Name,Ime preskusa
DocType: Healthcare Settings,Clinical Procedure Consumable Item,Klinični postopek Potrošni element
apps/erpnext/erpnext/utilities/activation.py,Create Users,Ustvari uporabnike
apps/erpnext/erpnext/utilities/user_progress.py,Gram,gram
DocType: Employee Tax Exemption Category,Max Exemption Amount,Najvišji znesek oprostitve
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,Subscriptions,Naročnine
DocType: Quality Review Table,Objective,Cilj
DocType: Supplier Scorecard,Per Month,Na mesec
DocType: Education Settings,Make Academic Term Mandatory,Naredite akademski izraz obvezen
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Quantity to Manufacture must be greater than 0.,Količina na Izdelava mora biti večja od 0.
apps/erpnext/erpnext/config/crm.py,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: Shopping Cart Settings,Show Contact Us Button,Prikaži gumb Stik z nami
DocType: Loyalty Program,Customer Group,Skupina za stranke
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch ID (Optional),Nova Serija ID (po želji)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Expense account is mandatory for item {0},Expense račun je obvezna za postavko {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Release date must be in the future,Datum izdaje mora biti v prihodnosti
DocType: BOM,Website Description,Spletna stran Opis
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Equity,Neto sprememba v kapitalu
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py,Not permitted. Please disable the Service Unit Type,"Ni dovoljeno. Prosimo, onemogočite vrsto servisne enote"
apps/erpnext/erpnext/crm/doctype/lead/lead.py,"Email Address must be unique, already exists for {0}","E-poštni naslov mora biti edinstven, že obstaja za {0}"
DocType: Serial No,AMC Expiry Date,AMC preteka Datum
DocType: Asset,Receipt,prejem
,Sales Register,Prodaja Register
DocType: Daily Work Summary Group,Send Emails At,Pošlji e-pošte na
DocType: Quotation Lost Reason,Quotation Lost Reason,Kotacija Lost Razlog
apps/erpnext/erpnext/accounts/doctype/sales_invoice/regional/india_list.js,Generate e-Way Bill JSON,Ustvari e-Way Bill JSON
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Transaction reference no {0} dated {1},Referenčna transakcija ni {0} dne {1}
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js,There is nothing to edit.,Nič ni za urejanje.
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Form View,Pogled obrazca
DocType: HR Settings,Expense Approver Mandatory In Expense Claim,Odobritev stroškov je obvezna v zahtevi za odhodke
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Summary for this month and pending activities,Povzetek za ta mesec in v teku dejavnosti
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,Please set Unrealized Exchange Gain/Loss Account in Company {0},V podjetju nastavite neizkoriščen račun za dobiček / izgubo za Exchange {0}
apps/erpnext/erpnext/utilities/user_progress.py,"Add users to your organization, other than yourself.","Dodajte uporabnike v svojo organizacijo, razen sebe."
DocType: Customer Group,Customer Group Name,Ime skupine strank
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}: Quantity not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Vrstica {0}: Količina ni na voljo za {4} v skladišču {1} ob času objave vnosa ({2} {3})
apps/erpnext/erpnext/public/js/pos/pos.html,No Customers yet!,Ni še nobene stranke!
DocType: Quality Procedure Process,Link existing Quality Procedure.,Povezati obstoječi postopek kakovosti.
apps/erpnext/erpnext/config/hr.py,Loans,Posojila
DocType: Healthcare Service Unit,Healthcare Service Unit,Enota za zdravstveno varstvo
,Customer-wise Item Price,Cena izdelka za kupce
apps/erpnext/erpnext/public/js/financial_statements.js,Cash Flow Statement,Izkaz denarnih tokov
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No material request created,Ni ustvarjeno nobeno materialno zahtevo
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.py,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,License,licenca
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,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: Healthcare Practitioner,Phone (R),Telefon (R)
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid {0} for Inter Company Transaction.,Neveljaven {0} za transakcijo med podjetji.
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Time slots added,Dodane so časovne reže
DocType: Products Settings,Attributes,Atributi
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Enable Template,Omogoči predlogo
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please enter Write Off Account,Vnesite račun za odpis
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Last Order Date,Zadnja Datum naročila
DocType: Accounts Settings,Unlink Advance Payment on Cancelation of Order,Prekličite predplačilo ob preklicu naročila
DocType: Salary Component,Is Payable,Je plačljivo
DocType: Inpatient Record,B Negative,B Negativno
DocType: Pricing Rule,Price Discount Scheme,Shema popustov na cene
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Maintenance Status has to be Cancelled or Completed to Submit,"Stanje vzdrževanja je treba preklicati ali končati, da ga pošljete"
DocType: Amazon MWS Settings,US,ZDA
DocType: Holiday List,Add Weekly Holidays,Dodaj tedenske počitnice
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Report Item,Postavka poročila
DocType: Staffing Plan Detail,Vacancies,Prosta delovna mesta
DocType: Hotel Room,Hotel Room,Hotelska soba
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} does not belongs to company {1},Račun {0} ne pripada podjetju {1}
DocType: Homepage Section,Use this field to render any custom HTML in the section.,"To polje uporabite v polju, če želite prikazati poljuben HTML po meri."
DocType: Leave Type,Rounding,Zaokroževanje
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Serial Numbers in row {0} does not match with Delivery Note,Številke v vrstici {0} se ne ujema z dobavnice
DocType: Employee Benefit Application,Dispensed Amount (Pro-rated),Razdeljeni znesek (Pro-rated)
DocType: Student,Guardian Details,Guardian Podrobnosti
DocType: C-Form,C-Form,C-Form
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! First 2 digits of GSTIN should match with State number {0}.,Neveljaven GSTIN! Prvi dve števki GSTIN bi se morali ujemati z državno številko {0}.
DocType: Agriculture Task,Start Day,Začni dan
DocType: Vehicle,Chassis No,podvozje ni
DocType: Payment Entry,Initiated,Začela
DocType: Production Plan Item,Planned Start Date,Načrtovani datum začetka
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select a BOM,Izberite BOM
DocType: Purchase Invoice,Availed ITC Integrated Tax,Uporabil integrirani davek ITC
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Repayment Entry,Ustvari vnos vračila
DocType: Purchase Order Item,Blanket Order Rate,Stopnja poravnave
,Customer Ledger Summary,Povzetek glavne knjige strank
apps/erpnext/erpnext/hooks.py,Certification,Certificiranje
DocType: Bank Guarantee,Clauses and Conditions,Klavzule in pogoji
DocType: Serial No,Creation Document Type,Creation Document Type
DocType: Amazon MWS Settings,ES,ES
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invoices,Pridobite račune
DocType: Leave Allocation,New Leaves Allocated,Nove Listi Dodeljena
apps/erpnext/erpnext/controllers/trends.py,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,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: Journal Entry,Inter Company Journal Entry Reference,Referenčni opis vmesnika podjetja
DocType: Course,Topics,Teme
DocType: Tally Migration,Is Day Book Data Processed,Ali so podatki o dnevnikih obdelani
DocType: Appraisal Template,Appraisal Template Title,Cenitev Predloga Naslov
apps/erpnext/erpnext/utilities/user_progress_utils.py,Commercial,Commercial
DocType: Patient,Alcohol Current Use,Alkoholna trenutna uporaba
DocType: Employee Tax Exemption Proof Submission,House Rent Payment Amount,Hišni znesek najemnine
DocType: Student Admission Program,Student Admission Program,Program sprejema študentov
DocType: Employee Tax Exemption Sub Category,Tax Exemption Category,Kategorija davčne oprostitve
DocType: Payment Entry,Account Paid To,Račun Izplača
DocType: Subscription Settings,Grace Period,Grace Period
DocType: Item Alternative,Alternative Item Name,Alternativno ime predmeta
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py,Parent Item {0} must not be a Stock Item,Parent Item {0} ne sme biti Stock Postavka
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Cannot create a Delivery Trip from Draft documents.,Iz osnutkov dokumentov ni mogoče ustvariti potovanja.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Website Listing,Seznam spletnih mest
apps/erpnext/erpnext/config/buying.py,All Products or Services.,Vse izdelke ali storitve.
DocType: Email Digest,Open Quotations,Odprte Ponudbe
apps/erpnext/erpnext/www/all-products/item_row.html,More Details,Več podrobnosti
DocType: Supplier Quotation,Supplier Address,Dobavitelj Naslov
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} proračun za račun {1} na {2} {3} je {4}. Bo prekoračen za {5}
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,This feature is under development...,Ta funkcija je v razvoju ...
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Creating bank entries...,Ustvarjanje bančnih vnosov ...
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Out Qty,Out Kol
apps/erpnext/erpnext/buying/doctype/supplier/supplier.py,Series is mandatory,Serija je obvezna
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Financial Services,Finančne storitve
DocType: Student Sibling,Student ID,Student ID
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Quantity must be greater than zero,Za količino mora biti večja od nič
apps/erpnext/erpnext/config/projects.py,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: Email Campaign,Email Campaign,E-poštna akcija
apps/erpnext/erpnext/public/js/hub/hub_call.js,Marketplace Error,Napaka na trgu
DocType: Complaint,Complaint,Pritožba
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Warehouse required for stock Item {0},Skladišče je potrebna za borzo postavki {0}
DocType: Leave Allocation,Unused leaves,Neizkoriščene listi
apps/erpnext/erpnext/patches/v11_0/create_department_records_for_each_company.py,All Departments,Vsi oddelki
DocType: Healthcare Service Unit,Vacant,Prazen
DocType: Patient,Alcohol Past Use,Pretekla uporaba alkohola
DocType: Fertilizer Content,Fertilizer Content,Vsebina gnojil
apps/erpnext/erpnext/public/js/hub/pages/Seller.vue,No description,brez opisa
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Cr,Cr
DocType: Tax Rule,Billing State,Država za zaračunavanje
DocType: Quality Goal,Monitoring Frequency,Spremljanje pogostosti
DocType: Share Transfer,Transfer,Prenos
DocType: Quality Action,Quality Feedback,Kakovostne povratne informacije
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Work Order {0} must be cancelled before cancelling this Sales Order,Delovni nalog {0} morate preklicati pred preklicem tega prodajnega naloga
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,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,Due Date is mandatory,Datum zapadlosti je obvezno
apps/erpnext/erpnext/controllers/accounts_controller.py,Cannot set quantity less than received quantity,Količine ni mogoče nastaviti manj kot prejeto količino
apps/erpnext/erpnext/controllers/item_variant.py,Increment for Attribute {0} cannot be 0,Prirastek za Attribute {0} ne more biti 0
DocType: Employee Benefit Claim,Benefit Type and Amount,Vrsta in znesek ugodnosti
DocType: Delivery Stop,Visited,Obiskan
apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py,Rooms Booked,Sobe Rezervirano
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Ends On date cannot be before Next Contact Date.,Konec Na datum ne more biti pred naslednjim datumom stika.
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batch Entries,Vstopne serije
DocType: Journal Entry,Pay To / Recd From,Pay / Recd Od
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Unpublish Item,Razveljavi element
DocType: Naming Series,Setup Series,Nastavitve zaporedja
DocType: Payment Reconciliation,To Invoice Date,Če želite Datum računa
DocType: Bank Account,Contact HTML,Kontakt HTML
DocType: Support Settings,Support Portal,Podporni portal
apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py,Registration fee can not be Zero,Prijavnina ne sme biti nič
DocType: Disease,Treatment Period,Obdobje zdravljenja
DocType: Travel Itinerary,Travel Itinerary,Načrt potovanja
apps/erpnext/erpnext/education/api.py,Result already Submitted,Rezultat že oddan
apps/erpnext/erpnext/controllers/buying_controller.py,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,Please wait 3 days before resending the reminder.,Počakajte 3 dni pred ponovnim pošiljanjem opomnika.
DocType: Landed Cost Voucher,Purchase Receipts,Odkupne Prejemki
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,"Upload a bank statement, link or reconcile a bank account","Naložite bančni izpisek, povežite ali uskladite bančni račun"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,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,Retail,Maloprodaja
DocType: Student Attendance,Absent,Odsoten
DocType: Staffing Plan,Staffing Plan Detail,Podrobnosti o kadrovskem načrtu
DocType: Employee Promotion,Promotion Date,Datum promocije
apps/erpnext/erpnext/hr/doctype/leave_ledger_entry/leave_ledger_entry.py,Leave allocation %s is linked with leave application %s,Dodelitev dopusta% s je povezana s prošnjo za dopust% s
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Product Bundle,Bundle izdelek
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,"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,Row {0}: Invalid reference {1},Vrstica {0}: Neveljavna referenčna {1}
apps/erpnext/erpnext/assets/doctype/location/location_tree.js,New Location,Nova lokacija
DocType: Purchase Invoice,Purchase Taxes and Charges Template,Nakup davki in dajatve Template
DocType: Additional Salary,Date on which this component is applied,"Datum, ko je ta komponenta uporabljena"
DocType: Subscription,Current Invoice Start Date,Začetni datum trenutnega računa
DocType: Designation Skill,Designation Skill,Naziv spretnosti
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of goods,Uvoz blaga
DocType: Timesheet,TS-,TS-
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: zahtevan je debetni ali kreditni znesek za {2}
DocType: GL Entry,Remarks,Opombe
DocType: Support Settings,Track Service Level Agreement,Sledite sporazumu o ravni storitev
DocType: Hotel Room Amenity,Hotel Room Amenity,Hotelska ugodnost
DocType: Budget,Action if Annual Budget Exceeded on MR,"Ukrep, če je letni proračun presegel MR"
DocType: Course Enrollment,Course Enrollment,Vpis na tečaj
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: Project,From Template,S predloge
DocType: Journal Entry,Write Off Based On,Odpisuje temelji na
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,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,Send Supplier Emails,Pošlji Dobavitelj e-pošte
DocType: Asset Movement,ACC-ASM-.YYYY.-,ACC-ASM-.LLLL.-
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Plača je že pripravljena za obdobje med {0} in {1}, Pusti obdobje uporabe ne more biti med tem časovnem obdobju."
DocType: Fiscal Year,Auto Created,Samodejno ustvarjeno
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,Submit this to create the Employee record,"Pošljite to, da ustvarite zapis zaposlenega"
DocType: Item Default,Item Default,Element Privzeto
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Intra-State Supplies,Potrebščine znotraj države
DocType: Chapter Member,Leave Reason,Pustite razlog
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py,IBAN is not valid,IBAN ni veljaven
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Invoice {0} no longer exists,Račun {0} ne obstaja več
DocType: Guardian Interest,Guardian Interest,Guardian Obresti
DocType: Volunteer,Availability,Razpoložljivost
apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.py,Leave application is linked with leave allocations {0}. Leave application cannot be set as leave without pay,Prošnja za dopust je povezana z dodelitvijo dopusta {0}. Zapustitve vloge ni mogoče nastaviti kot dopust brez plačila
apps/erpnext/erpnext/config/retail.py,Setup default values for POS Invoices,Nastavitev privzetih vrednosti za račune POS
DocType: Employee Training,Training,usposabljanje
DocType: Project,Time to send,Čas za pošiljanje
apps/erpnext/erpnext/public/js/hub/pages/Selling.vue,This page keeps track of your items in which buyers have showed some interest.,"Ta stran spremlja vaše izdelke, za katere so kupci pokazali nekaj zanimanja."
DocType: Timesheet,Employee Detail,Podrobnosti zaposleni
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.py,Set warehouse for Procedure {0} ,Nastavite skladišče za postopek {0}
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Email ID,Guardian1 E-ID
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Email ID,Guardian1 E-ID
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Error: {0} is mandatory field,Napaka: {0} je obvezno polje
DocType: Lab Prescription,Test Code,Testna koda
apps/erpnext/erpnext/config/website.py,Settings for website homepage,Nastavitve za spletni strani
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} je na čakanju do {1}
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ-ji niso dovoljeni za {0} zaradi postavke ocene rezultatov {1}
apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Naredite račun za nakup
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Uporabljeni listi
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Uporabljeni kuponi so {1}. Dovoljena količina je izčrpana
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Ali želite oddati materialno zahtevo
DocType: Job Offer,Awaiting Response,Čakanje na odgovor
DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-YYYY-
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Above,Nad
DocType: Support Search Source,Link Options,Možnosti povezave
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Total Amount {0},Skupni znesek {0}
apps/erpnext/erpnext/controllers/item_variant.py,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,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,Row {0}: Cost center is required for an item {1},Vrstica {0}: Za postavko je potreben stroškovni center {1}
DocType: Training Event Employee,Optional,Neobvezno
DocType: Salary Slip,Earning & Deduction,Zaslužek &amp; Odbitek
DocType: Agriculture Analysis Criteria,Water Analysis,Analiza vode
DocType: Sales Order,Skip Delivery Note,Preskočite dobavnico
DocType: Price List,Price Not UOM Dependent,Cena ni odvisna od UOM
apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} ustvarjene različice.
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Pogodba o ravni privzete storitve že obstaja.
DocType: Quality Objective,Quality Objective,Cilj kakovosti
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Optional. This setting will be used to filter in various transactions.,Neobvezno. Ta nastavitev bo uporabljena za filtriranje v različnih poslih.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,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,Reload Linked Analysis,Ponovno naloži povezano analizo
DocType: Fiscal Year,"For e.g. 2012, 2012-13","Za primer leta 2012, 2012-13"
DocType: Purchase Order,Purchase Order Pricing Rule,Pravilo o cenah naročil
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,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,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,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: Homepage Section Card,Subtitle,Podnaslov
apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py,No record found,Nobenega zapisa najdenih
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Scrapped Asset,Stroški izločeni sredstvi
DocType: Employee Checkin,OUT,ZUNAJ
apps/erpnext/erpnext/controllers/stock_controller.py,{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,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,Split,Split
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split,Split
DocType: Tally Migration,Master Data,Glavni podatki
DocType: Employee Transfer,Re-allocate Leaves,Ponovno dodelite listi
DocType: GL Entry,Is Advance,Je Advance
apps/erpnext/erpnext/config/hr.py,Employee Lifecycle,Lifecycle zaposlenih
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,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,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,Last Communication Date,Zadnje Sporočilo Datum
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication Date,Zadnje Sporočilo Datum
DocType: Clinical Procedure Item,Clinical Procedure Item,Postavka kliničnega postopka
DocType: Sales Team,Contact No.,Kontakt št.
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Billing Address is same as Shipping Address,Naslov za izstavitev računa je isti kot naslov za pošiljanje
DocType: Bank Reconciliation,Payment Entries,Plačilni vnosi
DocType: Location,Latitude,Zemljepisna širina
DocType: Work Order,Scrap Warehouse,ostanki Skladišče
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}","Skladišče, potrebno na vrstico št. {0}, nastavite privzeto skladišče za predmet {1} za podjetje {2}"
DocType: Work Order,Check if material transfer entry is not required,"Preverite, ali je vpis prenosa materiala ni potrebno"
DocType: Work 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/help.py,Publish Items on Website,Objavite elementov na spletni strani
apps/erpnext/erpnext/utilities/activation.py,Group your students in batches,Skupina učenci v serijah
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be greater than unadjusted amount,Dodeljeni znesek ne sme biti večji od neprilagojenega zneska
DocType: Authorization Rule,Authorization Rule,Dovoljenje Pravilo
apps/erpnext/erpnext/projects/doctype/project/project.py,Status must be Cancelled or Completed,Status mora biti preklican ali dokončan
DocType: Sales Invoice,Terms and Conditions Details,Pogoji in Podrobnosti
DocType: Sales Invoice,Sales Taxes and Charges Template,Prodajne Davki in dajatve predloge
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Total (Credit),Skupaj (Credit)
DocType: Repayment Schedule,Payment Date,Dan plačila
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch Qty,Nova Serija Kol
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch Qty,Nova Serija Kol
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Apparel & Accessories,Oblačila in dodatki
apps/erpnext/erpnext/controllers/accounts_controller.py,Item quantity can not be zero,Količina artikla ne more biti nič
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Could not solve weighted score function. Make sure the formula is valid.,"Funkcije uteženih rezultatov ni bilo mogoče rešiti. Prepričajte se, da formula velja."
DocType: Invoice Discounting,Loan Period (Days),Obdobje posojila (dnevi)
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Purchase Order Items not received on time,Točke naročilnice niso bile prejete pravočasno
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,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,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/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Transactions already retreived from the statement,Transakcije so že umaknjene iz izpisa
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Opening Value,Otvoritev Vrednost
DocType: Salary Component,Formula,Formula
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Serial #,Serial #
DocType: Material Request Plan Item,Required Quantity,Zahtevana količina
DocType: Lab Test Template,Lab Test Template,Lab Test Template
apps/erpnext/erpnext/accounts/doctype/accounting_period/accounting_period.py,Accounting Period overlaps with {0},Računovodsko obdobje se prekriva z {0}
apps/erpnext/erpnext/setup/doctype/company/company.py,Sales Account,Prodajni račun
DocType: Purchase Invoice Item,Total Weight,Totalna teža
DocType: Pick List Item,Pick List Item,Izberi element seznama
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Commission on Sales,Komisija za prodajo
DocType: Job Offer Term,Value / Description,Vrednost / Opis
apps/erpnext/erpnext/controllers/accounts_controller.py,"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,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debetnih in kreditnih ni enaka za {0} # {1}. Razlika je {2}.
DocType: Clinical Procedure Item,Invoice Separately as Consumables,Račun ločeno kot potrošni material
DocType: Budget,Control Action,Kontrolni ukrep
DocType: Asset Maintenance Task,Assign To Name,Dodeli imenu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Entertainment Expenses,Zabava Stroški
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open Item {0},Odpri Artikel {0}
DocType: Asset Finance Book,Written Down Value,Zapisana vrednost
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Račun {0} je potrebno preklicati pred preklicom tega prodajnega naročila
DocType: Clinical Procedure,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,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/selling/page/point_of_sale/point_of_sale.js,Search Item (Ctrl + i),Element iskanja (Ctrl + i)
DocType: C-Form,ACC-CF-.YYYY.-,ACC-CF-.GGGG.-
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction can not be deleted,Račun z obstoječim poslom ni mogoče izbrisati
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Why do think this Item should be removed?,"Zakaj mislite, da je treba ta izdelek odstraniti?"
DocType: Vehicle,Last Carbon Check,Zadnja Carbon Check
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Pravni stroški
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Izberite količino na vrsti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Delovni nalog {0}: službene izkaznice ni mogoče najti za operacijo {1}
DocType: Purchase Invoice,Posting Time,Ura vnosa
DocType: Timesheet,% Amount Billed,% Zaračunani znesek
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,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,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_with_account_number.py,Direct Expenses,Neposredni stroški
DocType: Pricing Rule Detail,Child Docname,Docname otroka
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,New Customer Revenue,New Customer Prihodki
apps/erpnext/erpnext/config/support.py,Service Level.,Raven storitev.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Travel Expenses,Potni stroški
DocType: Maintenance Visit,Breakdown,Zlomiti se
DocType: Travel Itinerary,Vegetarian,Vegetarijansko
DocType: Patient Encounter,Encounter Date,Datum srečanja
DocType: Work Order,Update Consumed Material Cost In Project,Posodobiti porabljene stroške materiala v projektu
apps/erpnext/erpnext/controllers/accounts_controller.py,Account: {0} with currency: {1} can not be selected,Račun: {0} z valuti: ne more biti izbran {1}
DocType: Bank Statement Transaction Settings Item,Bank Data,Podatki banke
DocType: Purchase Receipt Item,Sample Quantity,Količina vzorca
DocType: Bank Guarantee,Name of Beneficiary,Ime upravičenca
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: Supplier,SUP-.YYYY.-,SUP-.YYYY.-
,BOM Items and Scraps,Predmeti in zapisi BOM
DocType: Bank Reconciliation Detail,Cheque Date,Ček Datum
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} does not belong to company: {2},Račun {0}: Matični račun {1} ne pripada podjetju: {2}
apps/erpnext/erpnext/setup/doctype/company/company.js,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,As on Date,Kot na datum
DocType: Additional Salary,HR,Človeški viri
DocType: Course 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,Probation,Poskusno delo
DocType: Company,Sales Settings,Nastavitve prodaje
DocType: Program Enrollment Tool,New Academic Year,Novo študijsko leto
DocType: Supplier Scorecard,Load All Criteria,Naložite vsa merila
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,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,Total Paid Amount,Skupaj Plačan znesek
DocType: GST Settings,B2C Limit,Omejitev B2C
DocType: Job Card,Transferred Qty,Prenese Kol
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,The selected payment entry should be linked with a creditor bank transaction,Izbrani vnos plačila mora biti povezan s transakcijo banke upnika
DocType: POS Closing Voucher,Amount in Custody,Znesek v skrbništvu
apps/erpnext/erpnext/config/help.py,Navigating,Krmarjenje
apps/erpnext/erpnext/hr/doctype/hr_settings/hr_settings.js,Password policy cannot contain spaces or simultaneous hyphens. The format will be restructured automatically,Pravilnik o geslu ne sme vsebovati presledkov ali istočasnih vezajev. Oblika se samodejno prestrukturira
DocType: Quotation Item,Planning,Načrtovanje
DocType: Salary Component,Depends on Payment Days,Odvisno od plačilnih dni
DocType: Contract,Signee,Signee
DocType: Share Balance,Issued,Izdala
DocType: Loan,Repayment Start Date,Datum začetka odplačevanja
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Student Activity,študent dejavnost
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Supplier Id,Dobavitelj Id
DocType: Payment Request,Payment Gateway Details,Plačilo Gateway Podrobnosti
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity should be greater than 0,Količina mora biti večja od 0
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Price or product discount slabs are required,Potrebne so plošče za ceno ali popust
DocType: Journal Entry,Cash Entry,Cash Začetek
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,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: Attendance Request,Half Day Date,Poldnevni datum
DocType: Academic Year,Academic Year Name,Ime študijsko leto
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} not allowed to transact with {1}. Please change the Company.,"{0} ni dovoljeno posredovati z {1}. Prosimo, spremenite družbo."
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_sub_category/employee_tax_exemption_sub_category.py,Max Exemption Amount cannot be greater than maximum exemption amount {0} of Tax Exemption Category {1},Najvišji znesek oprostitve ne sme presegati najvišjega zneska oprostitve {0} kategorije oprostitev davkov {1}
DocType: Sales Partner,Contact Desc,Kontakt opis izdelka
DocType: Email Digest,Send regular summary reports via Email.,Pošlji redna zbirna poročila preko e-maila.
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Please set default account in Expense Claim Type {0},"Prosim, nastavite privzetega računa v Tip Expense Terjatve {0}"
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Available Leaves,Na voljo listi
DocType: Assessment Result,Student Name,Student Ime
DocType: Hub Tracked Item,Item Manager,Element Manager
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Payroll Payable,Plače plačljivo
DocType: GSTR 3B Report,April,April
DocType: Plant Analysis,Collection Datetime,Zbirka Datetime
DocType: Asset Repair,ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-
DocType: Work Order,Total Operating Cost,Skupni operativni stroški
apps/erpnext/erpnext/controllers/selling_controller.py,Note: Item {0} entered multiple times,Opomba: Točka {0} vpisana večkrat
apps/erpnext/erpnext/config/buying.py,All Contacts.,Vsi stiki.
DocType: Accounting Period,Closed Documents,Zaprti dokumenti
DocType: Healthcare Settings,Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Upravljanje s pripisom Imetnik samodejno predloži in samodejno prekliče za srečanje bolnikov
apps/erpnext/erpnext/config/website.py,Add cards or custom sections on homepage,Na domačo stran dodajte kartice ali razdelke po meri
DocType: Patient Appointment,Referring Practitioner,Referenčni zdravnik
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation,Kratica podjetja
apps/erpnext/erpnext/hr/doctype/employee/employee.py,User {0} does not exist,Uporabnik {0} ne obstaja
DocType: Payment Term,Day(s) after invoice date,Dan (dan) po datumu računa
apps/erpnext/erpnext/setup/doctype/company/company.js,Date of Commencement should be greater than Date of Incorporation,Datum začetka je večji od datuma začetka registracije
DocType: Contract,Signed On,Podpisano
DocType: Bank Account,Party Type,Vrsta Party
DocType: Discounted Invoice,Discounted Invoice,Popustni račun
DocType: Payment Schedule,Payment Schedule,Urnik plačila
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,No Employee found for the given employee field value. '{}': {},Za določeno vrednost polja zaposlenega ni bilo najdenega zaposlenega. &#39;{}&#39;: {}
DocType: Item Attribute Value,Abbreviation,Kratica
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry already exists,Plačilo vnos že obstaja
DocType: Course Content,Quiz,Kviz
DocType: Subscription,Trial Period End Date,Končni datum poskusnega obdobja
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Not authroized since {0} exceeds limits,"Ne authroized saj je {0}, presega meje"
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Start entering data from here : ,Začnite vnašati podatke od tukaj:
DocType: Serial No,Asset Status,Stanje sredstev
DocType: Sales Invoice,Over Dimensional Cargo (ODC),Nad dimenzijskim tovorom (ODC)
DocType: Restaurant Order Entry,Restaurant Table,Restavracija Tabela
DocType: Hotel Room,Hotel Manager,Hotel Manager
apps/erpnext/erpnext/utilities/activation.py,Create Student Batch,Ustvari študentsko serijo
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Set Tax Rule for shopping cart,Nastavite Davčna pravilo za nakupovalno košarico
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.py,There are no vacancies under staffing plan {0},V kadrovskem načrtu ni prostih mest {0}
DocType: Purchase Invoice,Taxes and Charges Added,Davki in dajatve Dodano
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,"Amortizacijski vrstici {0}: Naslednji Amortizacijski datum ne sme biti pred datumom, ki je na voljo za uporabo"
,Sales Funnel,Prodaja toka
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Kratica je obvezna
DocType: Project,Task Progress,naloga Progress
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Košarica
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.py,Bank account {0} already exists and could not be created again,Bančni račun {0} že obstaja in ga ni več mogoče ustvariti
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Missed,Pokliči klic
DocType: Certified Consultant,GitHub ID,GitHub ID
DocType: Staffing Plan,Total Estimated Budget,Skupni predvideni proračun
,Qty to Transfer,Količina Prenos
apps/erpnext/erpnext/config/selling.py,Quotes to Leads or Customers.,Ponudbe za interesente ali stranke.
DocType: Stock Settings,Role Allowed to edit frozen stock,Vloga Dovoljeno urediti zamrznjeno zalog
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Customer Groups,Vse skupine strank
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Accumulated Monthly,Bilančni Mesečni
DocType: Attendance Request,On Duty,Na dolžnosti
apps/erpnext/erpnext/controllers/accounts_controller.py,{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/hr/doctype/staffing_plan/staffing_plan.py,Staffing Plan {0} already exist for designation {1},Kadrovski načrt {0} že obstaja za oznako {1}
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Template is mandatory.,Davčna Predloga je obvezna.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Goods are already received against the outward entry {0},Blago je že prejeto proti vhodnemu vnosu {0}
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Last Issue,Zadnja izdaja
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} does not exist,Račun {0}: Matični račun {1} ne obstaja
DocType: Bank Account,Mask,Maska
DocType: POS Closing Voucher,Period Start Date,Datum začetka obdobja
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
apps/erpnext/erpnext/config/retail.py,To make Customer based incentive schemes.,Ustvariti spodbujevalne sheme s strani kupcev.
DocType: Lab Prescription,Test Created,Ustvarjeno testiranje
DocType: Healthcare Settings,Custom Signature in Print,Podpis po meri v tisku
DocType: Account,Temporary,Začasna
DocType: Material Request Plan Item,Customer Provided,Stranka
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Customer LPO No.,Stranka LPO št.
DocType: Amazon MWS Settings,Market Place Account Group,Skupina računov na trgu
DocType: Program,Courses,Tečaji
DocType: Monthly Distribution Percentage,Percentage Allocation,Odstotek dodelitve
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Secretary,Sekretar
apps/erpnext/erpnext/regional/india/utils.py,House rented dates required for exemption calculation,"Datumi, najeti v najemu, potrebni za izraćun oprostitev"
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: Quality Review Table,Quality Review Table,Preglednica kakovosti
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,This action will stop future billing. Are you sure you want to cancel this subscription?,"To dejanje bo ustavilo prihodnje obračunavanje. Ali ste prepričani, da želite preklicati to naročnino?"
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/pos_profile/pos_profile.js,Please set Company,Nastavite Company
DocType: Procedure Prescription,Procedure Created,Ustvarjen postopek
DocType: Pricing Rule,Buying,Nabava
apps/erpnext/erpnext/config/agriculture.py,Diseases & Fertilizers,Bolezni in gnojila
DocType: HR Settings,Employee Records to be created by,"Zapisi zaposlenih, ki ga povzročajo"
DocType: Inpatient Record,AB Negative,AB negativno
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_with_account_number.py,Creditors,Upniki
DocType: Assessment Plan,Assessment Name,Ime ocena
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,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
DocType: Employee Onboarding,Job Offer,Zaposlitvena ponudba
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Abbreviation,Kratica inštituta
,Item-wise Price List Rate,Element-pametno Cenik Rate
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Supplier Quotation,Dobavitelj za predračun
apps/erpnext/erpnext/config/support.py,Issue Priority.,Prednostna izdaja.
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,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,Quantity ({0}) cannot be a fraction in row {1},Količina ({0}) ne more biti komponenta v vrstici {1}
DocType: Contract,Unsigned,Brez podpore
DocType: Selling Settings,Each Transaction,Vsaka transakcija
apps/erpnext/erpnext/stock/doctype/item/item.py,Barcode {0} already used in Item {1},Barcode {0} že uporabljajo v postavki {1}
DocType: Shift Type,The time before the shift end time when check-out is considered as early (in minutes).,"Čas pred zaključkom izmene, ko se odjava šteje kot zgodnji (v minutah)."
apps/erpnext/erpnext/config/selling.py,Rules for adding shipping costs.,Pravila za dodajanje stroškov dostave.
DocType: Hotel Room,Extra Bed Capacity,Zmogljivost dodatnega ležišča
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Varaiance ,Varaiance
apps/erpnext/erpnext/config/hr.py,Performance,Izvedba
DocType: Item,Opening Stock,Začetna zaloga
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Customer is required,Je potrebno kupca
DocType: Lab Test,Result Date,Datum oddaje
DocType: Purchase Order,To Receive,Prejeti
DocType: Leave Period,Holiday List for Optional Leave,Seznam počitnic za izbirni dopust
DocType: Item Tax Template,Tax Rates,Davčne stopnje
apps/erpnext/erpnext/utilities/user_progress.py,user@example.com,user@example.com
DocType: Asset,Asset Owner,Lastnik sredstev
DocType: Item,Website Content,Vsebina spletnega mesta
DocType: Bank Account,Integration ID,ID integracije
DocType: Purchase Invoice,Reason For Putting On Hold,Razlog za zaustavitev
DocType: Employee,Personal Email,Osebna Email
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,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/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() accepted invalid IBAN {},BankAccount.validate_iban () sprejel neveljaven IBAN {}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Brokerage,Posredništvo
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Attendance for employee {0} is already marked for this day,Udeležba na zaposlenega {0} je že označen za ta dan
DocType: Work Order Operation,"in Minutes
Updated via 'Time Log'",v minutah Posodobljeno preko &quot;Čas Logu&quot;
DocType: Customer,From Lead,Iz ponudbe
DocType: Amazon MWS Settings,Synch Orders,Naročila sinhronizacije
apps/erpnext/erpnext/config/manufacturing.py,Orders released for production.,Naročila sprosti za proizvodnjo.
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Fiscal Year...,Izberite poslovno leto ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,"POS Profil zahteva, da POS Entry"
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",Točke zvestobe bodo izračunane na podlagi porabljenega zneska (prek prodajnega računa) na podlagi navedenega faktorja zbiranja.
DocType: Program Enrollment Tool,Enroll Students,včlanite Študenti
DocType: Pricing Rule,Coupon Code Based,Na osnovi kode kupona
DocType: Company,HRA Settings,Nastavitve HRA
DocType: Homepage,Hero Section,Oddelek za junake
DocType: Employee Transfer,Transfer Date,Datum prenosa
DocType: Lab Test,Approved Date,Odobren datum
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Selling,Standardna Prodaja
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Atleast one warehouse is mandatory,Atleast eno skladišče je obvezna
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py,"Configure Item Fields like UOM, Item Group, Description and No of Hours.","Konfigurirajte polja polj, na primer UOM, skupino elementov, opis in število ur."
DocType: Certification Application,Certification Status,Certifikacijski status
apps/erpnext/erpnext/public/js/hub/marketplace.js,Marketplace,Tržnica
DocType: Travel Itinerary,Travel Advance Required,Zahtevano potovanje
DocType: Subscriber,Subscriber Name,Ime naročnika
DocType: Serial No,Out of Warranty,Iz garancije
DocType: Bank Statement Transaction Settings Item,Mapped Data Type,Tip mapiranih podatkov
DocType: BOM Update Tool,Replace,Zamenjaj
apps/erpnext/erpnext/templates/includes/product_list.js,No products found.,Ni izdelkov.
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,Publish More Items,Objavite več predmetov
apps/erpnext/erpnext/support/doctype/issue/issue.py,This Service Level Agreement is specific to Customer {0},Ta pogodba o ravni storitev je značilna za stranko {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Invoice {1},{0} za Račun {1}
DocType: Antibiotic,Laboratory User,Laboratorijski uporabnik
DocType: Request for Quotation Item,Project Name,Ime projekta
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Customer Address,"Prosimo, nastavite naslov stranke"
DocType: Customer,Mention if non-standard receivable account,Omemba če nestandardno terjatve račun
DocType: Bank,Plaid Access Token,Plaid Access Token
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Please add the remaining benefits {0} to any of the existing component,"Prosimo, dodajte preostale ugodnosti {0} v katero koli obstoječo komponento"
DocType: Journal Entry Account,If Income or Expense,Če prihodek ali odhodek
DocType: Course Topic,Course Topic,Tema predmeta
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/pos_closing_voucher.py,POS Closing Voucher alreday exists for {0} between date {1} and {2},Prodajni zapiralni bon za POS obstaja za {0} med datumom {1} in {2}
DocType: Bank Statement Transaction Entry,Matching Invoices,Ujemanje računov
DocType: Work Order,Required Items,Zahtevani Točke
DocType: Stock Ledger Entry,Stock Value Difference,Stock Value Razlika
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Item Row {0}: {1} {2} does not exist in above '{1}' table,Element Red {0}: {1} {2} v tabeli &quot;{1}&quot; ne obstaja
apps/erpnext/erpnext/config/help.py,Human Resource,Človeški vir
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Plačilo Sprava Plačilo
DocType: Disease,Treatment Task,Naloga zdravljenja
DocType: Payment Order Reference,Bank Account Details,Podatki o bančnem računu
DocType: Purchase Order Item,Blanket Order,Blanket naročilo
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.py,Repayment Amount must be greater than ,Znesek vračila mora biti večji od
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Tax Assets,Davčni Sredstva
DocType: BOM Item,BOM No,BOM Ne
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,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
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Benefit,Ugodnost
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_with_account_number.py,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,Leaves must be allocated in multiples of 0.5,Listi morajo biti dodeljen v večkratnikih 0.5
DocType: Work Order,Operation Cost,Delovanje Stroški
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Identifying Decision Makers,Prepoznavanje odločevalcev
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,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]
DocType: Payment Entry,Payment Ordered,Plačilo je naročeno
DocType: Asset Maintenance Team,Maintenance Team Name,Ime ekipe za vzdrževanje
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Če 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/controllers/trends.py,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/hr/doctype/employee/employee_dashboard.py,Lifecycle,Življenski krog
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Payment Document Type,Vrsta plačilnega dokumenta
apps/erpnext/erpnext/controllers/selling_controller.py,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,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: Designation Skill,Skill,Spretnost
DocType: Subscription,Taxes,Davki
DocType: Purchase Invoice Item,Weight Per Unit,Teža na enoto
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Paid and Not Delivered,Plačana in ni podal
DocType: QuickBooks Migrator,Default Cost Center,Privzet Stroškovni Center
apps/erpnext/erpnext/www/all-products/index.html,Toggle Filters,Preklopite filtre
apps/erpnext/erpnext/config/stock.py,Stock Transactions,Zaloga Transakcije
DocType: Budget,Budget Accounts,Proračun računi
DocType: Employee,Internal Work History,Notranji Delo Zgodovina
DocType: Bank Statement Transaction Entry,New Transactions,Nove transakcije
DocType: Depreciation Schedule,Accumulated Depreciation Amount,Bilančni Amortizacija Znesek
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Private Equity,Private Equity
DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Spremenljivka Scorecard spremenljivke
DocType: Shift Type,Working Hours Threshold for Half Day,Mejna vrednost delovnega časa za pol dneva
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please create purchase receipt or purchase invoice for the item {0},"Prosimo, ustvarite potrdilo o nakupu ali kupite račun za predmet {0}"
DocType: Job Card,Material Transferred,Preneseno gradivo
DocType: Employee Advance,Due Advance Amount,Znesek vnaprej vnaprej
DocType: Maintenance Visit,Customer Feedback,Customer Feedback
DocType: Account,Expense,Expense
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js,Score cannot be greater than Maximum Score,Rezultat ne sme biti večja od najvišjo oceno
DocType: Support Search Source,Source Type,Vrsta vira
DocType: Course Content,Course Content,Vsebina predmeta
apps/erpnext/erpnext/utilities/user_progress.py,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: Inpatient Occupancy,Invoiced,Fakturirani
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,WooCommerce Products,Izdelki WooCommerce
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in formula or condition: {0},Skladenjska napaka v formuli ali stanje: {0}
apps/erpnext/erpnext/stock/utils.py,Item {0} ignored since it is not a stock item,"Postavka {0} prezrta, ker ne gre za element parka"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","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
DocType: Employee Checkin,Shift Actual End,Dejanski konec premika
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Jobs,Jobs
,Sales Order Trends,Sales Order Trendi
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,The 'From Package No.' field must neither be empty nor it's value less than 1.,&quot;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/work_order/work_order_calendar.js,Production Item,Proizvodnja Postavka
,Employee Information,Informacije zaposleni
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Healthcare Practitioner not available on {0},Zdravstveni delavec ni na voljo na {0}
DocType: Stock Entry Detail,Additional Cost,Dodatne Stroški
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"Can not filter based on Voucher No, if grouped by Voucher","Filter ne more temeljiti na kupona št, če je združena s Voucher"
DocType: Quality Inspection,Incoming,Dohodni
apps/erpnext/erpnext/setup/doctype/company/company.js,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,Assessment Result record {0} already exists.,Ocenjevanje Rezultat zapisa {0} že obstaja.
DocType: Item,"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.","Primer: ABCD. #####. Če je serija nastavljena in številka paketa ni navedena v transakcijah, bo na podlagi te serije izdelana avtomatična serijska številka. Če za to postavko vedno želite izrecno omeniti Lot št., Pustite to prazno. Opomba: ta nastavitev bo imela prednost pred imeniku serije Prefix v nastavitvah zalog."
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Outward taxable supplies(zero rated),Dohodno obdavčljive dobave (ničelna ocena)
DocType: BOM,Materials Required (Exploded),Potreben materiali (eksplodirala)
apps/erpnext/erpnext/buying/report/purchase_analytics/purchase_analytics.js,based_on,temelji na
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Submit Review,Pošljite pregled
DocType: Contract,Party User,Stranski uporabnik
apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,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,Posting Date cannot be future date,Napotitev datum ne more biti prihodnji datum
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Vrstica # {0}: Serijska št {1} ne ujema z {2} {3}
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Nastavite serijsko številčenje za udeležbo prek Setup&gt; Seting Number
DocType: Stock Entry,Target Warehouse Address,Naslov tarče skladišča
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Casual Zapusti
DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"Čas pred začetkom izmene, v katerem se šteje prijava zaposlenih za udeležbo."
DocType: Agriculture Task,End Day,Konec dneva
DocType: Batch,Batch ID,Serija ID
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Note: {0},Opomba: {0}
DocType: Stock Settings,Action if Quality inspection is not submitted,"Ukrep, če se ne predloži pregled kakovosti"
,Delivery Note Trends,Dobavnica Trendi
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,This Week's Summary,Povzetek Ta teden je
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,In Stock Qty,Na zalogi Količina
,Daily Work Summary Replies,Povzetki dnevnega dela Povzetki
DocType: Delivery Trip,Calculate Estimated Arrival Times,Izračunajte predvideni čas prihoda
apps/erpnext/erpnext/accounts/general_ledger.py,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: Tally Migration,ERPNext Company,Podjetje ERPNext
DocType: Shopify Settings,Webhooks,Webhooks
DocType: Bank Account,Party,Zabava
DocType: Healthcare Settings,Patient Name,Ime bolnika
DocType: Variant Field,Variant Field,Različno polje
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Target Location,Ciljna lokacija
DocType: Sales Order,Delivery Date,Datum dostave
DocType: Opportunity,Opportunity Date,Priložnost Datum
DocType: Employee,Health Insurance Provider,Ponudnik zdravstvenega zavarovanja
DocType: Service Level,Holiday List (ignored during SLA calculation),Seznam počitnic (zanemarjen pri izračunu SLA)
DocType: Products Settings,Show Availability Status,Prikaži stanje razpoložljivosti
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."
DocType: Employee Grade,Employee Grade,Razred zaposlenih
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Akord
DocType: GSTR 3B Report,June,Junij
DocType: Share Balance,From No,Od št
DocType: Shift Type,Early Exit Grace Period,Predčasno izstopno milostno obdobje
DocType: Task,Actual Time (in Hours),Dejanski čas (v urah)
DocType: Employee,History In Company,Zgodovina v družbi
DocType: Customer,Customer Primary Address,Primarni naslov stranke
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Connected,Klic je povezan
apps/erpnext/erpnext/config/crm.py,Newsletters,Glasila
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Reference No.,Referenčna št.
DocType: Drug Prescription,Description/Strength,Opis / moč
apps/erpnext/erpnext/config/hr.py,Energy Point Leaderboard,Tabela energetskih točk
DocType: Bank Statement Transaction Entry,Create New Payment/Journal Entry,Ustvari novo plačilo / vnos v dnevnik
DocType: Certification Application,Certification Application,Certifikacijska aplikacija
DocType: Leave Type,Is Optional Leave,Neobvezno pusti
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Declare Lost,Razglasi izgubljenega
DocType: Share Balance,Is Company,Je podjetje
DocType: Pricing Rule,Same Item,Isti element
DocType: Stock Ledger Entry,Stock Ledger Entry,Stock Ledger Entry
DocType: Quality Action Resolution,Quality Action Resolution,Kakovostna ločljivost ukrepov
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Half day Leave on {1},{0} na poldnevni dan pustite {1}
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,Item {0} is not setup for Serial Nos. Column must be blank,Postavka {0} ni setup za Serijska št. Kolona mora biti prazno
apps/erpnext/erpnext/regional/india/utils.py,Either GST Transporter ID or Vehicle No is required if Mode of Transport is Road,"Če je način prevoza cestni, GST Transporter ID ali vozilo ne potrebujeta"
DocType: Accounts Settings,Accounts Settings,Računi Nastavitve
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Approve,odobri
DocType: Loyalty Program,Customer Territory,Teritorija kupca
DocType: Email Digest,Sales Orders to Deliver,"Prodajne naloge, ki jih želite oddati"
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"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
DocType: GSTR 3B Report,Invoices with no Place Of Supply,Računi brez kraja dobave
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,No Result to submit,Ni zadetka
DocType: Customer,Sales Partner and Commission,Prodaja Partner in Komisija
DocType: 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,"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;"
apps/erpnext/erpnext/hr/utils.py,To date can not be less than from date,Do danes ne sme biti manj kot od datuma
DocType: Opportunity,To Discuss,Razpravljati
apps/erpnext/erpnext/stock/stock_ledger.py,{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/config/quality_management.py,Quality Goal.,Cilj kakovosti.
DocType: Support Settings,Forum URL,Forum URL
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Accounts,Začasni računi
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Source Location is required for the asset {0},Izvorna lokacija je potrebna za sredstvo {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Black,Črna
DocType: BOM Explosion Item,BOM Explosion Item,BOM Eksplozija Postavka
DocType: Shareholder,Contact List,Seznam kontaktov
DocType: Account,Auditor,Revizor
DocType: Project,Frequency To Collect Progress,Frekvenca za zbiranje napredka
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items produced,{0} postavke proizvedene
apps/erpnext/erpnext/utilities/user_progress.py,Learn More,Nauči se več
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} is not added in the table,{0} ni dodan v tabeli
DocType: Payment Entry,Party Bank Account,Bančni račun stranke
DocType: Cheque Print Template,Distance from top edge,Oddaljenost od zgornjega roba
DocType: POS Closing Voucher Invoices,Quantity of Items,Količina izdelkov
apps/erpnext/erpnext/stock/get_item_details.py,Price List {0} is disabled or does not exist,Cenik {0} je onemogočena ali pa ne obstaja
DocType: Purchase Invoice,Return,Return
DocType: Account,Disable,Onemogoči
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Mode of payment is required to make a payment,"Način plačila je potrebno, da bi plačilo"
DocType: Task,Pending Review,Dokler Pregled
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,"Edit in full page for more options like assets, serial nos, batches etc.","Uredite na celotni strani za več možnosti, kot so sredstva, serijski nosi, serije itd."
DocType: Leave Type,Maximum Continuous Days Applicable,Najvišji neprekinjeni dnevi veljajo
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 4,Razpon staranja 4
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Batch {2},{0} - {1} ni vpisan v serijo {2}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,"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,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,Mark Absent,Mark Odsoten
DocType: Job Applicant Source,Job Applicant Source,Vir prijavitelja zaposlitve
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,IGST Amount,Znesek IGST
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup company,Podjetje za nastavitev ni uspelo
DocType: Asset Repair,Asset Repair,Popravilo sredstev
DocType: Warehouse,Warehouse Type,Vrsta skladišča
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Vrstica {0}: Valuta BOM # {1} mora biti enaka izbrani valuti {2}
DocType: 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,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,Fleet Management,Fleet management
apps/erpnext/erpnext/config/agriculture.py,Crops & Lands,Rastline in zemljišča
DocType: Shift Type,Enable Exit Grace Period,Omogoči obdobje izstopa milosti
DocType: Cheque Print Template,Regular,redno
DocType: Fertilizer,Density (if liquid),Gostota (če je tekoča)
apps/erpnext/erpnext/education/doctype/course/course.py,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: GSTR 3B Report,August,Avgusta
DocType: Account,Asset,Asset
DocType: Quality Goal,Revised On,Revidirano dne
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock cannot exist for Item {0} since has variants,"Stock ne more obstajati za postavko {0}, saj ima variant"
DocType: Healthcare Practitioner,Mobile,Mobile
DocType: Issue,Reset Service Level Agreement,Ponastavi sporazum o ravni storitev
,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,Warehouse {0} does not exist,Skladišče {0} ne obstaja
DocType: Cashier Closing,Custody,Skrbništvo
DocType: Employee Tax Exemption Proof Submission Detail,Employee Tax Exemption Proof Submission Detail,Dodatek o predložitvi dokazila o oprostitvi davka na zaposlene
DocType: Monthly Distribution,Monthly Distribution Percentages,Mesečni Distribucijski Odstotki
apps/erpnext/erpnext/stock/doctype/batch/batch.py,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
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.js,Print IRS 1099 Forms,Natisni obrazci IRS 1099
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,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,Explore Sales Cycle,Raziščite prodajne cikle
DocType: Assessment Plan,Supervisor,nadzornik
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Retention Stock Entry,Vstop v zaloge
,Available Stock for Packing Items,Zaloga za embalirane izdelke
DocType: Item Variant,Item Variant,Postavka Variant
DocType: Employee Skill Map,Trainings,Treningi
,Work Order Stock Report,Poročilo o delovni nalogi
DocType: Purchase Receipt,Auto Repeat Detail,Samodejno ponovite podrobnosti
DocType: Assessment Result Tool,Assessment Result Tool,Ocena Rezultat orodje
apps/erpnext/erpnext/education/doctype/instructor/instructor.js,As Supervisor,Kot nadzornik
DocType: Leave Policy Detail,Leave Policy Detail,Pustite podrobnosti o politiki
DocType: BOM Scrap Item,BOM Scrap Item,BOM Odpadno Item
apps/erpnext/erpnext/accounts/page/pos/pos.js,Submitted orders can not be deleted,Predložene naročila ni mogoče izbrisati
DocType: Leave Control Panel,Department (optional),Oddelek (neobvezno)
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Stanje na računu je že ""bremenitev"", ni dovoljeno nastaviti ""Stanje mora biti"" kot ""kredit"""
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"If you {0} {1} worth item <b>{2}</b>, the scheme <b>{3}</b> will be applied on the item.
				","Če je {0} {1} vreden izdelek <b>{2}</b> , bo na izdelku uporabljena shema <b>{3}</b> ."
DocType: Customer Feedback,Quality Management,Upravljanje kakovosti
apps/erpnext/erpnext/assets/doctype/asset/asset.py,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: Loan,Repay Fixed Amount per Period,Povrne fiksni znesek na obdobje
DocType: Employee,Health Insurance No,Zdravstveno zavarovanje št
DocType: Employee Tax Exemption Proof Submission,Tax Exemption Proofs,Dokazi o davčni oprostitvi
apps/erpnext/erpnext/buying/utils.py,Please enter quantity for Item {0},Vnesite količino za postavko {0}
DocType: Quality Procedure,Processes,Procesi
DocType: Shift Type,First Check-in and Last Check-out,Prva prijava in Zadnja odjava
apps/erpnext/erpnext/regional/report/hsn_wise_summary_of_outward_supplies/hsn_wise_summary_of_outward_supplies.py,Total Taxable Amount,Skupaj obdavčljiv znesek
DocType: Employee External Work History,Employee External Work History,Delavec Zunanji Delo Zgodovina
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Job card {0} created,Kartica za delo {0} je bila ustvarjena
DocType: Opening Invoice Creation Tool,Purchase,Nakup
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Balance Qty,Balance Kol
DocType: Pricing Rule,Conditions will be applied on all the selected items combined. ,Pogoji bodo uporabljeni za vse izbrane izdelke skupaj.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Goals cannot be empty,Cilji ne morejo biti prazna
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js,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,{0} for {1},{0} za {1}
DocType: Healthcare Settings,Valid number of days,Veljavno število dni
apps/erpnext/erpnext/setup/doctype/company/company.js,Cost Centers,Stroškovna mesta
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Restart Subscription,Ponovni zagon naročnine
DocType: Linked Plant Analysis,Linked Plant Analysis,Analiza povezanih naprav
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Transporter ID,ID transporterja
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Value Proposition,Vrednostni predlog
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"
DocType: Purchase Invoice Item,Service End Date,Datum konca storitve
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,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: Bank Guarantee,Receiving,Prejemanje
DocType: Training Event Employee,Invited,povabljen
apps/erpnext/erpnext/config/accounting.py,Setup Gateway accounts.,Gateway račune.
apps/erpnext/erpnext/config/integrations.py,Connect your bank accounts to ERPNext,Povežite svoje bančne račune z ERPNext
DocType: Employee,Employment Type,Vrsta zaposlovanje
apps/erpnext/erpnext/config/projects.py,Make project from a template.,Izdelajte projekt iz predloge.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,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
DocType: Shareholder,ACC-SH-.YYYY.-,ACC-SH-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,Combined invoice portion must equal 100%,Kombinirani del na računu mora biti enak 100%
DocType: Item Default,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,Student Email ID,Študent Email ID
DocType: Employee,Notice (days),Obvestilo (dni)
DocType: POS Closing Voucher Invoices,POS Closing Voucher Invoices,POS računi z zaprtimi računi
DocType: Tax Rule,Sales Tax Template,Sales Tax Predloga
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Download JSON,Prenesite JSON
DocType: Employee Benefit Application Detail,Pay Against Benefit Claim,Neupravičeno plačilo
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Update Cost Center Number,Posodobi številko centra stroškov
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select items to save the invoice,"Izberite predmete, da shranite račun"
DocType: Employee,Encashment Date,Vnovčevanje Datum
DocType: Training Event,Internet,internet
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Seller Information,Podatki prodajalca
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,Default Activity Cost exists for Activity Type - {0},Obstaja Stroški Privzeta aktivnost za vrsto dejavnosti - {0}
DocType: Work Order,Planned Operating Cost,Načrtovana operacijski stroškov
DocType: Academic Term,Term Start Date,Izraz Datum začetka
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Authentication Failed,Preverjanje ni uspelo
apps/erpnext/erpnext/config/accounting.py,List of all share transactions,Seznam vseh deležev transakcij
DocType: Supplier,Is Transporter,Je transporter
DocType: Shopify Settings,Import Sales Invoice from Shopify if Payment is marked,"Uvozite račun za prodajo iz Shopify, če je plačilo označeno"
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp Count,Opp Štetje
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp Count,Opp Štetje
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Both Trial Period Start Date and Trial Period End Date must be set,Določiti je treba začetni datum preizkusnega obdobja in datum konca poskusnega obdobja
apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py,Average Rate,Povprečna hitrost
apps/erpnext/erpnext/controllers/accounts_controller.py,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/stock/doctype/item/item.py,"""Customer Provided Item"" cannot have Valuation Rate","&quot;Izdelek, ki ga zagotavlja stranka&quot;, ne more imeti stopnje vrednotenja"
DocType: Subscription Plan Detail,Plan,Načrt
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,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 / Ime artikla
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,Serial No is mandatory for Item {0},Zaporedna številka je obvezna za postavko {0}
DocType: Website Attribute,Attribute,Lastnost
DocType: Staffing Plan Detail,Current Count,Trenutna števila
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Please specify from/to range,"Prosimo, navedite iz / v razponu"
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,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,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,Default settings for selling transactions.,Privzete nastavitve za prodajne transakcije.
DocType: Guardian,Guardian Of ,Guardian Of
DocType: Grading Scale Interval,Threshold,prag
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Filter Employees By (Optional),Filtriraj zaposlene po (neobvezno)
DocType: BOM Update Tool,Current BOM,Trenutni BOM
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Balance (Dr - Cr),Ravnotežje (Dr - Cr)
DocType: Pick List,Qty of Finished Goods Item,Količina izdelka končnega blaga
apps/erpnext/erpnext/public/js/utils.js,Add Serial No,Dodaj Serijska št
DocType: Work Order Item,Available Qty at Source Warehouse,Na voljo Količina na Vir Warehouse
apps/erpnext/erpnext/config/support.py,Warranty,garancija
DocType: Purchase Invoice,Debit Note Issued,Opomin Izdano
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Filter based on Cost Center is only applicable if Budget Against is selected as Cost Center,"Filtriranje na podlagi stroškovnega centra se uporablja le, če je Budget Against izbran kot Center stroškov"
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,"Search by item code, serial number, batch no or barcode","Iskanje po oznaki predmeta, serijski številki, številki serije ali črtno kodo"
DocType: Work Order,Warehouses,Skladišča
DocType: Shift Type,Last Sync of Checkin,Zadnja sinhronizacija Checkin
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Add a new address,Dodajte nov naslov
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,{0} asset cannot be transferred,{0} sredstev ni mogoče prenesti
DocType: Hotel Room Pricing,Hotel Room Pricing,Cene hotelske sobe
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py,"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Označevanje bolnišničnega zapisa ni mogoče označiti kot prazno, obstajajo neizbrisani računi {0}"
DocType: Subscription,Days Until Due,Dnevi do dneva
apps/erpnext/erpnext/stock/doctype/item/item.js,This Item is a Variant of {0} (Template).,Ta element je različica {0} (predloga).
DocType: Workstation,per hour,na uro
DocType: Blanket Order,Purchasing,Purchasing
DocType: Announcement,Announcement,Obvestilo
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,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,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,Distribution,Porazdelitev
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Employee status cannot be set to 'Left' as following employees are currently reporting to this employee:&nbsp;,"Statusa zaposlenega ni mogoče nastaviti na „Levo“, saj se temu zaposlenemu trenutno poročajo naslednji zaposleni:"
DocType: Journal Entry Account,Loan,Posojilo
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,Volunteer information.,Informacije o prostovoljcih.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Project Manager,Project Manager
,Quoted Item Comparison,Citirano Točka Primerjava
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Overlap in scoring between {0} and {1},Prekrivanje v dosegu med {0} in {1}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Dispatch,Dispatch
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,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,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,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Vrstica # {0}: ni dovoljeno spreminjati Dobavitelj kot Naročilo že obstaja
DocType: Stock Entry,Material Consumption for Manufacture,Poraba materiala za izdelavo
DocType: Item Alternative,Alternative Item Code,Alternativni koda izdelka
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."
DocType: Production Plan,Select Items to Manufacture,Izberite artikel v Izdelava
DocType: Delivery Stop,Delivery Stop,Dostava Stop
apps/erpnext/erpnext/accounts/page/pos/pos.js,"Master data syncing, it might take some time","Master podatkov sinhronizacijo, lahko traja nekaj časa"
DocType: Material Request Plan Item,Material Issue,Material Issue
DocType: Employee Education,Qualification,Kvalifikacije
DocType: Item Price,Item Price,Item Cena
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Soap & Detergent,Soap &amp; Detergent
DocType: BOM,Show Items,prikaži Točke
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.py,Duplicate Tax Declaration of {0} for period {1},Podvojena davčna izjava {0} za obdobje {1}
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py,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,Do you want to notify all the customers by email?,Ali želite obvestiti vse stranke po elektronski pošti?
DocType: Subscription Plan,Billing Interval,Interval zaračunavanja
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Motion Picture & Video,Motion Picture &amp; Video
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js,Ordered,Naročeno
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Resume,Nadaljuj
DocType: Salary Detail,Component,Komponenta
DocType: Video,YouTube,YouTube
apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py,Row {0}: {1} must be greater than 0,Vrstica {0}: {1} mora biti večja od 0
DocType: Assessment Criteria,Assessment Criteria Group,Skupina Merila ocenjevanja
DocType: Healthcare Settings,Patient Name By,Ime bolnika z
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Accrual Journal Entry for salaries from {0} to {1},Vpis v časopisni razgovor za plače od {0} do {1}
DocType: Sales Invoice Item,Enable Deferred Revenue,Omogočite odloženi prihodek
apps/erpnext/erpnext/assets/doctype/asset/asset.py,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 Ime
DocType: Naming Series,Select Transaction,Izberite Transaction
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Vnesite Odobritev vloge ali Potrditev uporabnika
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Pogodba o ravni storitve s tipom entitete {0} in entiteto {1} že obstaja.
DocType: Journal Entry,Write Off Entry,Napišite Off Entry
DocType: BOM,Rate Of Materials Based On,Oceni materialov na osnovi
DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Če je omogočeno, bo polje Academic Term Obvezno v orodju za vpisovanje programov."
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Values of exempt, nil rated and non-GST inward supplies","Vrednosti oproščenih, z ničelno vrednostjo in vhodnih dobav brez GST"
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Uncheck all,Odznači vse
DocType: Purchase Taxes and Charges,On Item Quantity,Na Količina izdelka
DocType: POS Profile,Terms and Conditions,Pravila in pogoji
DocType: Asset,Booked Fixed Asset,Rezervirano osnovno sredstvo
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,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"
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Creating Accounts...,Ustvarjanje računov ...
DocType: Leave Block List,Applies to Company,Velja za podjetja
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Cannot cancel because submitted Stock Entry {0} exists,"Ni mogoče preklicati, ker je predložila Stock Začetek {0} obstaja"
DocType: Loan,Disbursement Date,izplačilo Datum
DocType: Service Level Agreement,Agreement Details,Podrobnosti o sporazumu
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Start Date of Agreement can't be greater than or equal to End Date.,Začetni datum pogodbe ne sme biti večji ali enak končnemu datumu.
DocType: BOM Update Tool,Update latest price in all BOMs,Posodobi najnovejšo ceno v vseh BOM
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Done,Končano
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Medical Record,Medicinski zapis
DocType: Vehicle,Vehicle,vozila
DocType: Purchase Invoice,In Words,V besedi
apps/erpnext/erpnext/hr/doctype/leave_ledger_entry/leave_ledger_entry.py,To date needs to be before from date,Do danes mora biti pred datumom
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the name of the bank or lending institution before submittting.,Pred predložitvijo navedite ime banke ali posojilne institucije.
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py,{0} must be submitted,{0} je treba vložiti
DocType: POS Profile,Item Groups,postavka Skupine
DocType: Company,Standard Working Hours,Standardne delovne ure
DocType: Sales Order Item,For Production,Za proizvodnjo
DocType: Payment Request,payment_url,payment_url
DocType: Exchange Rate Revaluation Account,Balance In Account Currency,Stanje v valuti računa
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,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/crm/report/campaign_efficiency/campaign_efficiency.py,Opp/Lead %,OPP / svinec%
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp/Lead %,OPP / svinec%
DocType: Bank Guarantee,Bank Account Info,Informacije o bančnem računu
DocType: Bank Guarantee,Bank Guarantee Type,Vrsta bančne garancije
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() failed for valid IBAN {},BankAccount.validate_iban () ni uspel za veljavno IBAN {}
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,Amount {0} {1} transferred from {2} to {3},Znesek {0} {1} je preselil iz {2} na {3}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0} nima razporeda zdravniškega zdravnika. Dodajte ga v mojstrski zdravnik
DocType: Sales Invoice,Get Advances Received,Get prejeti predujmi
DocType: Email Digest,Add/Remove Recipients,Dodaj / Odstrani prejemnike
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js,"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;"
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Amount of TDS Deducted,Znesek TDS odbitega
DocType: Production Plan,Include Subcontracted Items,Vključite predmete s podizvajalci
apps/erpnext/erpnext/projects/doctype/project/project.py,Join,pridruži se
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Shortage Qty,Pomanjkanje Kol
DocType: Purchase Invoice,Input Service Distributor,Distributer vhodnih storitev
apps/erpnext/erpnext/stock/doctype/item/item.py,Item variant {0} exists with same attributes,Obstaja postavka varianta {0} z enakimi atributi
DocType: Loan,Repay from Salary,Poplačilo iz Plača
DocType: Exotel Settings,API Token,API žeton
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Requesting payment against {0} {1} for amount {2},Zahteva plačilo pred {0} {1} za znesek {2}
DocType: Additional Salary,Salary Slip,Plača listek
apps/erpnext/erpnext/support/doctype/issue/issue.py,Allow Resetting Service Level Agreement from Support Settings.,Dovoli ponastavitev sporazuma o ravni storitve iz nastavitev podpore.
DocType: Lead,Lost Quotation,Izgubljeno Kotacija
apps/erpnext/erpnext/utilities/user_progress.py,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,'To Date' is required,"""Do datuma"" je obvezno polje"
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Actual Qty: Quantity available in the warehouse.,"Dejanska količina: količina, ki je na voljo v skladišču."
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: Payroll Entry,Deduct Tax For Unclaimed Employee Benefits,Davek od odbitka za neupravičene zaslužke zaposlenih
DocType: Salary Slip,Total Interest Amount,Skupni znesek obresti
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,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: Travel Itinerary,Arrival Datetime,Prihod Datetime
DocType: Tax Rule,Billing Zipcode,Poštna številka
DocType: Attendance,HR-ATT-.YYYY.-,HR-ATT-.YYYY.-
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
DocType: Service Day,Workday,Delovni dan
apps/erpnext/erpnext/setup/doctype/terms_and_conditions/terms_and_conditions.py,At least one of the Applicable Modules should be selected,Izbrati je treba vsaj enega izmed uporabnih modulov
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate item group found in the item group table,Dvojnik postavka skupina je našla v tabeli točka skupine
apps/erpnext/erpnext/config/quality_management.py,Tree of Quality Procedures.,Drevo kakovostnih postopkov.
apps/erpnext/erpnext/public/js/controllers/transaction.js,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,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: Sales Invoice,Is Discounted,Se zniža
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on Actual,"Ukrep, če je bil akumulirani mesečni proračun presežen na dejanski"
DocType: Salary Component,Create Separate Payment Entry Against Benefit Claim,Ustvarite ločen plačilni vpis pred škodnim zahtevkom
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,Delete permanently?,Izbriši trajno?
DocType: Expense Claim,Total Claimed Amount,Skupaj zahtevani znesek
apps/erpnext/erpnext/config/crm.py,Potential opportunities for selling.,Potencialne možnosti za prodajo.
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,{} is an invalid Attendance Status.,{} je neveljaven status udeležbe.
DocType: Shareholder,Folio no.,Folio št.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,Invalid {0},Neveljavna {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Sick Leave,Bolniški dopust
DocType: Email Digest,Email Digest,Email Digest
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,"As raw materials projected quantity is more than required quantity, there is no need to create material request.
			Still if you want to make material request, kindly enable <b>Ignore Existing Projected Quantity</b> checkbox","Ker je predvidena količina surovin večja od zahtevane količine, ni treba ustvarjati materialne zahteve. Če želite vložiti materialno zahtevo, prosimo, da potrdite potrditveno polje <b>Ignore Existing Projected Quantity</b>"
DocType: Delivery Note,Billing Address Name,Zaračunavanje Naslov Name
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Department Stores,Veleblagovnice
,Item Delivery Date,Datum dobave artikla
DocType: Selling Settings,Sales Update Frequency,Pogostost prodajnega posodabljanja
DocType: Production Plan,Material Requested,Zahtevani material
DocType: Warehouse,PIN,PIN
DocType: Bin,Reserved Qty for sub contract,Rezervirano Kol za podizvajalsko pogodbo
DocType: Patient Service Unit,Patinet Service Unit,Patinet servisna enota
DocType: Sales Invoice,Base Change Amount (Company Currency),Osnovna Sprememba Znesek (družba Valuta)
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,No accounting entries for the following warehouses,Ni vknjižbe za naslednjih skladiščih
apps/erpnext/erpnext/shopping_cart/cart.py,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: Contract,Fulfilment Details,Podrobnosti o izpolnjevanju
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py,Pay {0} {1},Plačajte {0} {1}
DocType: Employee Onboarding,Activities,Dejavnosti
DocType: Expense Claim Detail,Expense Date,Expense Datum
DocType: Item,No of Months,Število mesecev
DocType: Item,Max Discount (%),Max Popust (%)
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,Credit Days cannot be a negative number,Kreditni dnevi ne smejo biti negativni
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Upload a statement,Naložite izjavo
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Report this item,Prijavite to postavko
DocType: Purchase Invoice Item,Service Stop Date,Datum zaustavitve storitve
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,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," {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: Certification Application,Yet to appear,Še vedno pa se pojavi
DocType: Delivery Stop,Email Sent To,E-pošta poslana
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Salary Structure not found for employee {0} and date {1},Strukture plače za zaposlenega {0} in datum {1} ni mogoče najti
DocType: Job Card Item,Job Card Item,Postavka Job Card
DocType: Accounts Settings,Allow Cost Center In Entry of Balance Sheet Account,Dovoli stroškovnem centru pri vnosu bilance stanja
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge with Existing Account,Spoji z obstoječim računom
DocType: Budget,Warn,Opozori
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Vsi elementi so bili že preneseni za ta delovni nalog.
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: Bank Account,Company Account,Račun podjetja
DocType: Asset Maintenance,Manufacturing User,Proizvodnja Uporabnik
DocType: Purchase Invoice,Raw Materials Supplied,"Surovin, dobavljenih"
DocType: Subscription Plan,Payment Plan,Plačilni načrt
DocType: Bank Transaction,Series,Zaporedje
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Currency of the price list {0} must be {1} or {2},Valuta cenika {0} mora biti {1} ali {2}
apps/erpnext/erpnext/config/accounting.py,Subscription Management,Upravljanje naročnin
DocType: Appraisal,Appraisal Template,Cenitev Predloga
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Pin Code,Za kodo
DocType: Soil Texture,Ternary Plot,Ternary plot
DocType: Amazon MWS Settings,Check this to enable a scheduled Daily synchronization routine via scheduler,"Preverite to, da omogočite načrtovano dnevno sinhronizacijo prek načrtovalca"
DocType: Item Group,Item Classification,Postavka Razvrstitev
apps/erpnext/erpnext/templates/pages/home.html,Publications,Publikacije
DocType: Driver,License Number,Številka licence
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Business Development Manager,Business Development Manager
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Vzdrževanje Obiščite Namen
DocType: Stock Entry,Stock Entry Type,Vrsta vpisa
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Invoice Patient Registration,Registracija računa pacientov
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js,General Ledger,Glavna knjiga
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,To Fiscal Year,V proračunsko leto
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js,View Leads,Poglej ponudbe
DocType: Program Enrollment Tool,New Program,Nov program
DocType: Item Attribute Value,Attribute Value,Vrednosti atributa
DocType: POS Closing Voucher Details,Expected Amount,Pričakovani znesek
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Multiple,Ustvari večkrat
,Itemwise Recommended Reorder Level,Itemwise Priporočena Preureditev Raven
apps/erpnext/erpnext/hr/utils.py,Employee {0} of grade {1} have no default leave policy,Zaposleni {0} razreda {1} nimajo pravilnika o privzetem dopustu
DocType: Salary Detail,Salary Detail,plača Podrobnosti
DocType: Email Digest,New Purchase Invoice,Nov račun za nakup
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select {0} first,"Prosimo, izberite {0} najprej"
apps/erpnext/erpnext/public/js/hub/marketplace.js,Added {0} users,Dodal {0} uporabnike
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Less Than Amount,Manj kot znesek
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent",V primeru večstopenjskega programa bodo stranke samodejno dodeljene zadevni stopnji glede na porabljene
DocType: Appointment Type,Physician,Zdravnik
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,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,Consultations,Posvetovanja
apps/erpnext/erpnext/manufacturing/report/bom_variance_report/bom_variance_report.py,Finished Good,Končano dobro
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,"Item Price appears multiple times based on Price List, Supplier/Customer, Currency, Item, UOM, Qty and Dates.","Postavka Cena se prikaže večkrat na podlagi cenika, dobavitelja / naročnika, valute, postavke, UOM, količine in datumov."
DocType: Sales Invoice,Commission,Komisija
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) ne more biti večja od načrtovane količine ({2}) v delovnem redu {3}
DocType: Certification Application,Name of Applicant,Ime prosilca
apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Čas List za proizvodnjo.
DocType: Quick Stock Balance,Quick Stock Balance,Hitro stanje zalog
apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Vmesni seštevek
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Lastnosti variant ni mogoče spremeniti po transakciji z delnicami. Za to morate narediti novo postavko.
apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless Mandat SEPA
DocType: Healthcare Practitioner,Charges,Dajatve
DocType: Production Plan,Get Items For Work Order,Pridobite predmete za delovni red
DocType: Salary Detail,Default Amount,Privzeti znesek
DocType: Lab Test Template,Descriptive,Opisno
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Warehouse not found in the system,Skladišče ni mogoče najti v sistemu
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,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,`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/stock/report/stock_balance/stock_balance.py,Earliest Age,Najstarejša starost
apps/erpnext/erpnext/utilities/user_progress.py,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."
DocType: Quality Goal,Revision,Revizija
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Healthcare Services,Zdravstvene storitve
,Project wise Stock Tracking,Projekt pametno Stock Tracking
DocType: GST HSN Code,Regional,regionalno
apps/erpnext/erpnext/config/healthcare.py,Laboratory,Laboratorij
DocType: UOM Category,UOM Category,Kategorija UOM
DocType: Clinical Procedure Item,Actual Qty (at source/target),Dejanska Količina (pri viru / cilju)
DocType: Item Customer Detail,Ref Code,Ref Code
DocType: Accounts Settings,Address used to determine Tax Category in transactions.,"Naslov, ki se uporablja za določanje davčne kategorije pri transakcijah."
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Customer Group is Required in POS Profile,Skupina strank je potrebna v profilu POS
DocType: HR Settings,Payroll Settings,Nastavitve plače
apps/erpnext/erpnext/config/accounting.py,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,Place Order,Naročiti
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.js,Create Invoice,Ustvari račun
DocType: Email Digest,New Purchase Orders,Nova naročila
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Root cannot have a parent cost center,Root ne more imeti matična stroškovno mesto v
DocType: POS Closing Voucher,Expense Details,Podrobnosti o izdatkih
apps/erpnext/erpnext/public/js/stock_analytics.js,Select Brand...,Izberi znamko ...
apps/erpnext/erpnext/public/js/setup_wizard.js,Non Profit (beta),Neprofitna (beta)
apps/erpnext/erpnext/portal/doctype/products_settings/products_settings.py,"Filter Fields Row #{0}: Fieldname <b>{1}</b> must be of type ""Link"" or ""Table MultiSelect""",Vrstica filtrov polja št. {0}: Ime polja <b>{1}</b> mora biti tipa &quot;Link&quot; ali &quot;Table MultiSelect&quot;
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Accumulated Depreciation as on,"Nabrano amortizacijo, na"
DocType: Employee Tax Exemption Category,Employee Tax Exemption Category,Kategorija oprostitve plačila davka za zaposlene
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Amount should not be less than zero.,Znesek ne sme biti manjši od nič.
DocType: Sales Invoice,C-Form Applicable,"C-obliki, ki velja"
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Operation Time must be greater than 0 for Operation {0},"Delovanje Čas mora biti večja od 0, za obratovanje {0}"
DocType: Support Search Source,Post Route String,String nizov poti
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Warehouse is mandatory,Skladišče je obvezna
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,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/education/doctype/program/program_dashboard.py,Admission and Enrollment,Vpis in vpis
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,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/accounts/report/general_ledger/general_ledger.py,Group by Voucher (Consolidated),Skupina po vavčerju (prečiščeno)
DocType: HR Settings,Encrypt Salary Slips in Emails,Šifrirajte plačne spodrsljaje v e-pošti
DocType: Question,Multiple Correct Answer,Več pravilnih odgovorov
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,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
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Discharge,Razrešnica razporeda
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Cheques and Deposits incorrectly cleared,Čeki in depoziti nepravilno izbil
DocType: Homepage Section Card,Homepage Section Card,Kartica oddelka za domačo stran
,Amount To Be Billed,"Znesek, ki ga je treba plačati"
apps/erpnext/erpnext/accounts/doctype/account/account.py,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,Create customer quotes,Ustvari ponudbe kupcev
apps/erpnext/erpnext/public/js/controllers/transaction.js,Service Stop Date cannot be after Service End Date,Datum zaustavitve storitve ne more biti po končnem datumu storitve
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,Bill of Materials (BOM),Kosovnica (BOM)
DocType: Item,Average time taken by the supplier to deliver,"Povprečen čas, ki ga dobavitelj dostaviti"
DocType: Travel Itinerary,Check-in Date,Datum prihoda
DocType: Sample Collection,Collected By,Zbrane z
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js,Assessment Result,ocena Rezultat
DocType: Hotel Room Package,Hotel Room Package,Paket za hotelske sobe
DocType: Employee Transfer,Employee Transfer,Prenos zaposlenih
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,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/selling/doctype/sales_order/sales_order.js,Work Order already created for all items with BOM,Delovni nalog je že ustvarjen za vse elemente z BOM
DocType: Bank Account,Party Details,Podrobnosti o zabavi
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant Details Report,Poročilo o variantah
DocType: Setup Progress Action,Setup Progress Action,Akcijski program Setup Progress
DocType: Course Activity,Video,Video
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Price List,Nakupni cenik
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Remove item if charges is not applicable to that item,"Odstranite element, če stroški ne nanaša na to postavko"
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Cancel Subscription,Prekliči naročnino
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Please select Maintenance Status as Completed or remove Completion Date,Izberite stanje vzdrževanja kot 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,Transaction currency must be same as Payment Gateway currency,Transakcijski valuta mora biti enaka kot vplačilo valuto
DocType: Payment Entry,Receive,Prejeti
DocType: Employee Benefit Application Detail,Earning Component,Zmagovalna komponenta
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Items and UOMs,Obdelava elementov in UOM-ov
apps/erpnext/erpnext/regional/italy/utils.py,Please set either the Tax ID or Fiscal Code on Company '%s',"Prosimo, nastavite bodisi davčno številko bodisi davčno kodo podjetja &#39;% s&#39;"
apps/erpnext/erpnext/templates/pages/rfq.html,Quotations: ,Ponudbe:
DocType: Contract,Partially Fulfilled,Delno izpolnjeno
DocType: Maintenance Visit,Fully Completed,V celoti končana
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,"Special Characters except ""-"", ""#"", ""."", ""/"", ""{"" and ""}"" not allowed in naming series","Posebni znaki, razen &quot;-&quot;, &quot;#&quot;, &quot;.&quot;, &quot;/&quot;, &quot;{&quot; In &quot;}&quot; v poimenovanju ni dovoljen"
DocType: Purchase Invoice Item,Is nil rated or exempted,Ni nič ali je oproščeno
DocType: Employee,Educational Qualification,Izobraževalni Kvalifikacije
DocType: Workstation,Operating Costs,Obratovalni stroški
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Currency for {0} must be {1},Valuta za {0} mora biti {1}
DocType: Shift Type,Mark attendance based on 'Employee Checkin' for Employees assigned to this shift.,"Označite udeležbo na podlagi „Checkee Employee Checkin“ za zaposlene, dodeljene tej izmeni."
DocType: Asset,Disposal Date,odstranjevanje Datum
DocType: Service Level,Response and Resoution Time,Čas odziva in odziva
DocType: Employee Leave Approver,Employee Leave Approver,Zaposleni Leave odobritelj
apps/erpnext/erpnext/stock/doctype/item/item.py,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/hr/doctype/staffing_plan/staffing_plan.js,Please enter the designation,Vnesite oznako
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py,"Cannot declare as lost, because Quotation has been made.","Ne more razglasiti kot izgubljena, ker je bil predračun postavil."
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Items for Raw Material Request,Artikli za zahtevo surovin
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,CWIP Account,Račun CWIP
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Feedback,Predlogi za usposabljanje
apps/erpnext/erpnext/config/accounting.py,Tax Withholding rates to be applied on transactions.,"Stopnje obdavčitve davkov, ki se uporabljajo pri transakcijah."
DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Merila ocenjevalnih meril za dobavitelje
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select Start Date and End Date for Item {0},"Prosimo, izberite Start in končni datum za postavko {0}"
DocType: Maintenance Schedule,MAT-MSH-.YYYY.-,MAT-MSH-YYYY.-
,Amount to Receive,Znesek za prejem
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Course is mandatory in row {0},Seveda je obvezna v vrsti {0}
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,From date can not be greater than than To date,Od datuma ne sme biti večje od Do danes
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,To date cannot be before from date,Do danes ne more biti pred od datuma
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non GST Inward Supplies,Vhodne potrebščine brez GST
DocType: Employee Group Table,Employee Group Table,Tabela skupin zaposlenih
DocType: Packed Item,Prevdoc DocType,Prevdoc DOCTYPE
DocType: Cash Flow Mapper,Section Footer,Noga odseka
apps/erpnext/erpnext/stock/doctype/item/item.js,Add / Edit Prices,Dodaj / Uredi Cene
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Employee Promotion cannot be submitted before Promotion Date ,Promocija zaposlenih ni mogoče vložiti pred datumom uveljavitve
DocType: Batch,Parent Batch,nadrejena Serija
DocType: Batch,Parent Batch,nadrejena Serija
DocType: Cheque Print Template,Cheque Print Template,Ček Print Predloga
DocType: Salary Component,Is Flexible Benefit,Je fleksibilna korist
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Chart of Cost Centers,Grafikon stroškovnih mest
DocType: Subscription Settings,Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,Število dni po datumu računa je preteklo pred preklicem naročnine ali označitve naročnine kot neplačano
DocType: Clinical Procedure Template,Sample Collection,Zbiranje vzorcev
,Requested Items To Be Ordered,Zahtevane Postavke naloži
DocType: Price List,Price List Name,Cenik Ime
DocType: Delivery Stop,Dispatch Information,Informacije o odpremi
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill JSON can only be generated from submitted document,e-Way Bill JSON je mogoče ustvariti samo iz predloženega dokumenta
DocType: Blanket Order,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,Something went wrong!,Nekaj je šlo narobe!
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Warning: Leave application contains following block dates,Opozorilo: Pustite prijava vsebuje naslednje datume blok
DocType: Bank Statement Settings,Transaction Data Mapping,Kartiranje podatkov o transakcijah
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Sales Invoice {0} has already been submitted,Račun {0} je že bil predložen
DocType: Salary Component,Is Tax Applicable,Ali je davčni zavezanec
DocType: Supplier Scorecard Scoring Criteria,Score,ocena
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,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: Program,Is Featured,Je predstavljeno
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Fetching...,Pridobivanje ...
DocType: Agriculture Analysis Criteria,Agriculture User,Kmetijski uporabnik
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Valid till date cannot be before transaction date,Veljaven do datuma ne more biti pred datumom transakcije
apps/erpnext/erpnext/stock/stock_ledger.py,{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/healthcare/doctype/clinical_procedure/clinical_procedure.js,Stock quantity to start procedure is not available in the warehouse. Do you want to record a Stock Transfer,Količina zalog za začetek postopka ni na voljo v skladišču. Želite posneti prenos stanj
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,New {0} pricing rules are created,Izdelana so nova {0} pravila za določanje cen
DocType: Shipping Rule,Shipping Rule Type,Vrsta pravilnika o dostavi
apps/erpnext/erpnext/utilities/user_progress.py,Go to Rooms,Pojdi v sobe
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,"Company, Payment Account, From Date and To Date is mandatory","Družba, plačilni račun, datum in datum je obvezen"
DocType: Company,Budget Detail,Proračun Detail
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Please enter message before sending,Vnesite sporočilo pred pošiljanjem
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Setting up company,Ustanovitev podjetja
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Of the supplies shown in 3.1 (a) above, details of inter-State supplies made to unregisterd
	persons, composition taxable persons and UIN holders","Med dobavami, prikazanimi v točki 3.1 (a), so podatki o meddržavnih dobavah za neregistrirane osebe, davčne zavezance za sestavo in imetnike UIN"
DocType: Education Settings,Enable LMS,Omogoči LMS
DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DVOJNIK dobavitelja
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Please save the report again to rebuild or update,"Ponovno shranite poročilo, da obnovite ali posodobite"
DocType: Service Level Agreement,Response and Resolution Time,Čas odziva in reševanja
DocType: Asset,Custodian,Skrbnik
apps/erpnext/erpnext/config/retail.py,Point-of-Sale Profile,Point-of-Sale profila
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py,{0} should be a value between 0 and 100,{0} mora biti vrednost med 0 in 100
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Payment of {0} from {1} to {2},Plačilo {0} od {1} do {2}
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward supplies liable to reverse charge (other than 1 & 2 above),"Notranji zalogi, ki so podvrženi povratnemu polnjenju (razen 1 in 2 zgoraj)"
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount(Company Currency),Znesek naročila (valuta podjetja)
DocType: Chart of Accounts Importer,Import Chart of Accounts from a csv file,Uvoz računov iz datoteke csv
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,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: Shift Type,Strictly based on Log Type in Employee Checkin,Strogo temelji na vrsti dnevnika v Checkin zaposlenem
DocType: Maintenance Schedule Detail,Scheduled Date,Načrtovano Datum
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
,GST Itemised Sales Register,DDV Razčlenjeni prodaje Registracija
DocType: Staffing Plan,Staffing Plan Details,Podrobnosti o kadrovskem načrtu
DocType: Soil Texture,Silt Loam,Silt Loam
,Serial No Service Contract Expiry,Zaporedna številka Service Contract preteka
DocType: Employee Health Insurance,Employee Health Insurance,Zdravstveno zavarovanje zaposlenih
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,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.,Srčni utrip 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,Total weightage assigned should be 100%. It is {0},Skupaj weightage dodeljena mora biti 100%. To je {0}
DocType: Loyalty Point Entry,Loyalty Program Tier,Stopnja programa zvestobe
apps/erpnext/erpnext/utilities/user_progress.py,Your Suppliers,Vaši Dobavitelji
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,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/buying/doctype/purchase_order/purchase_order.js,Reason for hold: ,Razlog za zadržanje:
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,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/public/js/hub/components/reviews.js,Anonymous,Anonimno
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Received From,Prejela od
DocType: Lead,Converted,Pretvorjena
DocType: Item,Has Serial No,Ima serijsko številko
DocType: Stock Entry Detail,PO Supplied Item,PO dobavljeni artikel
DocType: Employee,Date of Issue,Datum izdaje
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}","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,Row #{0}: Set Supplier for item {1},Vrstica # {0}: Nastavite Dobavitelj za postavko {1}
DocType: Global Defaults,Default Distance Unit,Privzeta enota za razdaljo
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,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,Website Image {0} attached to Item {1} cannot be found,Spletna stran slike {0} pritrjena na postavki {1} ni mogoče najti
DocType: Asset,Assets,Sredstva
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Computer,Računalnik
DocType: Item,List this Item in multiple groups on the website.,Seznam ta postavka v več skupinah na spletni strani.
DocType: Subscription,Current Invoice End Date,Trenutni datum zaključka računa
DocType: Payment Term,Due Date Based On,Datum na podlagi datuma
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,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,{0} {1} does not exist,{0} {1} ne obstaja
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,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,Item: {0} does not exist in the system,Postavka: {0} ne obstaja v sistemu
apps/erpnext/erpnext/accounts/doctype/account/account.py,You are not authorized to set Frozen value,Nimate dovoljenja za nastavitev Zamrznjena vrednost
DocType: Payment Reconciliation,Get Unreconciled Entries,Pridobite neusklajene vnose
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} is on Leave on {1},Zaposleni {0} je na Pusti {1}
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments selected for Journal Entry,Nobena odplačila niso izbrana za vnos v dnevnik
DocType: Purchase Invoice,GST Category,GST Kategorija
DocType: Payment Reconciliation,From Invoice Date,Od Datum računa
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Budgets,Proračuni
DocType: Invoice Discounting,Disbursed,Izplačano
DocType: Healthcare Settings,Laboratory Settings,Laboratorijske nastavitve
DocType: Clinical Procedure,Service Unit,Servisna enota
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Successfully Set Supplier,Uspešno nastavite dobavitelja
DocType: Leave Encashment,Leave Encashment,pustite Vnovčevanje
apps/erpnext/erpnext/public/js/setup_wizard.js,What does it do?,Kaj to naredi?
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py,Tasks have been created for managing the {0} disease (on row {1}),Opravljene so bile naloge za upravljanje {0} bolezni (na vrstici {1})
DocType: Crop,Byproducts,Stranski produkti
apps/erpnext/erpnext/stock/doctype/batch/batch.js,To Warehouse,Za skladišča
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,All Student Admissions,Vse Študentski Sprejemi
,Average Commission Rate,Povprečen Komisija Rate
DocType: Share Balance,No of Shares,Število delnic
DocType: Taxable Salary Slab,To Amount,Za znesek
apps/erpnext/erpnext/stock/doctype/item/item.py,'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,Select Status,Izberite Stanje
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance can not be marked for future dates,Udeležba ni mogoče označiti za prihodnje datume
DocType: Support Search Source,Post Description Key,Ključ za opis sporočila
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: Opportunity,Sales Stage,Prodajna faza
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Customer PO,Stranka PO
DocType: Purchase Taxes and Charges,Account Head,Račun Head
DocType: Company,HRA Component,HRA komponenta
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Electrical,Električno
apps/erpnext/erpnext/utilities/activation.py,Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,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: Employee Checkin,Location / Device ID,Lokacija / ID naprave
DocType: Grant Application,Requested Amount,Zahtevani znesek
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Exchange Rate is mandatory,Vrstica {0}: Menjalni tečaj je obvezen
DocType: Invoice Discounting,Bank Charges Account,Račun za bančne stroške
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,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
DocType: Bank,Data Import Configuration,Konfiguracija uvoza podatkov
DocType: Asset Maintenance Task,Last Completion Date,Zadnji datum zaključka
apps/erpnext/erpnext/accounts/report/inactive_sales_items/inactive_sales_items.js,Days Since Last Order,Dni od zadnjega naročila
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To account must be a Balance Sheet account,Bremenitev računa mora biti bilanca računa
DocType: Asset,Naming Series,Poimenovanje zaporedja
DocType: Vital Signs,Coated,Prevlečen
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Vrstica {0}: Pričakovana vrednost po uporabnem življenjskem obdobju mora biti manjša od bruto zneska nakupa
apps/erpnext/erpnext/regional/italy/utils.py,Please set {0} for address {1},"Prosimo, nastavite {0} za naslov {1}"
DocType: GoCardless Settings,GoCardless Settings,GoCardless nastavitve
apps/erpnext/erpnext/controllers/stock_controller.py,Create Quality Inspection for Item {0},Ustvari pregled kakovosti za predmet {0}
DocType: Leave Block List,Leave Block List Name,Pustite Ime Block List
DocType: Certified Consultant,Certification Validity,Veljavnost certifikata
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Insurance Start date should be less than Insurance End date,Datum zavarovanje Začetek sme biti manjša od datuma zavarovanje End
DocType: Support Settings,Service Level Agreements,Dogovori o ravni storitev
DocType: Shopping Cart Settings,Display Settings,Nastavitve zaslona
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Assets,Zaloga Sredstva
DocType: Restaurant,Active Menu,Aktivni meni
DocType: Accounting Dimension Detail,Default Dimension,Privzeta razsežnost
DocType: Target Detail,Target Qty,Ciljna Kol
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Against Loan: {0},Proti posojilu: {0}
DocType: Shopping Cart Settings,Checkout Settings,Naročilo Nastavitve
DocType: Student Attendance,Present,Present
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Delivery Note {0} must not be submitted,Dobavnica {0} ni treba predložiti
DocType: HR Settings,"The salary slip emailed to the employee will be password protected, the password will be generated based on the password policy.","Potrdilo o plači, poslano zaposlenemu, bo zaščiteno z geslom, geslo bo ustvarjeno na podlagi pravilnika o geslu."
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,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,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,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,BOM does not contain any stock item,BOM ne vsebuje nobenega elementa zaloge
DocType: Chapter,Chapter Head,Poglavje glave
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Search for a payment,Poiščite plačilo
DocType: Payment Term,Month(s) after the end of the invoice month,Mesec (i) po koncu meseca računa
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Salary Structure should have flexible benefit component(s) to dispense benefit amount,"Struktura plače mora imeti prožne komponente (komponente), da bi odplačala znesek nadomestila"
apps/erpnext/erpnext/config/projects.py,Project activity / task.,Projektna dejavnost / naloga.
DocType: Vital Signs,Very Coated,Zelo prevlečen
DocType: Salary Component,Only Tax Impact (Cannot Claim But Part of Taxable Income),"Samo davčni vpliv (ne moremo trditi, ampak del obdavčljivega dohodka)"
DocType: Vehicle Log,Refuelling Details,Oskrba z gorivom Podrobnosti
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab result datetime cannot be before testing datetime,Datetime rezultatov laboratorija ne more biti pred testiranjem datetime
DocType: Delivery Trip,Use Google Maps Direction API to optimize route,Uporabite API za usmerjanje Google Maps za optimizacijo poti
DocType: POS Profile,Allow user to edit Discount,Dovoli uporabniku urejanje popusta
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Get customers from,Pridobite stranke od
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per rules 42 & 43 of CGST Rules,Po pravilih 42 in 43 pravil CGST
DocType: Purchase Invoice Item,Include Exploded Items,Vključi eksplodirane elemente
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,"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,Discount must be less than 100,"Popust, mora biti manj kot 100"
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,"Start Time can't be greater than or equal to End Time \
					for {0}.",Začetni čas ne sme biti večji ali enak končnemu času \ za {0}.
DocType: Shipping Rule,Restrict to Countries,Omeji na države
DocType: Shift Type,Alternating entries as IN and OUT during the same shift,Med istim premikom se izmenični vnosi kot IN in OUT
DocType: Shopify Settings,Shared secret,Skupna skrivnost
DocType: Amazon MWS Settings,Synch Taxes and Charges,Synch Taxes and Charges
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/work_order/work_order.py,Default BOM for {0} not found,Privzeti BOM za {0} ni bilo mogoče najti
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year Start Date should be one year earlier than Fiscal Year End Date,Datum začetka proračunskega leta mora biti eno leto prej kot končni datum proračunskega leta
apps/erpnext/erpnext/stock/doctype/item/item.py,Row #{0}: Please set reorder quantity,Vrstica # {0}: Prosim nastavite naročniško količino
apps/erpnext/erpnext/public/js/pos/pos.html,Tap items to add them here,"Dotaknite predmete, da jih dodate tukaj"
DocType: Course Enrollment,Program Enrollment,Program Vpis
apps/erpnext/erpnext/controllers/item_variant.py,Rename Not Allowed,Preimenovanje ni dovoljeno
DocType: Share Transfer,To Folio No,V Folio št
DocType: Landed Cost Voucher,Landed Cost Voucher,Pristali Stroški bon
apps/erpnext/erpnext/config/accounting.py,Tax Category for overriding tax rates.,Davčna kategorija za previsoke davčne stopnje.
apps/erpnext/erpnext/public/js/queries.js,Please set {0},"Prosim, nastavite {0}"
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} neaktiven študent
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} neaktiven študent
DocType: Employee,Health Details,Podrobnosti zdravja
DocType: Coupon Code,Coupon Type,Vrsta kupona
DocType: Leave Encashment,Encashable days,Priloženi dnevi
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,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,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
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Allocate Payment Amount,Dodeli znesek plačila
DocType: Subscription Plan,Subscription Plan,Naročni načrt
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,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} je povezan z {2}, vendar je Račun stranke {3}"
DocType: Bank Statement Settings Item,Bank Header,Glava banke
apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js,View Lab Tests,Oglejte si laboratorijske preiskave
DocType: Hub Users,Hub Users,Uporabniki vozlišča
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,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,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,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: Shift Type,Auto Attendance Settings,Nastavitve samodejne udeležbe
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,BOM and Manufacturing Quantity are required,BOM and Manufacturing Količina so obvezna
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 2,Staranje Razpon 2
DocType: SG Creation Tool Course,Max Strength,Max moč
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Installing presets,Namestitev prednastavitev
DocType: Fee Schedule,EDU-FSH-.YYYY.-,EDU-FSH-.YYYY.-
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,No Delivery Note selected for Customer {},Za kupca ni izbranega obvestila o dostavi {}
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Rows Added in {0},Vrstice dodane v {0}
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Employee {0} has no maximum benefit amount,Zaposleni {0} nima največjega zneska nadomestila
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,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,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
DocType: Quality Feedback Template Parameter,Quality Feedback Template Parameter,Parameter predloge kakovosti povratne informacije
apps/erpnext/erpnext/config/settings.py,Setting up Email,Postavitev Email
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Mobile No,Guardian1 Mobile No
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,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,Daily Reminders,Dnevni opomniki
apps/erpnext/erpnext/templates/pages/help.html,See all open tickets,Oglejte si vse odprte vozovnice
DocType: Brand,Brand Defaults,Privzete vrednosti blagovne znamke
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js,Healthcare Service Unit Tree,Drevo enote zdravstvenega varstva
DocType: Pricing Rule,Product,Izdelek
DocType: Products Settings,Home Page is Products,Domača stran je izdelki
,Asset Depreciation Ledger,Sredstvo Amortizacija Ledger
DocType: Salary Structure,Leave Encashment Amount Per Day,Pustite znesek obrokov na dan
DocType: Loyalty Program Collection,For how much spent = 1 Loyalty Point,Za koliko je bila porabljena = 1 Točka zvestobe
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Rule Conflicts with {0},Davčna Pravilo Konflikti z {0}
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,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,Customer Service,Storitev za stranke
DocType: BOM,Thumbnail,Thumbnail
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,No contacts with email IDs found.,Ni najdenih stikov z e-poštnimi ID-ji.
DocType: Item Customer Detail,Item Customer Detail,Postavka Detail Stranka
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum benefit amount of employee {0} exceeds {1},Najvišji znesek zaslužka zaposlenega {0} presega {1}
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total allocated leaves are more than days in the period,Skupaj dodeljena listi so več kot dni v obdobju
DocType: Linked Soil Analysis,Linked Soil Analysis,Povezana analiza tal
DocType: Pricing Rule,Percentage,odstotek
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,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/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Seznami za {0} se prekrivajo, ali želite nadaljevati, ko preskočite prekrivne reže?"
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js,Grant Leaves,Grantovi listi
DocType: Restaurant,Default Tax Template,Privzeta davčna predloga
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,{0} Students have been enrolled,{0} Študenti so bili vpisani
DocType: Fees,Student Details,Podrobnosti študenta
DocType: Woocommerce Settings,"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".","To je privzeti UOM, ki se uporablja za predmete in prodajna naročila. Rezervni UOM je &quot;št.&quot;"
DocType: Purchase Invoice Item,Stock Qty,Stock Kol
DocType: Purchase Invoice Item,Stock Qty,Stock Kol
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Ctrl+Enter to submit,Ctrl + Enter za pošiljanje
DocType: Contract,Requires Fulfilment,Zahteva izpolnjevanje
DocType: QuickBooks Migrator,Default Shipping Account,Privzeti ladijski račun
DocType: Loan,Repayment Period in Months,Vračilo Čas v mesecih
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,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,{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: Job Offer,Printing Details,Tiskanje Podrobnosti
DocType: Task,Closing Date,Zapiranje Datum
DocType: Sales Order Item,Produced Quantity,Proizvedena količina
DocType: Item Price,Quantity  that must be bought or sold per UOM,"Količina, ki jo je treba kupiti ali prodati na UOM"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Engineer,Inženir
DocType: Promotional Scheme Price Discount,Max Amount,Max znesek
DocType: Journal Entry,Total Amount Currency,Skupni znesek Valuta
DocType: Pricing Rule,Min Amt,Min Amt
DocType: Item,Is Customer Provided Item,Ali je izdelek s strani stranke
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Search Sub Assemblies,Iskanje sklope
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,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,Go to Items,Pojdi na elemente
DocType: Sales Partner,Partner Type,Partner Type
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Actual,Actual
DocType: Restaurant Menu,Restaurant Manager,Upravitelj restavracij
DocType: Call Log,Call Log,Seznam klicev
DocType: Authorization Rule,Customerwise Discount,Customerwise Popust
apps/erpnext/erpnext/config/projects.py,Timesheet for tasks.,Timesheet za naloge.
DocType: Purchase Invoice,Against Expense Account,Proti Expense račun
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Installation Note {0} has already been submitted,Je že bil predložen Namestitev Opomba {0}
DocType: BOM,Raw Material Cost (Company Currency),Stroški surovin (valuta podjetja)
apps/erpnext/erpnext/regional/india/utils.py,House rent paid days overlapping with {0},Dnevi plačila najemnine se prekrivajo z {0}
DocType: GSTR 3B Report,October,Oktober
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/accounts/doctype/sales_invoice/sales_invoice.js,Detailed Reason,Podroben razlog
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,View Now,Oglejte si zdaj
DocType: BOM,Raw Material Cost,Stroški surovin
DocType: Woocommerce Settings,Woocommerce Server URL,URL strežnika Woocommerce
DocType: Item Reorder,Re-Order Level,Ponovno naročila ravni
DocType: Additional Salary,Deduct Full Tax on Selected Payroll Date,Odšteti polni davek na izbrani datum plače
DocType: Shopify Tax Account,Shopify Tax/Shipping Title,Kupujte naslov davka / odpremo
apps/erpnext/erpnext/projects/doctype/project/project.js,Gantt Chart,Gantogram
DocType: Crop Cycle,Cycle Type,Vrsta cikla
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Part-time,Krajši delovni čas
DocType: Employee,Applicable Holiday List,Velja Holiday Seznam
DocType: Employee,Cheque,Ček
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Synchronize this account,Sinhronizirajte ta račun
DocType: Training Event,Employee Emails,Emails za zaposlene
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Series Updated,Zaporedje posodobljeno
apps/erpnext/erpnext/accounts/doctype/account/account.py,Report Type is mandatory,Vrsta poročila je obvezna
DocType: Item,Serial Number Series,Serijska številka zaporedja
,Sales Partner Transaction Summary,Povzetek transakcij prodajnega partnerja
apps/erpnext/erpnext/buying/utils.py,Warehouse is mandatory for stock Item {0} in row {1},Skladišče je obvezna za postavko {0} v vrstici {1}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,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
DocType: Employee Tax Exemption Declaration,Other Incomes,Drugi dohodki
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},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
DocType: Accounting Period,Accounting Period,Obračunsko obdobje
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date updated,Potrditev Datum posodobljeni
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split Batch,Split Serija
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split Batch,Split Serija
DocType: Stock Settings,Batch Identification,Identifikacija serije
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Successfully Reconciled,Uspešno usklajeno
DocType: Request for Quotation Supplier,Download PDF,Prenos PDF
DocType: Work 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"
DocType: Exchange Rate Revaluation Account,Current Exchange Rate,Trenutni menjalni tečaj
DocType: Item,"Sales, Purchase, Accounting Defaults","Prodaja, nabava, privzete računovodske izkaze"
DocType: Accounting Dimension Detail,Accounting Dimension Detail,Podrobnosti o dimenzijah računovodstva
apps/erpnext/erpnext/config/non_profit.py,Donor Type information.,Podatki o donatorju.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Leave on {1},{0} ob odhodu {1}
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available for use date is required,Potreben je datum uporabe
DocType: Request for Quotation,Supplier Detail,Dobavitelj Podrobnosti
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Error in formula or condition: {0},Napaka v formuli ali stanja: {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Invoiced Amount,Obračunani znesek
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Criteria weights must add up to 100%,Uteži meril morajo biti do 100%
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js,Attendance,Udeležba
apps/erpnext/erpnext/public/js/pos/pos.html,Stock Items,zalogi
DocType: Sales Invoice,Update Billed Amount in Sales Order,Posodobi obračunani znesek v prodajnem nalogu
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Contact Seller,Kontaktiraj prodajalca
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/stock/doctype/stock_entry/stock_entry.py,Posting date and posting time is mandatory,"Napotitev datum in čas objavljate, je obvezna"
apps/erpnext/erpnext/config/buying.py,Tax template for buying transactions.,Davčna predloga za nabavne transakcije
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Please login as a Marketplace User to report this item.,"Prijavite se kot uporabnik tržnice, če želite prijaviti ta element."
,Sales Partner Commission Summary,Povzetek komisije za prodajne partnerje
,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: Holiday List,Add to Holidays,Dodaj v praznike
DocType: Woocommerce Settings,Endpoint,Končna točka
DocType: Period Closing Voucher,Period Closing Voucher,Obdobje Closing bon
DocType: Patient Encounter,Review Details,Pregled podrobnosti
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shareholder does not belong to this company,Delničar ne pripada tej družbi
DocType: Dosage Form,Dosage Form,Odmerni obrazec
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,Please set up the Campaign Schedule in the Campaign {0},"Prosimo, nastavite razpored akcije v kampanji {0}"
apps/erpnext/erpnext/config/buying.py,Price List master.,Cenik gospodar.
DocType: Task,Review Date,Pregled Datum
DocType: BOM,Allow Alternative Item,Dovoli alternativni element
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Purchase Receipt doesn't have any Item for which Retain Sample is enabled.,"Potrdilo o nakupu nima nobenega predmeta, za katerega bi bil omogočen Retain Sample."
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Invoice Grand Total,Račun za skupni znesek
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
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Time logs are required for job card {0},Za službeno izkaznico so potrebni časovni dnevniki {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Healthcare Service,Izberite storitev zdravstvenega varstva
DocType: Purchase Taxes and Charges,On Net Total,On Net Total
apps/erpnext/erpnext/controllers/item_variant.py,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Vrednost atributa {0} mora biti v razponu od {1} do {2} v korakih po {3} za postavko {4}
DocType: Pricing Rule,Product Discount Scheme,Shema popustov na izdelke
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,No issue has been raised by the caller.,Pozivatelj ni postavil nobenega vprašanja.
DocType: Restaurant Reservation,Waitlisted,Waitlisted
DocType: Employee Tax Exemption Declaration Category,Exemption Category,Kategorija izvzetja
apps/erpnext/erpnext/accounts/doctype/account/account.py,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: Tally Migration,Round Off Account,Zaokrožijo račun
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Administrative Expenses,Administrativni stroški
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consulting,Consulting
DocType: Subscription Plan,Based on price list,Na podlagi cenika
DocType: Customer Group,Parent Customer Group,Parent Customer Group
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill JSON can only be generated from Sales Invoice,e-Way Bill JSON lahko ustvarite samo iz prodajnega računa
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Maximum attempts for this quiz reached!,Največje število poskusov tega kviza!
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Subscription,Naročnina
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Pending,Čakanje v kreiranju
DocType: Project Template Task,Duration (Days),Trajanje (dnevi)
DocType: Appraisal Goal,Score Earned,Rezultat Zaslužili
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Notice Period,Odpovedni rok
DocType: Asset Category,Asset Category Name,Sredstvo Kategorija Ime
apps/erpnext/erpnext/setup/doctype/territory/territory.js,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,New Sales Person Name,Ime New Sales oseba
DocType: Packing Slip,Gross Weight UOM,Bruto Teža UOM
DocType: Employee Transfer,Create New Employee Id,Ustvari ID novega zaposlenega
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Set Details,Nastavite podrobnosti
apps/erpnext/erpnext/templates/pages/home.html,By {0},Do {0}
DocType: Travel Itinerary,Travel From,Potovanje iz
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,Please enter serial numbers for serialized item ,Vnesite serijske številke za serialized postavko
DocType: Bin,Reserved Qty for Production,Rezervirano Količina za proizvodnjo
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,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,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: Service Level Agreement,Entity,Entiteta
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
DocType: QuickBooks Migrator,Default Warehouse,Privzeto Skladišče
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Budget cannot be assigned against Group Account {0},Proračun ne more biti dodeljena pred Group račun {0}
DocType: Shopping Cart Settings,Show Price,Prikaži ceno
DocType: Healthcare Settings,Patient Registration,Registracija pacientov
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,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,Depreciation Date,Amortizacija Datum
,Work Orders in Progress,Delovni nalogi v teku
DocType: Customer Credit Limit,Bypass Credit Limit Check,Obhodno preverjanje kreditnega limita
DocType: Issue,Support Team,Support Team
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expiry (In Days),Iztek (v dnevih)
DocType: Appraisal,Total Score (Out of 5),Skupna ocena (od 5)
DocType: Student Attendance Tool,Batch,Serija
DocType: Support Search Source,Query Route String,String String poizvedbe
DocType: Tally Migration,Day Book Data,Podatki o dnevnih knjigah
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update rate as per last purchase,Hitrost posodobitve po zadnjem nakupu
DocType: Donor,Donor Type,Vrsta donatorja
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Auto repeat document updated,Posodobljen samodejno ponavljanje dokumenta
apps/erpnext/erpnext/stock/doctype/item/item.js,Balance,Bilanca
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please select the Company,Izberite podjetje
DocType: Employee Checkin,Skip Auto Attendance,Preskočite samodejno udeležbo
DocType: BOM,Job Card,Job Card
DocType: Room,Seating Capacity,Število sedežev
DocType: Issue,ISS-,ISS-
DocType: Item,Is Non GST,Ali ni GST
DocType: Lab Test Groups,Lab Test Groups,Laboratorijske skupine
apps/erpnext/erpnext/config/accounting.py,Profitability,Donosnost
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,Party Type and Party is mandatory for {0} account,Vrsta stranke in stranka je obvezna za račun {0}
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,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: Crop Cycle,ISO 8601 standard,ISO 8601 standard
DocType: Journal Entry,Debit Note,Opomin
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,You can only redeem max {0} points in this order.,V tem vrstnem redu lahko uveljavljate največ {0} točk.
DocType: Expense Claim,HR-EXP-.YYYY.-,HR-EXP-YYYY-
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Secret,Vnesite Potrošniško skrivnost API-ja
DocType: Stock Entry,As per Stock UOM,Kot je na borzi UOM
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js,Not Expired,Ni potekel
DocType: Student Log,Achievement,dosežek
DocType: Asset,Insurer,Zavarovatelj
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,Following course schedules were created,Ustanovljeni so bili naslednji razporedi tečaja
DocType: Employee Onboarding,Employee Onboarding,Zaposleni na vozilu
DocType: Journal Entry,Total Debit,Skupaj Debetna
DocType: Travel Request Costing,Sponsored Amount,Sponzorirani znesek
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Privzete Končano Blago Skladišče
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Please select Patient,Izberite Patient
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Sales Person,Prodaja oseba
DocType: Hotel Room Package,Amenities,Amenities
DocType: Accounts Settings,Automatically Fetch Payment Terms,Samodejno prejmite plačilne pogoje
DocType: QuickBooks Migrator,Undeposited Funds Account,Račun nedefiniranih skladov
DocType: Coupon Code,Uses,Uporaba
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Večkratni način plačila ni dovoljen
DocType: Sales Invoice,Loyalty Points Redemption,Odkupi točk zvestobe
,Appointment Analytics,Imenovanje Analytics
DocType: Lead,Blog Subscriber,Blog Subscriber
DocType: Guardian,Alternate Number,namestnik Število
DocType: Assessment Plan Criteria,Maximum Score,Najvišja ocena
apps/erpnext/erpnext/config/settings.py,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, Group Roll No,Številka skupine
DocType: Quality Goal,Revision and Revised On,Revizija in revidirana dne
DocType: Batch,Manufacturing Date,Datum izdelave
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Failed,Ustvarjanje provizij ni uspelo
DocType: Opening Invoice Creation Tool,Create Missing Party,Ustvari manjkajočo stranko
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Skupni proračun
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"
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Domene ni bilo mogoče dodati
apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Če želite dovoliti prejem / dostavo, posodobite &quot;Over Prejem / Dovoljenje za dostavo&quot; v nastavitvah zaloge ali pošiljko."
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Aplikacije, ki uporabljajo trenutni ključ, ne bodo imele dostopa, ali ste prepričani?"
DocType: Subscription Settings,Prorate,Prorate
DocType: Purchase Invoice,Total Advance,Skupaj predplačila
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Template Code,Spremeni kodo šablone
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,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,Quot Count,quot Štetje
DocType: Bank Statement Transaction Entry,Bank Statement,Bančni izpisek
DocType: Employee Benefit Claim,Max Amount Eligible,Najvišji znesek je primeren
,BOM Stock Report,BOM Stock Poročilo
DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Če ni določenega časovnega razporeda, bo komunikacija upravljala ta skupina"
DocType: Stock Reconciliation Item,Quantity Difference,količina Razlika
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dobavitelj&gt; Vrsta dobavitelja
DocType: Opportunity Item,Basic Rate,Osnovni tečaj
DocType: GL Entry,Credit Amount,Credit Znesek
,Electronic Invoice Register,Register elektronskih računov
DocType: Cheque Print Template,Signatory Position,podpisnik Položaj
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Set as Lost,Nastavi kot Lost
DocType: Timesheet,Total Billable Hours,Skupaj plačljivih ur
DocType: Subscription,Number of days that the subscriber has to pay invoices generated by this subscription,"Število dni, v katerem mora naročnik plačati račune, ki jih ustvari ta naročnina"
DocType: Employee Benefit Application Detail,Employee Benefit Application Detail,Podrobnosti o uporabi programa za zaposlene
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Payment Receipt Note,Prejem plačilnih Note
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,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/stock/doctype/stock_entry/stock_entry.js,Create Material Request,Ustvari materialno zahtevo
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"Start and end dates not in a valid Payroll Period, cannot calculate {0}","Začetni in končni datumi, ki niso v veljavnem obdobju plače, ne morejo izračunati {0}"
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},"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,Tečajno poročilo o oceni
DocType: Customer Feedback Template,Customer Feedback Template,Predloga za povratne informacije strank
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 enako stopnja skozi celoten cikel prodaje
apps/erpnext/erpnext/hub_node/api.py,Please login as another user to register on Marketplace,"Prijavite se kot drugi uporabnik, da se registrirate na Marketplace"
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Načrtujte čas dnevnike zunaj Workstation delovnih ur.
apps/erpnext/erpnext/public/js/pos/pos.html,Customers in Queue,Stranke v vrsti
DocType: Driver,Issuing Date,Datum izdaje
DocType: Procedure Prescription,Appointment Booked,Imenovanje rezervirano
DocType: Student,Nationality,državljanstvo
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure,Konfigurirajte
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Submit this Work Order for further processing.,Pošljite ta delovni nalog za nadaljnjo obdelavo.
,Items To Be Requested,"Predmeti, ki bodo zahtevana"
DocType: Company,Allow Account Creation Against Child Company,Dovoli ustvarjanje računa proti otroški družbi
DocType: Company,Company Info,Informacije o podjetju
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select or add new customer,Izberite ali dodati novo stranko
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,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_with_account_number.py,Application of Funds (Assets),Uporaba sredstev (sredstva)
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,This is based on the attendance of this Employee,Ta temelji na prisotnosti tega zaposlenega
DocType: Payment Request,Payment Request Type,Vrsta zahtevka za plačilo
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Mark Attendance,Označi udeležbo
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Debit Account,Debetni račun
DocType: Fiscal Year,Year Start Date,Leto Start Date
DocType: Additional Salary,Employee Name,ime zaposlenega
DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Vnos naročila restavracije
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,{0} bank transaction(s) created and {1} errors,{0} nastale bančne transakcije in {1} napake
DocType: Purchase Invoice,Rounded Total (Company Currency),Zaokrožena Skupaj (Company Valuta)
apps/erpnext/erpnext/accounts/doctype/account/account.py,Cannot covert to Group because Account Type is selected.,"Ne more prikrite skupini, saj je izbrana vrsta računa."
DocType: Quiz,Max Attempts,Največji poskusi
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{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.
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.","Če je za točke zvestobe neomejen rok trajanja, sledite praznim časom trajanja ali 0."
DocType: Asset Maintenance Team,Maintenance Team Members,Člani vzdrževalne ekipe
DocType: Loyalty Point Entry,Purchase Amount,Znesek nakupa
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot deliver Serial No {0} of item {1} as it is reserved \
											to fullfill Sales Order {2}","Ne more dostaviti zaporednega št. {0} elementa {1}, ker je rezerviran \ za polnjenje prodajnega naročila {2}"
DocType: Quotation,SAL-QTN-.YYYY.-,SAL-QTN-YYYY-
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Supplier Quotation {0} created,Dobavitelj za predračun {0} ustvaril
apps/erpnext/erpnext/accounts/report/financial_statements.py,End Year cannot be before Start Year,Konec leta ne more biti pred začetkom leta
DocType: Employee Benefit Application,Employee Benefits,Zaslužki zaposlencev
apps/erpnext/erpnext/projects/report/billing_summary.py,Employee ID,ID zaposlenega
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Packed quantity must equal quantity for Item {0} in row {1},Pakirana količina mora biti enaka količini za postavko {0} v vrstici {1}
DocType: Work Order,Manufactured Qty,Izdelano Kol.
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shares don't exist with the {0},Delnice ne obstajajo z {0}
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Select Difference Account,Izberite račun za razlike
DocType: Sales Partner Type,Sales Partner Type,Vrsta prodajnega partnerja
DocType: Shopify Webhook Detail,Webhook ID,ID spletnega koda
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,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,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,{0}: {1} does not exists,{0}: {1} ne obstaja
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch Numbers,Izberite številke Serija
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To GSTIN,Za GSTIN
apps/erpnext/erpnext/config/accounting.py,Bills raised to Customers.,Računi zbrana strankam.
DocType: Healthcare Settings,Invoice Appointments Automatically,Samodejni izstavki računov
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Id,ID Projekta
DocType: Salary Component,Variable Based On Taxable Salary,Spremenljivka na podlagi obdavčljive plače
DocType: Company,Basic Component,Osnovna komponenta
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Vrstica št {0}: količina ne more biti večja od Dokler Znesek proti Expense zahtevka {1}. Dokler Znesek je {2}
DocType: Patient Service Unit,Medical Administrator,Zdravstveni administrator
DocType: Assessment Plan,Schedule,Urnik
DocType: Account,Parent Account,Matični račun
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,Salary Structure Assignment for Employee already exists,Struktura plače za zaposlene že obstaja
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Available,Na voljo
DocType: Quality Inspection Reading,Reading 3,Branje 3
DocType: Stock Entry,Source Warehouse Address,Naslov skladišča vira
DocType: GL Entry,Voucher Type,Bon Type
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Future Payments,Prihodnja plačila
DocType: Amazon MWS Settings,Max Retry Limit,Najvišja poskusna omejitev
apps/erpnext/erpnext/accounts/page/pos/pos.js,Price List not found or disabled,Cenik ni mogoče najti ali onemogočena
DocType: Content Activity,Last Activity ,Zadnja aktivnost
DocType: Student Applicant,Approved,Odobreno
DocType: Pricing Rule,Price,Cena
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Employee relieved on {0} must be set as 'Left',Zaposleni razrešen na {0} mora biti nastavljen kot &quot;levo&quot;
DocType: Guardian,Guardian,Guardian
apps/erpnext/erpnext/support/doctype/issue/issue.js,All communications including and above this shall be moved into the new Issue,"Vsa sporočila, vključno z in nad tem, se premaknejo v novo številko"
DocType: Salary Detail,Tax on additional salary,Davek na dodatno plačo
DocType: Item Alternative,Item Alternative,Postavka Alternative
DocType: Healthcare Settings,Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,"Računovodski izkazi za neplačane zneske, ki se uporabljajo, če zdravnik ni določil za knjiženje pristojbin za imenovanja."
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Total contribution percentage should be equal to 100,Skupni odstotek prispevka mora biti enak 100
DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Ustvari manjkajočo stranko ali dobavitelja.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,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
DocType: Payroll Entry,Salary Slips Created,Ustvarjene plačne liste
DocType: Inpatient Record,Expected Discharge,Pričakovano odvajanje
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,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,Monthly Sales Target (,Mesečna prodajna tarča (
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html,modified,spremenjene
DocType: Travel Request,Identification Document Number,Številka identifikacijskega dokumenta
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"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"
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,BOM 1,BOM 1
apps/erpnext/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py,Asset Id,ID premoženja
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js,This is a root healthcare service unit and cannot be edited.,To je korenska storitev zdravstvene oskrbe in je ni mogoče urejati.
DocType: Asset Repair,Repair Status,Stanje popravila
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Requested Qty: Quantity requested for purchase, but not ordered.","Zahtevana količina: Zahtevana količina za nakup, vendar ni naročena."
,Subcontracted Item To Be Received,"Izdelek, ki ga oddate v podizvajanje"
apps/erpnext/erpnext/public/js/event.js,Add Sales Partners,Dodaj prodajne partnerje
apps/erpnext/erpnext/config/accounting.py,Accounting journal entries.,Vpisi računovodstvo lista.
DocType: Travel Request,Travel Request,Zahteva za potovanje
DocType: Payment Reconciliation,System will fetch all the entries if limit value is zero.,"Sistem bo dobil vse vnose, če je mejna vrednost enaka nič."
DocType: Delivery Note Item,Available Qty at From Warehouse,Na voljo Količina na IZ SKLADIŠČA
apps/erpnext/erpnext/hr/doctype/department_approver/department_approver.py,Please select Employee Record first.,"Prosimo, izberite Employee Snemaj prvi."
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as it is a Holiday.,"Udeležba ni bila oddana za {0}, ker je praznik."
DocType: POS Profile,Account for Change Amount,Račun za znesek spremembe
DocType: QuickBooks Migrator,Connecting to QuickBooks,Povezava na QuickBooks
DocType: Exchange Rate Revaluation,Total Gain/Loss,Skupni dobiček / izguba
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Pick List,Ustvari seznam izbirnikov
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Vrstica {0}: Party / račun se ne ujema z {1} / {2} v {3} {4}
DocType: Employee Promotion,Employee Promotion,Promocija zaposlenih
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,Course Code: ,Šifra predmeta:
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please enter Expense Account,Vnesite Expense račun
DocType: Quality Action Resolution,Problem,Problem
DocType: Account,Stock,Zaloga
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","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: Production Plan Item,Make Work Order for Sub Assembly Items,Naredite delovni nalog za predmete pod montažo
DocType: Serial No,Purchase / Manufacture Details,Nakup / Izdelava Podrobnosti
DocType: Assessment Group,Assessment Group,Skupina ocena
DocType: Stock Entry,Per Transferred,Na preneseno
apps/erpnext/erpnext/config/help.py,Batch Inventory,Serija Inventory
DocType: Sales Invoice,GST Transporter ID,Identifikator prehoda GST
DocType: Procedure Prescription,Procedure Name,Ime postopka
DocType: Employee,Contract End Date,Naročilo End Date
DocType: Amazon MWS Settings,Seller ID,ID prodajalca
DocType: Sales Order,Track this Sales Order against any Project,Sledi tej Sales Order proti kateri koli projekt
DocType: Bank Statement Transaction Entry,Bank Statement Transaction Entry,Vnos transakcijskega poročila banke
DocType: Sales Invoice Item,Discount and Margin,Popust in Margin
DocType: Lab Test,Prescription,Predpis
DocType: Company,Default Deferred Revenue Account,Privzeti odloženi prihodki
DocType: Project,Second Email,Druga e-pošta
DocType: Budget,Action if Annual Budget Exceeded on Actual,"Ukrep, če je letni proračun presegel dejansko"
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Not Available,Ni na voljo
DocType: Pricing Rule,Min Qty,Min Kol
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Disable Template,Onemogoči predlogo
DocType: Bank Statement Transaction Invoice Item,Transaction Date,Transakcijski Datum
DocType: Production Plan Item,Planned Qty,Načrtovano Kol
DocType: Project Template Task,Begin On (Days),Začetek dneva (dnevi)
DocType: Quality Action,Preventive,Preventivno
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to Unregistered Persons,Potrebščine za neregistrirane osebe
DocType: Company,Date of Incorporation,Datum ustanovitve
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Total Tax,Skupna davčna
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Last Purchase Price,Zadnja nakupna cena
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,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)
DocType: Sales Invoice,Air,Zrak
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Leto Končni datum ne more biti zgodnejši od datuma Leto Start. Popravite datum in poskusite znova.
DocType: Purchase Order,Set Target Warehouse,Nastavite ciljno skladišče
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} is not in Optional Holiday List,{0} ni na seznamu neobveznih praznikov
DocType: Amazon MWS Settings,JP,JP
DocType: BOM,Scrap Items,ostanki Točke
DocType: Work 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/hr/doctype/salary_structure/salary_structure.py,"Skipping Salary Structure Assignment for the following employees, as Salary Structure Assignment records already exists against them. {0}","Preskok dodelitve strukture plače za naslednje zaposlene, saj za njih že obstajajo zapisi o dodelitvi strukture plače. {0}"
apps/erpnext/erpnext/config/manufacturing.py,Generate Material Requests (MRP) and Work Orders.,Ustvari materialne zahteve (MRP) in delovne naloge.
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Set default mode of payment,Nastavite privzeti način plačila
DocType: Stock Entry Detail,Against Stock Entry,Proti vpisu zalog
DocType: Grant Application,Withdrawn,umaknjena
DocType: Support Search Source,Support Search Source,Podpora v iskalnem omrežju
apps/erpnext/erpnext/accounts/report/account_balance/account_balance.js,Chargeble,Polnilna
DocType: Project,Gross Margin %,Gross Margin%
DocType: BOM,With Operations,Pri poslovanju
DocType: Support Search Source,Post Route Key List,Seznam seznama ključnih besed
apps/erpnext/erpnext/accounts/party.py,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,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 Component,Statistical Component,Statistični Komponenta
DocType: Salary Component,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
DocType: Purchase Taxes and Charges,On Previous Row Amount,Na prejšnje vrstice Znesek
DocType: Options,Is Correct,Je pravilen
DocType: Item,Has Expiry Date,Ima rok veljavnosti
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Transfer Asset,prenos sredstev
apps/erpnext/erpnext/config/support.py,Issue Type.,Vrsta izdaje
DocType: POS Profile,POS Profile,POS profila
DocType: Training Event,Event Name,Ime dogodka
DocType: Healthcare Practitioner,Phone (Office),Telefon (Office)
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,"Cannot Submit, Employees left to mark attendance","Ni mogoče poslati, zaposleni so pustili, da označijo udeležbo"
DocType: Inpatient Record,Admission,sprejem
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Admissions for {0},Vstopnine za {0}
DocType: Shift Type,Last Known Successful Sync of Employee Checkin. Reset this only if you are sure that all Logs are synced from all the locations. Please don't modify this if you are unsure.,"Zadnja znana uspešna sinhronizacija zaposlenega Checkin. To ponastavite le, če ste prepričani, da so vsi Dnevniki sinhronizirani z vseh lokacij. Če niste prepričani, tega ne spreminjajte."
apps/erpnext/erpnext/config/accounting.py,"Seasonality for setting budgets, targets etc.","Sezonskost za nastavitev proračunov, cilji itd"
apps/erpnext/erpnext/www/all-products/index.html,No values,Ni vrednosti
DocType: Supplier Scorecard Scoring Variable,Variable Name,Ime spremenljivke
apps/erpnext/erpnext/stock/get_item_details.py,"Item {0} is a template, please select one of its variants","Postavka {0} je predlogo, izberite eno od njenih različic"
DocType: Purchase Invoice Item,Deferred Expense,Odloženi stroški
apps/erpnext/erpnext/public/js/hub/pages/Messages.vue,Back to Messages,Nazaj na sporočila
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,From Date {0} cannot be before employee's joining Date {1},Od datuma {0} ne more biti preden se zaposleni pridružijo datumu {1}
DocType: Asset,Asset Category,sredstvo Kategorija
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Net pay cannot be negative,Neto plača ne more biti negativna
DocType: Purchase Order,Advance Paid,Advance Paid
DocType: Manufacturing Settings,Overproduction Percentage For Sales Order,Odstotek prekomerne proizvodnje za prodajno naročilo
DocType: Item Group,Item Tax,Postavka Tax
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material to Supplier,Material za dobavitelja
DocType: Soil Texture,Loamy Sand,Loamy Sand
,Lost Opportunity,Izgubljena priložnost
DocType: Accounts Settings,Determine Address Tax Category From,Določite kategorijo naslova davka od
DocType: Production Plan,Material Request Planning,Načrtovanje materialnih zahtev
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Excise Invoice,Trošarina Račun
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,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,Zabeležena Udeležba
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Current Liabilities,Kratkoročne obveznosti
apps/erpnext/erpnext/public/js/projects/timer.js,Timer exceeded the given hours.,Časovnik je presegel dane ure.
apps/erpnext/erpnext/config/crm.py,Send mass SMS to your contacts,Pošlji množično SMS vaših stikov
DocType: Inpatient Record,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/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Actual Qty is mandatory,Dejanska Količina je obvezna
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} ima trenutno {1} oceno dobavitelja in naročila temu dobavitelju je treba izdajati s previdnostjo
DocType: Asset Maintenance Team,Asset Maintenance Team,Ekipa za vzdrževanje sredstev
apps/erpnext/erpnext/setup/default_success_action.py,{0} has been submitted successfully,{0} je bilo uspešno poslano
DocType: Loan,Loan Type,posojilo Vrsta
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Credit Card,Credit Card
DocType: Quality Goal,Quality Goal,Cilj kakovosti
DocType: BOM,Item to be manufactured or repacked,"Postavka, ki se proizvaja ali prepakirana"
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in condition: {0},Sintaktična napaka v stanju: {0}
DocType: Fee Structure,EDU-FST-.YYYY.-,EDU-FST-.LLLL.-
DocType: Employee Education,Major/Optional Subjects,Glavni / Izbirni predmeti
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please Set Supplier Group in Buying Settings.,V nastavitvah nakupa nastavite skupino dobaviteljev.
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
DocType: Article,Article,Člen
apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,"Prosimo, vnesite kodo kupona !!"
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Od denarja in denarja ne more biti enaka
DocType: Taxable Salary Slab,Percent Deduction,Odstotek odbitka
DocType: GL Entry,To Rename,Če želite preimenovati
DocType: Stock Entry,Repack,Zapakirajte
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select to add Serial Number.,"Izberite, če želite dodati serijsko številko."
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the customer '%s',"Prosimo, nastavite davčno kodo za stranko &#39;% s&#39;"
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select the Company first,Najprej izberite podjetje
DocType: Item Attribute,Numeric Values,Numerične vrednosti
apps/erpnext/erpnext/public/js/setup_wizard.js,Attach Logo,Priložite Logo
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Levels,Zaloga Ravni
DocType: Customer,Commission Rate,Komisija Rate
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Successfully created payment entries,Uspešno so ustvarili vnose v plačilo
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Created {0} scorecards for {1} between: ,Ustvarjene {0} kazalnike za {1} med:
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.py,Not permitted. Please disable the Procedure Template,Ni dovoljeno. Izključite predlogo za postopek
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,"Payment Type must be one of Receive, Pay and Internal Transfer","Plačilo Tip mora biti eden od Prejemanje, plačati in notranji prenos"
DocType: Travel Itinerary,Preferred Area for Lodging,Prednostno območje za vložitev
apps/erpnext/erpnext/config/agriculture.py,Analytics,Analytics
DocType: Salary Detail,Additional Amount,Dodatni znesek
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html,Cart is Empty,Košarica je Prazna
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Item {0} has no Serial No. Only serilialized items \
						can have delivery based on Serial No",Element {0} nima serijske številke. Samo serilializirani predmeti \ lahko imajo dostavo na podlagi serijske št
DocType: Vehicle,Model,Model
DocType: Work Order,Actual Operating Cost,Dejanski operacijski stroškov
DocType: Payment Entry,Cheque/Reference No,Ček / referenčna številka
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Fetch based on FIFO,Pridobivanje temelji na FIFO
DocType: Soil Texture,Clay Loam,Clay Loam
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root cannot be edited.,Root ni mogoče urejati.
DocType: Item,Units of Measure,Merske enote
DocType: Employee Tax Exemption Declaration,Rented in Metro City,Izposojeno v mestu Metro
DocType: Supplier,Default Tax Withholding Config,Podnapisani davčni odtegljaj
DocType: Manufacturing Settings,Allow Production on Holidays,Dovoli Proizvodnja na počitnicah
DocType: Sales Invoice,Customer's Purchase Order Date,Stranke Naročilo Datum
DocType: Production Plan,MFG-PP-.YYYY.-,MFG-PP-YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Capital Stock,Osnovni kapital
DocType: Asset,Default Finance Book,Privzeta finančna knjiga
DocType: Shopping Cart Settings,Show Public Attachments,Prikaži Javna Priključki
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Edit Publishing Details,Uredite podrobnosti objave
DocType: Packing Slip,Package Weight Details,Paket Teža Podrobnosti
DocType: Leave Type,Is Compensatory,Je nadomestilo
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
DocType: Item Tax Template Detail,Item Tax Template Detail,Podrobnosti predloge o predlogi za davek
apps/erpnext/erpnext/controllers/buying_controller.py,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Davčna kategorija se je spremenila v &quot;Skupaj&quot;, ker so vsi artikli, ki niso zalogi"
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,To date can not be equal or less than from date,Do datuma ne more biti enako ali manj kot od datuma
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Nothing to change,Ničesar se ne spremeni
apps/erpnext/erpnext/crm/doctype/lead/lead.py,A Lead requires either a person's name or an organization's name,Vodnik zahteva ime osebe ali ime organizacije
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please select a csv file,Izberite csv datoteko
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Error in some rows,Napaka v nekaterih vrsticah
DocType: Holiday List,Total Holidays,Skupaj prazniki
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Missing email template for dispatch. Please set one in Delivery Settings.,Manjka e-poštna predloga za odpošiljanje. Nastavite ga v nastavitvah za dostavo.
DocType: Student Leave Application,Mark as Present,Označi kot Trenutno
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,Row #{0}: Reqd by Date cannot be before Transaction Date,Vrstica # {0}: Reqd po datumu ne more biti pred datumom transakcije
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Select Serial No,Izberite serijsko št
DocType: Pricing Rule,Is Cumulative,Je kumulativno
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Designer,Oblikovalec
apps/erpnext/erpnext/config/buying.py,Terms and Conditions Template,Pogoji Template
DocType: Delivery Trip,Delivery Details,Dostava Podrobnosti
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js,Please fill in all the details to generate Assessment Result.,"Prosimo, da izpolnite vse podrobnosti, da ustvarite rezultat ocene."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,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: Terms and Conditions,Terms and Conditions Help,Pogoji Pomoč
,Item-wise Purchase Register,Elementni Nakupni register
DocType: Loyalty Point Entry,Expiry Date,Rok uporabnosti
DocType: Healthcare Settings,Employee name and designation in print,Ime in oznaka zaposlenega v tiskani obliki
apps/erpnext/erpnext/config/buying.py,Supplier Addresses and Contacts,Dobavitelj Naslovi
,accounts-browser,računi brskalnik
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Please select Category first,"Prosimo, izberite kategorijo najprej"
apps/erpnext/erpnext/config/projects.py,Project master.,Master projekt.
DocType: Contract,Contract Terms,Pogoji pogodbe
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Continue Configuration,Nadaljujte s konfiguracijo
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/employee_benefit_application/employee_benefit_application.py,Maximum benefit amount of component {0} exceeds {1},Najvišja višina ugodnosti sestavnega dela {0} presega {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py, (Half Day),(Poldnevni)
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Master Data,Obdelajte glavne podatke
DocType: Payment Term,Credit Days,Kreditni dnevi
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Please select Patient to get Lab Tests,"Prosimo, izberite Patient, da dobite laboratorijske teste"
DocType: Exotel Settings,Exotel Settings,Nastavitve Exotela
DocType: Leave Ledger Entry,Is Carry Forward,Se Carry Forward
DocType: Shift Type,Working hours below which Absent is marked. (Zero to disable),"Delovni čas, pod katerim je odsoten. (Nič, da onemogoči)"
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Send a message,Poslati sporočilo
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Get Items from BOM,Pridobi artikle iz BOM
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Lead Time Days,Dobavni rok dni
DocType: Cash Flow Mapping,Is Income Tax Expense,Ali je prihodek od davka na dohodek
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Your order is out for delivery!,Vaše naročilo je brezplačno!
apps/erpnext/erpnext/controllers/accounts_controller.py,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."
DocType: Course,Hero Image,Slika junaka
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Sales Orders in the above table,Vnesite Prodajne nalogov v zgornji tabeli
,Stock Summary,Stock Povzetek
apps/erpnext/erpnext/config/assets.py,Transfer an asset from one warehouse to another,Prenese sredstva iz enega skladišča v drugo
DocType: Vehicle,Petrol,Petrol
DocType: Employee Benefit Application,Remaining Benefits (Yearly),Preostale koristi (letno)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Bill of Materials,Kosovnica
DocType: Shift Type,The time after the shift start time when check-in is considered as late (in minutes).,"Čas po začetnem času premika, ko se prijava šteje za pozno (v minutah)."
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Vrstica {0}: Vrsta stranka in stranka je potrebna za terjatve / obveznosti račun {1}
DocType: Employee,Leave Policy,Leave Policy
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update Items,Posodobi elemente
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Ref Date,Ref Datum
DocType: Employee,Reason for Leaving,Razlog za odhod
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,View call log,Ogled dnevnika klicev
DocType: BOM Operation,Operating Cost(Company Currency),Obratovalni stroški (družba Valuta)
DocType: 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
DocType: Department,Expense Approvers,Odobritve za stroške
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,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,Account {0} does not exist,Račun {0} ne obstaja
DocType: Training Event,Training Program,Program usposabljanja
DocType: Account,Cash,Gotovina
DocType: Sales Invoice,Unpaid and Discounted,Neplačano in znižano
DocType: Employee,Short biography for website and other publications.,Kratka biografija za spletne strani in drugih publikacij.
