DocType: Accounting Period,Period Name,Naziv razdoblja
DocType: Employee,Salary Mode,Plaća način
apps/erpnext/erpnext/public/js/hub/marketplace.js,Register,Registrirajte se
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Received,Djelomično primljeno
DocType: Patient,Divorced,Rastavljen
DocType: Support Settings,Post Route Key,Objavi ključ rute
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Dopusti Stavka biti dodan više puta u transakciji
DocType: Content Question,Content Question,Sadržajno pitanje
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Cancel Material Visit {0} before cancelling this Warranty Claim,Odustani Materijal Posjetite {0} prije otkazivanja ovog jamstva se
DocType: Customer Feedback Table,Qualitative Feedback,Kvalitativne povratne informacije
apps/erpnext/erpnext/config/education.py,Assessment Reports,Izvješća o procjeni
DocType: Invoice Discounting,Accounts Receivable Discounted Account,Račun s diskontiranim potraživanjima
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting_list.js,Canceled,otkazan
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consumer Products,Consumer Products
DocType: Supplier Scorecard,Notify Supplier,Obavijesti dobavljača
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.js,Please select Party Type first,Odaberite Party Tip prvi
DocType: Item,Customer Items,Korisnički Stavke
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Liabilities,pasiva
DocType: Project,Costing and Billing,Obračun troškova i naplate
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Advance account currency should be same as company currency {0},Valuta unaprijed računa mora biti jednaka valuti tvrtke {0}
DocType: QuickBooks Migrator,Token Endpoint,Endpoint Tokena
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} can not be a ledger,Račun {0}: nadređeni račun {1} ne može biti glavna knjiga
DocType: Item,Publish Item to hub.erpnext.com,Objavi stavka to hub.erpnext.com
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Cannot find active Leave Period,Nije moguće pronaći aktivno razdoblje odmora
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Evaluation,procjena
DocType: Item,Default Unit of Measure,Zadana mjerna jedinica
DocType: SMS Center,All Sales Partner Contact,Kontakti prodajnog partnera
DocType: Department,Leave Approvers,Osobe ovlaštene za odobrenje odsustva
DocType: Employee,Bio / Cover Letter,Bio / Cover Letter
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Search Items ...,Stavke za pretraživanje ...
DocType: Patient Encounter,Investigations,istraživanja
DocType: Restaurant Order Entry,Click Enter To Add,Kliknite Unesi za dodavanje
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py,"Missing value for Password, API Key or Shopify URL","Nedostaje vrijednost za zaporku, API ključ ili Shopify URL"
DocType: Employee,Rented,Iznajmljeno
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,All Accounts,Svi računi
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Cannot transfer Employee with status Left,Ne mogu prenijeti zaposlenika s statusom lijevo
DocType: Vehicle Service,Mileage,Kilometraža
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Do you really want to scrap this asset?,Da li zaista želite odbaciti ovu imovinu?
DocType: Drug Prescription,Update Schedule,Ažuriraj raspored
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Select Default Supplier,Odabir Primarna Dobavljač
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Show Employee,Prikaži zaposlenika
DocType: Payroll Period,Standard Tax Exemption Amount,Standardni iznos oslobođenja od poreza
DocType: Exchange Rate Revaluation Account,New Exchange Rate,Novi 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 cjenik {0}
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Bit će izračunata u transakciji.
DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
DocType: Purchase Order,Customer Contact,Kupac Kontakt
DocType: Shift Type,Enable Auto Attendance,Omogući automatsku posjetu
DocType: Lost Reason Detail,Opportunity Lost Reason,Prilika izgubljen razlog
DocType: Patient Appointment,Check availability,Provjera dostupnosti
DocType: Retention Bonus,Bonus Payment Date,Datum plaćanja bonusa
DocType: Employee,Job Applicant,Posao podnositelj
DocType: Job Card,Total Time in Mins,Ukupno vrijeme u minima
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py,This is based on transactions against this Supplier. See timeline below for details,To se temelji na transakcijama protiv tog dobavljača. Pogledajte vremensku crtu ispod za detalje
DocType: Manufacturing Settings,Overproduction Percentage For Work Order,Postotak prekomjerne proizvodnje za radni nalog
DocType: Landed Cost Voucher,MAT-LCV-.YYYY.-,MAT-lakih gospodarskih-.YYYY.-
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Legal,Pravni
DocType: Sales Invoice,Transport Receipt Date,Datum prijema prijevoza
DocType: Shopify Settings,Sales Order Series,Serija prodajnih naloga
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},Stvarni tipa porez ne može biti uključen u stopu stavka u nizu {0}
DocType: Allowed To Transact With,Allowed To Transact With,Dopušteno za transakciju s
DocType: Bank Guarantee,Customer,Kupac
DocType: Purchase Receipt Item,Required By,Potrebna Do
DocType: Delivery Note,Return Against Delivery Note,Povratak Protiv izdatnice
DocType: Asset Category,Finance Book Detail,Financijska knjiga pojedinosti
apps/erpnext/erpnext/assets/doctype/asset/asset.py,All the depreciations has been booked,Sve su amortizacije knjižene
DocType: Purchase Order,% Billed,% Naplaćeno
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Payroll Number,Broj plaća
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Exchange Rate must be same as {0} {1} ({2}),Tečaj mora biti ista kao {0} {1} ({2})
DocType: Employee Tax Exemption Declaration,HRA Exemption,HRA izuzeće
DocType: Sales Invoice,Customer Name,Naziv klijenta
DocType: Vehicle,Natural Gas,Prirodni gas
DocType: Project,Message will sent to users to get their status on the project,Poruka će biti poslana korisnicima kako bi dobili svoj status na projektu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Bank account cannot be named as {0},Bankovni račun ne može biti imenovan kao {0}
DocType: Employee Tax Exemption Declaration,HRA as per Salary Structure,HRA prema Strukturi plaća
DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,Šefovi (ili skupine) od kojih računovodstvenih unosa su i sredstva su održavani.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Outstanding for {0} cannot be less than zero ({1}),Izvanredna za {0} ne može biti manji od nule ( {1} )
apps/erpnext/erpnext/public/js/controllers/transaction.js,Service Stop Date cannot be before Service Start Date,Servisni datum zaustavljanja ne može biti prije datuma početka usluge
DocType: Manufacturing Settings,Default 10 mins,Default 10 min
DocType: Leave Type,Leave Type Name,Naziv vrste odsustva
apps/erpnext/erpnext/templates/pages/projects.js,Show open,Prikaži otvorena
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Series Updated Successfully,Serija je uspješno ažurirana
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html,Checkout,Provjeri
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} in row {1},{0} u retku {1}
DocType: Asset Finance Book,Depreciation Start Date,Početni datum amortizacije
DocType: Pricing Rule,Apply On,Nanesite na
DocType: Item Price,Multiple Item prices.,Višestruke cijene proizvoda.
,Purchase Order Items To Be Received,Stavke narudžbenice za zaprimanje
DocType: SMS Center,All Supplier Contact,Svi kontakti dobavljača
DocType: Support Settings,Support Settings,Postavke za podršku
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0} is added in the child company {1},Račun {0} dodaje se u podružnici tvrtke {1}
apps/erpnext/erpnext/erpnext_integrations/doctype/exotel_settings/exotel_settings.py,Invalid credentials,Nevažeće vjerodajnice
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Available (whether in full op part),Dostupan ITC (bilo u cijelom op. Dijelu)
DocType: Amazon MWS Settings,Amazon MWS Settings,Amazon MWS postavke
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Vouchers,Obrada bonova
apps/erpnext/erpnext/utilities/transaction_base.py,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Red # {0}: Ocijenite mora biti ista kao {1}: {2} ({3} / {4})
,Batch Item Expiry Status,Hrpa Stavka isteka Status
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Bank Draft,Bank Nacrt
DocType: Journal Entry,ACC-JV-.YYYY.-,ACC-JV-.YYYY.-
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Late Entries,Ukupno kasnih unosa
DocType: Mode of Payment Account,Mode of Payment Account,Način plaćanja računa
apps/erpnext/erpnext/config/healthcare.py,Consultation,Konzultacija
DocType: Accounts Settings,Show Payment Schedule in Print,Prikaži raspored plaćanja u ispisu
apps/erpnext/erpnext/stock/doctype/item/item.py,Item Variants updated,Ažurirane su varijante predmeta
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py,Sales and Returns,Prodaja i povrat
apps/erpnext/erpnext/stock/doctype/item/item.js,Show Variants,Pokaži varijante
DocType: Academic Term,Academic Term,Akademski pojam
DocType: Employee Tax Exemption Sub Category,Employee Tax Exemption Sub Category,Podkategorija izuzeća od izuzeća radnika
apps/erpnext/erpnext/regional/italy/utils.py,Please set an Address on the Company '%s',Molimo postavite adresu na tvrtki &#39;% s&#39;
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py,Material,Materijal
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",Maksimalna korist zaposlenika {0} premašuje {1} zbroju {2} komponente proporcionalne aplikacije aplikacije za naknadu \ iznos i prijašnji iznos potraživanja
DocType: Opening Invoice Creation Tool Item,Quantity,Količina
,Customers Without Any Sales Transactions,Kupci bez ikakvih prodajnih transakcija
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Accounts table cannot be blank.,Računi stol ne može biti prazno.
DocType: Delivery Trip,Use Google Maps Direction API to calculate estimated arrival times,Koristite API za Google Maps Direction za izračunavanje predviđenih vremena dolaska
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Loans (Liabilities),Zajmovi (pasiva)
DocType: Patient Encounter,Encounter Time,Susret vrijeme
DocType: Staffing Plan Detail,Total Estimated Cost,Ukupni procijenjeni trošak
DocType: Employee Education,Year of Passing,Godina Prolazeći
DocType: Routing,Routing Name,Naziv usmjeravanja
DocType: Item,Country of Origin,Zemlja podrijetla
DocType: Soil Texture,Soil Texture Criteria,Kriteriji teksture tla
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,In Stock,Na zalihi
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js,Primary Contact Details,Primarni podaci za kontakt
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Issues,Otvorena pitanja
DocType: Production Plan Item,Production Plan Item,Proizvodnja plan artikla
DocType: Leave Ledger Entry,Leave Ledger Entry,Ostavite knjigu Ulaz
apps/erpnext/erpnext/hr/doctype/employee/employee.py,User {0} is already assigned to Employee {1},Korisnik {0} već dodijeljena zaposlenika {1}
DocType: Lab Test Groups,Add new line,Dodajte novu liniju
apps/erpnext/erpnext/utilities/activation.py,Create Lead,Stvorite olovo
DocType: Production Plan,Projected Qty Formula,Predviđena Qty Formula
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Health Care,Health Care
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,Delay in payment (Days),Kašnjenje u plaćanju (dani)
DocType: Payment Terms Template Detail,Payment Terms Template Detail,Detalji o predlošku uvjeta plaćanja
DocType: Hotel Room Reservation,Guest Name,Ime gosta
DocType: Delivery Note,Issue Credit Note,Issue Credit Note
DocType: Lab Prescription,Lab Prescription,Lab Prescription
,Delay Days,Dani odgode
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,Service Expense,usluga Rashodi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Serial Number: {0} is already referenced in Sales Invoice: {1},Serijski broj: {0} već se odnosi na prodajnu fakturu: {1}
DocType: Bank Statement Transaction Invoice Item,Invoice,Faktura
DocType: Employee Tax Exemption Declaration Category,Maximum Exempted Amount,Maksimalni izuzeti iznos
DocType: Purchase Invoice Item,Item Weight Details,Detalji o težini stavke
DocType: Asset Maintenance Log,Periodicity,Periodičnost
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} is required,Fiskalna godina {0} je potrebno
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py,Net Profit/Loss,Neto dobit / gubitak
DocType: Employee Group Table,ERPNext User ID,ERPNext User ID
DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,Najmanja udaljenost između redova biljaka za optimalni rast
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Please select Patient to get prescribed procedure,Molimo odaberite Pacijent da biste dobili propisani postupak
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Defense,Obrana
DocType: Salary Component,Abbr,Kratica
DocType: Appraisal Goal,Score (0-5),Ocjena (0-5)
DocType: Tally Migration,Tally Creditors Account,Račun vjerovnika Tally-a
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: {1} {2} does not match with {3},Red {0}: {1} {2} ne odgovara {3}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Row # {0}:,Red # {0}:
DocType: Timesheet,Total Costing Amount,Ukupno Obračun troškova Iznos
DocType: Sales Invoice,Vehicle No,Ne vozila
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select Price List,Molim odaberite cjenik
DocType: Accounts Settings,Currency Exchange Settings,Postavke mjenjačke valute
DocType: Work Order Operation,Work In Progress,Radovi u tijeku
DocType: Leave Control Panel,Branch (optional),Podružnica (izborno)
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>,Redak {0}: korisnik nije primijenio pravilo <b>{1}</b> na stavku <b>{2}</b>
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Please select date,Odaberite datum
DocType: Item Price,Minimum Qty ,Minimalni broj
DocType: Finance Book,Finance Book,Financijska knjiga
DocType: Patient Encounter,HLC-ENC-.YYYY.-,FHP-ENC-.YYYY.-
DocType: Daily Work Summary Group,Holiday List,Popis praznika
apps/erpnext/erpnext/config/quality_management.py,Review and Action,Pregled i radnja
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,This employee already has a log with the same timestamp.{0},Ovaj zaposlenik već ima zapisnik s istim vremenskim žigom. {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Accountant,Knjigovođa
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Selling Price List,Cjenik prodaje
DocType: Patient,Tobacco Current Use,Duhanska struja
apps/erpnext/erpnext/selling/report/customer_wise_item_price/customer_wise_item_price.py,Selling Rate,Stopa prodaje
DocType: Cost Center,Stock User,Stock Korisnik
DocType: Soil Analysis,(Ca+Mg)/K,(+ Ca Mg) / K
DocType: Delivery Stop,Contact Information,Kontakt informacije
apps/erpnext/erpnext/public/js/hub/pages/Search.vue,Search for anything ...,Traži bilo što ...
DocType: Company,Phone No,Telefonski broj
DocType: Delivery Trip,Initial Email Notification Sent,Poslana obavijest o početnoj e-pošti
DocType: Bank Statement Settings,Statement Header Mapping,Mapping Header Izjave
,Sales Partners Commission,Provizija prodajnih partnera
DocType: Soil Texture,Sandy Clay Loam,Pješčana Clay Loam
DocType: Purchase Invoice,Rounding Adjustment,Podešavanje zaokruživanja
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation cannot have more than 5 characters,Kratica ne može imati više od 5 znakova
DocType: Amazon MWS Settings,AU,AU
DocType: Payment Order,Payment Request,Zahtjev za plaćanje
apps/erpnext/erpnext/config/retail.py,To view logs of Loyalty Points assigned to a Customer.,Za pregled zapisnika lojalnih bodova dodijeljenih kupcu.
DocType: Asset,Value After Depreciation,Vrijednost Nakon Amortizacija
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","Nije pronađen prebačeni artikl {0} u radnom nalogu {1}, stavka nije dodana u unos zaliha"
DocType: Student,O+,O +
apps/erpnext/erpnext/stock/doctype/material_request/material_request_dashboard.py,Related,povezan
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance date can not be less than employee's joining date,Datum Gledatelji ne može biti manja od ulaska datuma zaposlenika
DocType: Grading Scale,Grading Scale Name,Ljestvici Ime
DocType: Employee Training,Training Date,Datum osposobljavanja
apps/erpnext/erpnext/public/js/hub/marketplace.js,Add Users to Marketplace,Dodajte korisnike na tržište
apps/erpnext/erpnext/accounts/doctype/account/account.js,This is a root account and cannot be edited.,To jekorijen račun i ne može se mijenjati .
DocType: POS Profile,Company Address,adresa tvrtke
DocType: BOM,Operations,Operacije
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Cannot set authorization on basis of Discount for {0},Ne mogu postaviti odobrenje na temelju popusta za {0}
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill JSON cannot be generated for Sales Return as of now,e-Way Bill JSON od sada se ne može generirati za povrat prodaje
DocType: Subscription,Subscription Start Date,Datum početka pretplate
DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Appointment charges.,"Ako se ne postavite na Patient da biste rezervirali tarife za sastanke, koristite račune s nepodmirenim potraživanjima."
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Pričvrstite .csv datoteku s dva stupca, jedan za stari naziv i jedan za novim nazivom"
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Address 2,Od adrese 2
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_proof_submission/employee_tax_exemption_proof_submission.js,Get Details From Declaration,Potražite detalje iz deklaracije
apps/erpnext/erpnext/accounts/utils.py,{0} {1} not in any active Fiscal Year.,{0} {1} nije u nijednoj fiskalnoj godini.
DocType: Packed Item,Parent Detail docname,Nadređeni detalj docname
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,"Reference: {0}, Item Code: {1} and Customer: {2}","Referenca: {0}, šifra stavke: {1} i klijent: {2}"
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py,{0} {1} is not present in the parent company,{0} {1} nije prisutno u matičnoj tvrtki
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Trial Period End Date Cannot be before Trial Period Start Date,Datum završetka probnog razdoblja Ne može biti prije datuma početka probnog razdoblja
apps/erpnext/erpnext/utilities/user_progress.py,Kg,kg
DocType: Tax Withholding Category,Tax Withholding Category,Kategorija zadržavanja poreza
apps/erpnext/erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py,Cancel the journal entry {0} first,Najprije poništite unos dnevnika {0}
DocType: Purchase Invoice,ACC-PINV-.YYYY.-,ACC-PINV-.YYYY.-
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,BOM is not specified for subcontracting item {0} at row {1},BOM nije određen za podugovaranje stavku {0} u redak {1}
DocType: Vital Signs,Reflexes,refleksi
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,{0} Result submittted,{0} Rezultat poslan
DocType: Item Attribute,Increment,Pomak
apps/erpnext/erpnext/templates/pages/search_help.py,Help Results for,Pomoć za rezultate
apps/erpnext/erpnext/public/js/stock_analytics.js,Select Warehouse...,Odaberite Warehouse ...
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Advertising,Oglašavanje
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py,Same Company is entered more than once,Ista tvrtka je ušao više od jednom
DocType: Patient,Married,Oženjen
apps/erpnext/erpnext/accounts/party.py,Not permitted for {0},Nije dopušteno {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get items from,Nabavite stavke iz
DocType: Stock Entry,Send to Subcontractor,Pošaljite podizvođaču
DocType: Purchase Invoice,Apply Tax Withholding Amount,Primijenite iznos zadržavanja poreza
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Total completed qty can not be greater than for quantity,Ukupni ispunjeni broj ne može biti veći nego za količinu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Stock cannot be updated against Delivery Note {0},Dionica ne može biti obnovljeno protiv isporuke Napomena {0}
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Total Amount Credited,Ukupan iznos je odobren
apps/erpnext/erpnext/templates/generators/item_group.html,No items listed,Nema navedenih stavki
DocType: Asset Repair,Error Description,Opis pogreške
DocType: Payment Reconciliation,Reconcile,pomiriti
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Grocery,Trgovina prehrambenom robom
DocType: Quality Inspection Reading,Reading 1,Čitanje 1
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Pension Funds,Mirovinski fondovi
DocType: Exchange Rate Revaluation Account,Gain/Loss,Dobit / Gubitak
DocType: Crop,Perennial,višegodišnji
DocType: Program,Is Published,Objavljeno je
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Delivery Notes,Prikaži bilješke o isporuci
apps/erpnext/erpnext/controllers/status_updater.py,"To allow over billing, update ""Over Billing Allowance"" in Accounts Settings or the Item.","Da biste omogućili prekomerno naplaćivanje, ažurirajte &quot;Nadoplata za naplatu&quot; u Postavkama računa ili Stavka."
DocType: Patient Appointment,Procedure,Postupak
DocType: Accounts Settings,Use Custom Cash Flow Format,Koristite prilagođeni format novčanog toka
DocType: SMS Center,All Sales Person,Svi prodavači
DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"** Mjesečna distribucija ** pomaže vam rasporediti proračun / Target preko mjeseca, ako imate sezonalnost u Vašem poslovanju."
apps/erpnext/erpnext/accounts/page/pos/pos.js,Not items found,Nije pronađen stavke
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Structure Missing,Struktura plaća Nedostaje
DocType: Lead,Person Name,Osoba ime
,Supplier Ledger Summary,Sažetak knjige dobavljača
DocType: Sales Invoice Item,Sales Invoice Item,Prodajni proizvodi
DocType: Quality Procedure Table,Quality Procedure Table,Tablica s postupcima kakvoće
DocType: Account,Credit,Kredit
DocType: POS Profile,Write Off Cost Center,Otpis troška
apps/erpnext/erpnext/public/js/setup_wizard.js,"e.g. ""Primary School"" or ""University""",npr &quot;Osnovna škola&quot; ili &quot;Sveučilište&quot;
apps/erpnext/erpnext/config/stock.py,Stock Reports,dionica izvješća
DocType: Warehouse,Warehouse Detail,Detalji o skladištu
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Last carbon check date cannot be a future date,Posljednji datum provjere ugljika ne može biti budući 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.,Datum Pojam završetka ne može biti kasnije od godine datum završetka školske godine u kojoj je pojam vezan (Akademska godina {}). Ispravite datume i pokušajte ponovno.
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","""je nepokretna imovina"" se ne može odznačiti, jer postoji zapis o imovini nad navedenom stavkom"
DocType: Delivery Trip,Departure Time,Vrijeme polaska
DocType: Vehicle Service,Brake Oil,ulje za kočnice
DocType: Tax Rule,Tax Type,Porezna Tip
,Completed Work Orders,Dovršeni radni nalozi
DocType: Support Settings,Forum Posts,Forum postova
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","Zadatak je zamišljen kao pozadinski posao. U slučaju da dođe do problema s obradom u pozadini, sustav će dodati komentar o pogrešci ovog usklađivanja zaliha i vratit će se u fazu skice."
apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Iznos oporezivanja
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Niste ovlašteni dodavati ili ažurirati unose prije {0}
DocType: Leave Policy,Leave Policy Details,Ostavite pojedinosti o pravilima
DocType: BOM,Item Image (if not slideshow),Slika proizvoda (ako nije slide prikaz)
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}.,Redak # {0}: Operacija {1} nije dovršena za {2} količinu gotovih proizvoda u radnom nalogu {3}. Ažurirajte status rada putem Job Card {4}.
DocType: Work Order Operation,(Hour Rate / 60) * Actual Operation Time,(Broj sati / 60) * Stvarno trajanje 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,Redak # {0}: Referentni tip dokumenta mora biti jedan od zahtjeva za trošak ili unos dnevnika
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select BOM,Odaberi BOM
DocType: SMS Log,SMS Log,SMS Prijava
DocType: Call Log,Ringing,zvonjava
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Delivered Items,Troškovi isporučenih stavki
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py,The holiday on {0} is not between From Date and To Date,Odmor na {0} nije između Od Datum i do sada
DocType: Inpatient Record,Admission Scheduled,Zakazan ulaz
DocType: Student Log,Student Log,Studentski Prijava
apps/erpnext/erpnext/config/buying.py,Templates of supplier standings.,Predlošci stanja dobavljača.
DocType: Lead,Interested,Zainteresiran
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,Opening,Otvaranje
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Program: ,Program:
DocType: Item,Copy From Item Group,Primjerak iz točke Group
DocType: Journal Entry,Opening Entry,Otvaranje - ulaz
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Account Pay Only,Račun platiti samo
DocType: Loan,Repay Over Number of Periods,Vrati Preko broj razdoblja
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Quantity to Produce can not be less than Zero,Količina za proizvodnju ne može biti manja od Nula
DocType: Stock Entry,Additional Costs,Dodatni troškovi
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Kupac&gt; Grupa kupaca&gt; Teritorij
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction can not be converted to group.,Račun s postojećom transakcijom ne može se pretvoriti u grupu.
DocType: Lead,Product Enquiry,Upit
DocType: Education Settings,Validate Batch for Students in Student Group,Validirati seriju za studente u grupi studenata
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,No leave record found for employee {0} for {1},Ne dopusta rekord pronađeno za zaposlenika {0} od {1}
DocType: Company,Unrealized Exchange Gain/Loss Account,Nerealizirani račun dobiti i gubitka
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter company first,Unesite tvrtka prva
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Please select Company first,Odaberite tvrtka prvi
DocType: Employee Education,Under Graduate,Preddiplomski
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Status Notification in HR Settings.,Postavite zadani predložak za Obavijest o statusu ostavite u HR postavkama.
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/sales_partner_target_variance_based_on_item_group.js,Target On,Target Na
DocType: BOM,Total Cost,Ukupan trošak
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.js,Allocation Expired!,Raspodjela je istekla!
DocType: Soil Analysis,Ca/K,Ca / K
DocType: Leave Type,Maximum Carry Forwarded Leaves,Maksimalno nose naprijed listove
DocType: Salary Slip,Employee Loan,zaposlenik kredita
DocType: Additional Salary,HR-ADS-.YY.-.MM.-,HR-ADS-.YY .-. MM.-
DocType: Fee Schedule,Send Payment Request Email,Pošaljite e-poštu za zahtjev za plaćanjem
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Item {0} does not exist in the system or has expired,Proizvod {0} ne postoji u sustavu ili je istekao
DocType: Supplier,Leave blank if the Supplier is blocked indefinitely,Ostavite prazno ako je dobavljač blokiran na neodređeno vrijeme
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Real Estate,Nekretnine
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Statement of Account,Izjava o računu
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Pharmaceuticals,Farmaceutske
DocType: Purchase Invoice Item,Is Fixed Asset,Je nepokretne imovine
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Future Payments,Prikaži buduće isplate
DocType: Patient,HLC-PAT-.YYYY.-,FHP-PAT-.YYYY.-
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,This bank account is already synchronized,Taj je bankovni račun već sinkroniziran
DocType: Homepage,Homepage Section,Odjeljak početne stranice
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work Order has been {0},Radni nalog je bio {0}
DocType: Budget,Applicable on Purchase Order,Primjenjivo na narudžbenicu
DocType: Item,STO-ITEM-.YYYY.-,STO-ITEM-.YYYY.-
apps/erpnext/erpnext/hr/doctype/hr_settings/hr_settings.py,Password policy for Salary Slips is not set,Pravila zaporki za salve za plaće nisu postavljena
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate customer group found in the cutomer group table,Dvostruka grupa kupaca nalaze u tablici cutomer grupe
DocType: Location,Location Name,Naziv lokacije
DocType: Quality Procedure Table,Responsible Individual,Odgovorni pojedinac
DocType: Naming Series,Prefix,Prefiks
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html,Event Location,Lokacija događaja
apps/erpnext/erpnext/selling/report/customer_wise_item_price/customer_wise_item_price.py,Available Stock,Dostupne zalihe
DocType: Asset Settings,Asset Settings,Postavke imovine
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,potrošni
DocType: Student,B-,B-
DocType: Assessment Result,Grade,Razred
DocType: Restaurant Table,No of Seats,Nema sjedala
DocType: Sales Invoice,Overdue and Discounted,Prepušteni i popusti
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Poziv prekinuti
DocType: Sales Invoice Item,Delivered By Supplier,Isporučio dobavljač
DocType: Asset Maintenance Task,Asset Maintenance Task,Zadatak održavanja imovine
DocType: SMS Center,All Contact,Svi kontakti
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Annual Salary,Godišnja plaća
DocType: Daily Work Summary,Daily Work Summary,Dnevni rad Sažetak
DocType: Period Closing Voucher,Closing Fiscal Year,Zatvaranje Fiskalna godina
apps/erpnext/erpnext/accounts/party.py,{0} {1} is frozen,{0} {1} je zamrznuta
apps/erpnext/erpnext/setup/doctype/company/company.py,Please select Existing Company for creating Chart of Accounts,Odaberite postojeće tvrtke za izradu grafikona o računima
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Expenses,Stock Troškovi
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Select Target Warehouse,Odaberite Target Warehouse
apps/erpnext/erpnext/hr/doctype/employee/employee.js,Please enter Preferred Contact Email,Unesite igraca Kontakt email
DocType: Purchase Invoice Item,Accepted Qty,Prihvaćeno Količina
DocType: Journal Entry,Contra Entry,Contra Stupanje
DocType: Journal Entry Account,Credit in Company Currency,Kredit u trgovačkim društvima valuti
DocType: Lab Test UOM,Lab Test UOM,Lab test UOM
DocType: Delivery Note,Installation Status,Status instalacije
DocType: BOM,Quality Inspection Template,Predložak inspekcije kvalitete
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,"Do you want to update attendance?<br>Present: {0}\
					<br>Absent: {1}",Želite li ažurirati dolazak? <br> Prisutni: {0} \ <br> Odsutni: {1}
apps/erpnext/erpnext/controllers/buying_controller.py,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Količina prihvaćeno + odbijeno mora biti jednaka zaprimljenoj količini proizvoda {0}
DocType: Item,Supply Raw Materials for Purchase,Nabava sirovine za kupnju
DocType: Agriculture Analysis Criteria,Fertilizer,gnojivo
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
				Item {0} is added with and without Ensure Delivery by \
				Serial No.",Ne može se osigurati isporuka prema serijskoj broju kao što je \ Stavka {0} dodana sa i bez osiguranja isporuke od strane \ Serial No.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,At least one mode of payment is required for POS invoice.,potreban je najmanje jedan način plaćanja za POS računa.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Batch no is required for batched item {0},Za serijsku stavku nije potreban broj serije {0}
DocType: Bank Statement Transaction Invoice Item,Bank Statement Transaction Invoice Item,Stavka transakcijske fakture bankovne izjave
DocType: Salary Detail,Tax on flexible benefit,Porez na fleksibilnu korist
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item {0} is not active or end of life has been reached,Proizvod {0} nije aktivan ili nije došao do kraja roka valjanosti
DocType: Student Admission Program,Minimum Age,Minimalna dob
apps/erpnext/erpnext/utilities/user_progress.py,Example: Basic Mathematics,Primjer: Osnovni Matematika
DocType: Customer,Primary Address,Primarna adresa
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Diff Qty,Diff Qty
DocType: Production Plan,Material Request Detail,Detalji o zahtjevu za materijal
DocType: Selling Settings,Default Quotation Validity Days,Zadani rokovi valjanosti ponude
apps/erpnext/erpnext/controllers/accounts_controller.py,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","To uključuje porez u redu {0} u stopu točke , porezi u redovima {1} također moraju biti uključeni"
apps/erpnext/erpnext/config/quality_management.py,Quality Procedure.,Postupak kvalitete.
DocType: SMS Center,SMS Center,SMS centar
DocType: Payroll Entry,Validate Attendance,Potvrđivanje prisutnosti
DocType: Sales Invoice,Change Amount,Promjena Iznos
DocType: Party Tax Withholding Config,Certificate Received,Primljena potvrda
DocType: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Postavite vrijednost fakture za B2C. B2CL i B2CS izračunate na temelju ove vrijednosti fakture.
DocType: BOM Update Tool,New BOM,Novi BOM
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Prescribed Procedures,Propisani postupci
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,Naziv grupe dobavljača
DocType: Driver,Driving License Categories,Kategorije voznih dozvola
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please enter Delivery Date,Unesite datum isporuke
DocType: Depreciation Schedule,Make Depreciation Entry,Provjerite Amortizacija unos
DocType: Closed Document,Closed Document,Zatvoreni dokument
DocType: HR Settings,Leave Settings,Napusti postavke
DocType: Appraisal Template Goal,KRA,KRA
DocType: Lead,Request Type,Zahtjev Tip
DocType: Purpose of Travel,Purpose of Travel,Svrha putovanja
DocType: Payroll Period,Payroll Periods,Razdoblja obračuna plaća
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Broadcasting,Radiodifuzija
apps/erpnext/erpnext/config/retail.py,Setup mode of POS (Online / Offline),Način postavljanja POS (Online / Offline)
DocType: Manufacturing Settings,Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order,Onemogućuje izradu vremenskih zapisnika o radnim nalozima. Operacije neće biti praćene radnim nalogom
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Execution,izvršenje
apps/erpnext/erpnext/config/manufacturing.py,Details of the operations carried out.,Pojedinosti o operacijama koje se provode.
DocType: Asset Maintenance Log,Maintenance Status,Status održavanja
DocType: Purchase Invoice Item,Item Tax Amount Included in Value,Iznos poreza na stavku uključen u vrijednost
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Membership Details,Pojedinosti o članstvu
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Supplier is required against Payable account {2},{0} {1}: potreban Dobavljač u odnosu na plativi račun{2}
apps/erpnext/erpnext/config/buying.py,Items and Pricing,Stavke i cijene
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Total hours: {0},Ukupno vrijeme: {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 trebao biti u fiskalnoj godini. Uz pretpostavku Od datuma = {0}
DocType: Patient Medical Record,HLC-PMR-.YYYY.-,FHP-PMR-.YYYY.-
DocType: Drug Prescription,Interval,Interval
DocType: Pricing Rule,Promotional Scheme Id,ID promotivne 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,Unutarnja potrošnja (može se obrnuti)
DocType: Supplier,Individual,Pojedinac
DocType: Academic Term,Academics User,Akademski korisnik
DocType: Cheque Print Template,Amount In Figure,Iznos u slici
DocType: Loan Application,Loan Info,Informacije o zajmu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,All Other ITC,Svi ostali ITC
apps/erpnext/erpnext/config/crm.py,Plan for maintenance visits.,Plan održavanja posjeta.
DocType: Supplier Scorecard Period,Supplier Scorecard Period,Razdoblje ocjena dobavljača
DocType: Support Settings,Search APIs,API-ji za pretraživanje
DocType: Share Transfer,Share Transfer,Dijeljenje prijenosa
,Expiring Memberships,Istječe članstva
apps/erpnext/erpnext/templates/pages/home.html,Read blog,Pročitajte blog
DocType: POS Profile,Customer Groups,kupaca Grupe
apps/erpnext/erpnext/public/js/financial_statements.js,Financial Statements,Financijska izvješća
DocType: Guardian,Students,Studenti
apps/erpnext/erpnext/config/buying.py,Rules for applying pricing and discount.,Pravila za primjenu cijena i popusta.
DocType: Daily Work Summary,Daily Work Summary Group,Svakodnevna grupa za rad
DocType: Practitioner Schedule,Time Slots,Vrijeme utora
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py,Price List must be applicable for Buying or Selling,Cjenik mora biti primjenjiv za kupnju ili prodaju
DocType: Shift Assignment,Shift Request,Zahtjev za Shift
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Installation date cannot be before delivery date for Item {0},Datum Instalacija ne može biti prije datuma isporuke za točke {0}
DocType: Purchase Invoice Item,Discount on Price List Rate (%),Popust na cjenik (%)
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,Item Template,Predložak stavke
DocType: Job Offer,Select Terms and Conditions,Odaberite Uvjeti
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Out Value,Iz vrijednost
DocType: Bank Statement Settings Item,Bank Statement Settings Item,Postavka bankovne izjave
DocType: Woocommerce Settings,Woocommerce Settings,Postavke Woocommerce
DocType: Leave Ledger Entry,Transaction Name,Naziv transakcije
DocType: Production Plan,Sales Orders,Narudžbe kupca
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Multiple Loyalty Program found for the Customer. Please select manually.,Korisnik je pronašao više programa lojalnosti. Odaberite ručno.
DocType: Purchase Taxes and Charges,Valuation,Procjena
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Set as Default,Postavi kao zadano
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Expiry date is mandatory for selected item.,Datum isteka obvezan je za odabrani artikl.
,Purchase Order Trends,Trendovi narudžbenica kupnje
apps/erpnext/erpnext/utilities/user_progress.py,Go to Customers,Idite na Kupce
DocType: Hotel Room Reservation,Late Checkin,Kasni ček
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Finding linked payments,Pronalaženje povezanih plaćanja
apps/erpnext/erpnext/templates/emails/request_for_quotation.html,The request for quotation can be accessed by clicking on the following link,Zahtjev za ponudu se može pristupiti klikom na sljedeći link
DocType: Quiz Result,Selected Option,Odabrana opcija
DocType: SG Creation Tool Course,SG Creation Tool Course,Tečaj SG alat za izradu
DocType: Bank Statement Transaction Invoice Item,Payment Description,Opis plaćanja
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Insufficient Stock,nedovoljna Stock
DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Onemogući planiranje kapaciteta i vremena za praćenje
DocType: Email Digest,New Sales Orders,Nove narudžbenice
DocType: Bank Account,Bank Account,Žiro račun
DocType: Travel Itinerary,Check-out Date,Datum isteka
DocType: Leave Type,Allow Negative Balance,Dopustite negativan saldo
apps/erpnext/erpnext/projects/doctype/project_type/project_type.py,You cannot delete Project Type 'External',Ne možete izbrisati vrstu projekta &#39;Vanjski&#39;
apps/erpnext/erpnext/public/js/utils.js,Select Alternate Item,Odaberite Alternativnu stavku
DocType: Employee,Create User,Izradi korisnika
DocType: Selling Settings,Default Territory,Zadani teritorij
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Television,Televizija
DocType: Work Order Operation,Updated via 'Time Log',Ažurirano putem 'Time Log'
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Select the customer or supplier.,Odaberite kupca ili dobavljača.
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Select only one Priority as Default.,Odaberite samo jedan prioritet kao zadani.
apps/erpnext/erpnext/controllers/taxes_and_totals.py,Advance amount cannot be greater than {0} {1},Advance iznos ne može biti veći 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}","Vremenski utor je preskočen, utor {0} do {1} preklapa vanjski otvor {2} na {3}"
DocType: Naming Series,Series List for this Transaction,Serija Popis za ovu transakciju
DocType: Company,Enable Perpetual Inventory,Omogući trajnu zalihu
DocType: Bank Guarantee,Charges Incurred,Naplaćeni troškovi
apps/erpnext/erpnext/public/js/education/lms/quiz.js,Something went wrong while evaluating the quiz.,Nešto je pošlo po zlu tijekom vrednovanja kviza.
DocType: Company,Default Payroll Payable Account,Zadana plaće Plaća račun
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Edit Details,Uredi pojedinosti
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Update Email Group,Update Email Grupa
DocType: POS Profile,Only show Customer of these Customer Groups,Pokaži samo kupca ovih korisničkih grupa
DocType: Sales Invoice,Is Opening Entry,je početni unos
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. ","Ako se ne označe, stavka neće biti prikazana u prodajnoj dostavnici, ali se može upotrebljavati u grupnom testiranju."
DocType: Customer Group,Mention if non-standard receivable account applicable,Spomenuti ako nestandardni potraživanja računa primjenjivo
DocType: Course Schedule,Instructor Name,Instruktor Ime
DocType: Company,Arrear Component,Obavijestite Komponente
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.py,Stock Entry has been already created against this Pick List,Unos dionica već je stvoren protiv ove liste odabira
DocType: Supplier Scorecard,Criteria Setup,Postavljanje kriterija
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,For Warehouse is required before Submit,Jer je potrebno Warehouse prije Podnijeti
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Received On,Primila je u
DocType: Codification Table,Medical Code,Medicinski kodeks
apps/erpnext/erpnext/config/integrations.py,Connect Amazon with ERPNext,Spojite Amazon s ERPNextom
apps/erpnext/erpnext/templates/generators/item/item_configure.html,Contact Us,Kontaktirajte nas
DocType: Delivery Note Item,Against Sales Invoice Item,Protiv prodaje dostavnice točke
DocType: Agriculture Analysis Criteria,Linked Doctype,Povezani Doctype
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Financing,Neto novčani tijek iz financijskih
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full , did not save","LocalStorage puna, nije štedjelo"
DocType: Lead,Address & Contact,Adresa i kontakt
DocType: Leave Allocation,Add unused leaves from previous allocations,Dodaj neiskorištenih lišće iz prethodnih dodjela
DocType: Sales Partner,Partner website,website partnera
DocType: Restaurant Order Entry,Add Item,Dodaj stavku
DocType: Party Tax Withholding Config,Party Tax Withholding Config,Konfiguracija zadržavanja poreza za strance
DocType: Lab Test,Custom Result,Prilagođeni rezultat
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.js,Bank accounts added,Dodani su bankovni računi
DocType: Call Log,Contact Name,Kontakt ime
DocType: Plaid Settings,Synchronize all accounts every hour,Sinkronizirajte sve račune na svakih sat vremena
DocType: Course Assessment Criteria,Course Assessment Criteria,Kriteriji za procjenu predmeta
DocType: Pricing Rule Detail,Rule Applied,Pravilo se primjenjuje
DocType: Service Level Priority,Resolution Time Period,Vrijeme razlučivosti
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Tax Id: ,ID poreza:
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student ID: ,Studentska iskaznica:
DocType: POS Customer Group,POS Customer Group,POS Korisnička Grupa
DocType: Healthcare Practitioner,Practitioner Schedules,Praktični raspored
DocType: Cheque Print Template,Line spacing for amount in words,Prored za iznos u riječima
DocType: Vehicle,Additional Details,dodatni detalji
apps/erpnext/erpnext/templates/generators/bom.html,No description given,Nema opisa
apps/erpnext/erpnext/config/buying.py,Request for purchase.,Zahtjev za kupnju.
DocType: POS Closing Voucher Details,Collected Amount,Prikupljeni iznos
DocType: Lab Test,Submitted Date,Poslani datum
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Company field is required,Polje tvrtke je obavezno
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py,This is based on the Time Sheets created against this project,To se temelji na vremenske tablice stvorene na ovom projektu
DocType: Call Log,Recording URL,URL za snimanje
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,Start Date cannot be before the current date,Datum početka ne može biti prije trenutnog datuma
,Open Work Orders,Otvorite radne narudžbe
DocType: Healthcare Practitioner,Out Patient Consulting Charge Item,Naplaćuje se naknada za savjetovanje o pacijentu
DocType: Payment Term,Credit Months,Mjeseci kredita
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Net Pay cannot be less than 0,Neto plaća ne može biti manja od 0
DocType: Contract,Fulfilled,ispunjena
DocType: Inpatient Record,Discharge Scheduled,Zakazano je iskrcavanje
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Relieving Date must be greater than Date of Joining,Olakšavanja Datum mora biti veći od dana ulaska u
DocType: POS Closing Voucher,Cashier,Blagajnik
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Leaves per Year,Ostavlja godišnje
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.,"Red {0}: Provjerite 'Je li Advance ""protiv nalog {1} Ako je to unaprijed ulaz."
apps/erpnext/erpnext/stock/utils.py,Warehouse {0} does not belong to company {1},Skladište {0} ne pripada tvrtki {1}
DocType: Email Digest,Profit & Loss,Gubitak profita
apps/erpnext/erpnext/utilities/user_progress.py,Litre,Litre
DocType: Task,Total Costing Amount (via Time Sheet),Ukupno troška Iznos (preko vremenska tablica)
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py,Please setup Students under Student Groups,Postavite učenike u Studentske grupe
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Complete Job,Završi posao
DocType: Item Website Specification,Item Website Specification,Specifikacija web stranice proizvoda
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave Blocked,Neodobreno odsustvo
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} has reached its end of life on {1},Proizvod {0} je dosegao svoj rok trajanja na {1}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Bank Entries,Bankovni tekstova
DocType: Customer,Is Internal Customer,Interni je kupac
DocType: Crop,Annual,godišnji
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)","Ako je uključeno automatsko uključivanje, klijenti će se automatski povezati s predmetnim programom lojalnosti (u pripremi)"
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Stock pomirenje točka
DocType: Stock Entry,Sales Invoice No,Prodajni račun br
DocType: Website Filter Field,Website Filter Field,Polje filtra web mjesta
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Supply Type,Vrsta napajanja
DocType: Material Request Item,Min Order Qty,Min naručena kol
DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Tečaj Student Grupa alat za izradu
DocType: Lead,Do Not Contact,Ne kontaktirati
apps/erpnext/erpnext/utilities/user_progress.py,People who teach at your organisation,Ljudi koji uče u svojoj organizaciji
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Software Developer,Software Developer
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Create Sample Retention Stock Entry,Napravite unos zaliha uzoraka
DocType: Item,Minimum Order Qty,Minimalna količina narudžbe
DocType: Supplier,Supplier Type,Dobavljač Tip
DocType: Course Scheduling Tool,Course Start Date,Naravno Datum početka
,Student Batch-Wise Attendance,Student šarže posjećenost
DocType: POS Profile,Allow user to edit Rate,Dopustite korisniku da uređivanje Rate
DocType: Item,Publish in Hub,Objavi na Hub
DocType: Student Admission,Student Admission,Studentski Ulaz
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is cancelled,Proizvod {0} je otkazan
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Depreciation Start Date is entered as past date,Row amortizacije {0}: Datum početka amortizacije unesen je kao protekli datum
DocType: Contract Template,Fulfilment Terms and Conditions,Uvjeti ispunjavanja uvjeta
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material Request,Zahtjev za robom
DocType: Bank Reconciliation,Update Clearance Date,Ažurirajte provjeri datum
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,Bundle Qty,Količina paketa
,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},Stavka {0} nije pronađena u &quot;sirovina nabavlja se &#39;stol narudžbenice {1}
DocType: Salary Slip,Total Principal Amount,Ukupni iznos glavnice
DocType: Student Guardian,Relation,Odnos
DocType: Quiz Result,Correct,ispravan
DocType: Student Guardian,Mother,Majka
DocType: Restaurant Reservation,Reservation End Time,Vrijeme završetka rezervacije
DocType: Crop,Biennial,dvogodišnjica
,BOM Variance Report,Izvješće o varijanti BOM
apps/erpnext/erpnext/config/selling.py,Confirmed orders from Customers.,Potvrđene narudžbe kupaca.
DocType: Purchase Receipt Item,Rejected Quantity,Odbijen Količina
apps/erpnext/erpnext/education/doctype/fees/fees.py,Payment request {0} created,Izrađen je zahtjev za plaćanje {0}
DocType: Inpatient Record,Admitted Datetime,Prihvaćeno Datetime
DocType: Work Order,Backflush raw materials from work-in-progress warehouse,Otpadne sirovine iz skladišta u tijeku rada
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Open Orders,Otvori narudžbe
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Unable to find Salary Component {0},Nije moguće pronaći komponentu plaće {0}
apps/erpnext/erpnext/healthcare/setup.py,Low Sensitivity,Niska osjetljivost
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_log/shopify_log.js,Order rescheduled for sync,Redoslijed je preusmjeren za sinkronizaciju
apps/erpnext/erpnext/templates/emails/training_event.html,Please confirm once you have completed your training,Potvrdite nakon završetka obuke
DocType: Lead,Suggestions,Prijedlozi
DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Postavite proračun za grupu proizvoda na ovom području. Također možete uključiti sezonalnost postavljanjem distribucije.
DocType: Plaid Settings,Plaid Public Key,Plaid javni ključ
DocType: Payment Term,Payment Term Name,Naziv plaćanja
DocType: Healthcare Settings,Create documents for sample collection,Izradite dokumente za prikupljanje uzoraka
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Plaćanje protiv {0} {1} ne može biti veća od preostali iznos {2}
apps/erpnext/erpnext/patches/v11_0/add_healthcare_service_unit_tree_root.py,All Healthcare Service Units,Sve zdravstvene usluge
DocType: Bank Account,Address HTML,Adressa u HTML-u
DocType: Lead,Mobile No.,Mobitel br.
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html,Mode of Payments,Način plaćanja
DocType: Maintenance Schedule,Generate Schedule,Generiranje Raspored
DocType: Purchase Invoice Item,Expense Head,Rashodi voditelj
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select Charge Type first,Odaberite Naknada za prvi
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.. ","Ovdje možete definirati sve zadatke koji su potrebni za ovaj usjev. Dnevno polje se koristi za spominjanje dana kada se zadatak treba obaviti, 1 je 1. dan itd."
DocType: Student Group Student,Student Group Student,Studentski Group Studentski
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Latest,Najnovije
DocType: Asset Maintenance Task,2 Yearly,2 Godišnje
DocType: Education Settings,Education Settings,Postavke za obrazovanje
DocType: Vehicle Service,Inspection,inspekcija
apps/erpnext/erpnext/regional/italy/utils.py,E-Invoicing Information Missing,Informacije o e-računima nedostaju
DocType: Leave Allocation,HR-LAL-.YYYY.-,HR-LAL-.YYYY.-
DocType: Exchange Rate Revaluation Account,Balance In Base Currency,Stanje u valuti baze
DocType: Supplier Scorecard Scoring Standing,Max Grade,Max Grade
DocType: Email Digest,New Quotations,Nove ponude
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as {1} on leave.,Sudjelovanje nije poslano za {0} kao {1} na dopustu.
DocType: Journal Entry,Payment Order,Nalog za plaćanje
DocType: Employee Tax Exemption Declaration,Income From Other Sources,Prihodi iz drugih izvora
DocType: Warehouse,"If blank, parent Warehouse Account or company default will be considered","Ako je prazno, uzet će se u obzir račun nadređenog skladišta ili neispunjenje tvrtke"
DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,E-mail plaće slip da zaposleniku na temelju preferiranih e-mail koji ste odabrali u zaposlenika
DocType: Tax Rule,Shipping County,dostava županija
DocType: Currency Exchange,For Selling,Za prodaju
apps/erpnext/erpnext/config/desktop.py,Learn,Naučiti
,Trial Balance (Simple),Probna ravnoteža (jednostavno)
DocType: Purchase Invoice Item,Enable Deferred Expense,Omogući odgođeno plaćanje
DocType: Asset,Next Depreciation Date,Sljedeći datum Amortizacija
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Aktivnost Cijena po zaposlenom
DocType: Accounts Settings,Settings for Accounts,Postavke za račune
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice No exists in Purchase Invoice {0},Dobavljač Račun br postoji u fakturi {0}
apps/erpnext/erpnext/config/crm.py,Manage Sales Person Tree.,Uredi raspodjelu prodavača.
DocType: Job Applicant,Cover Letter,Pismo
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Outstanding Cheques and Deposits to clear,Izvanredna Čekovi i depoziti za brisanje
DocType: Item,Synced With Hub,Sinkronizirati s Hub
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward supplies from ISD,Unutarnje zalihe od ISD-a
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},Red # {0}: {1} ne može biti negativna za predmet {2}
apps/erpnext/erpnext/setup/doctype/company/company.js,Wrong Password,Pogrešna Lozinka
DocType: POS Profile,Offline POS Settings,Offline postavke
DocType: Stock Entry Detail,Reference Purchase Receipt,Referentna kupnja
DocType: Stock Reconciliation,MAT-RECO-.YYYY.-,MAT-Reco-.YYYY.-
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Variant Of,Varijanta
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Completed Qty can not be greater than 'Qty to Manufacture',Završen Qty ne može biti veći od 'Kol proizvoditi'
apps/erpnext/erpnext/public/js/purchase_trends_filters.js,Period based On,Razdoblje na temelju
DocType: Period Closing Voucher,Closing Account Head,Zatvaranje računa šefa
DocType: Employee,External Work History,Vanjski Povijest Posao
apps/erpnext/erpnext/projects/doctype/task/task.py,Circular Reference Error,Kružni Referentna Greška
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Report Card,Kartica studentskog izvješća
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Pin Code,Iz PIN koda
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Sales Person,Pokaži prodajnu osobu
DocType: Appointment Type,Is Inpatient,Je li bolestan
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.,Riječima (izvoz) će biti vidljivo nakon što spremite otpremnicu.
DocType: Cheque Print Template,Distance from left edge,Udaljenost od lijevog ruba
apps/erpnext/erpnext/utilities/bot.py,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} jedinica [{1}] (# Form / Artikl / {1}) naći u [{2}] (# Form / Skladište / {2})
DocType: Lead,Industry,Industrija
DocType: BOM Item,Rate & Amount,Ocijenite i iznosite
apps/erpnext/erpnext/config/website.py,Settings for website product listing,Postavke za popis proizvoda na web mjestu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Amount of Integrated Tax,Iznos integriranog poreza
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Obavijest putem maila prilikom stvaranja automatskog Zahtjeva za robom
DocType: Accounting Dimension,Dimension Name,Naziv dimenzije
apps/erpnext/erpnext/healthcare/setup.py,Resistant,otporan
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Please set Hotel Room Rate on {},Molimo postavite Hotel Room Rate na {}
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Postavite serijsku brojevnu seriju za Attendance putem Postavljanje&gt; Numeriranje serija
DocType: Journal Entry,Multi Currency,Više valuta
DocType: Bank Statement Transaction Invoice Item,Invoice Type,Tip fakture
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from date must be less than valid upto date,Vrijedi od datuma mora biti manje od važećeg do datuma
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Exception occurred while reconciling {0},Izuzeće je došlo tijekom usklađivanja {0}
DocType: Purchase Invoice,Set Accepted Warehouse,Postavite Prihvaćeno skladište
DocType: Employee Benefit Claim,Expense Proof,Provedba troškova
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.py,Saving {0},Spremanje {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Delivery Note,Otpremnica
DocType: Patient Encounter,Encounter Impression,Susret susreta
apps/erpnext/erpnext/config/help.py,Setting up Taxes,Postavljanje Porezi
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Sold Asset,Troškovi prodane imovinom
DocType: Volunteer,Morning,Jutro
apps/erpnext/erpnext/accounts/utils.py,Payment Entry has been modified after you pulled it. Please pull it again.,Ulazak Plaćanje je izmijenjen nakon što ga je izvukao. Ponovno izvucite ga.
DocType: Program Enrollment Tool,New Student Batch,Nova studentska serija
apps/erpnext/erpnext/accounts/doctype/item_tax_template/item_tax_template.py,{0} entered twice in Item Tax,{0} dva puta ušao u točki poreza
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Summary for this week and pending activities,Sažetak za ovaj tjedan i tijeku aktivnosti
DocType: Student Applicant,Admitted,priznao
DocType: Workstation,Rent Cost,Rent cost
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid transactions sync error,Pogreška sinkronizacije plaidnih transakcija
DocType: Leave Ledger Entry,Is Expired,Istekao je
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py,Amount After Depreciation,Iznos nakon amortizacije
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Upcoming Calendar Events,Nadolazeći Kalendar događanja
apps/erpnext/erpnext/public/js/templates/item_quick_entry.html,Variant Attributes,Varijante Značajke
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Please select month and year,Molimo odaberite mjesec i godinu
DocType: Employee,Company Email,tvrtka E-mail
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,User has not applied rule on the invoice {0},Korisnik nije primijenio pravilo na računu {0}
DocType: GL Entry,Debit Amount in Account Currency,Debitna Iznos u valuti računa
DocType: Supplier Scorecard,Scoring Standings,Ocjenjivanje poretka
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Value,Vrijednost narudžbe
DocType: Certified Consultant,Certified Consultant,Ovlašteni konzultant
apps/erpnext/erpnext/config/accounting.py,Bank/Cash transactions against party or for internal transfer,Banka / Novac transakcije protiv stranke ili za internog transfera
DocType: Shipping Rule,Valid for Countries,Vrijedi za zemlje
apps/erpnext/erpnext/hr/doctype/training_event/training_event.py,End time cannot be before start time,Krajnje vrijeme ne može biti prije početka
apps/erpnext/erpnext/templates/generators/item/item_configure.js,1 exact match.,1 točno podudaranje.
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,"Ova točka je predložak i ne može se koristiti u prometu. Atributi artikl će biti kopirana u varijanti osim 'Ne Copy ""je postavljena"
DocType: Grant Application,Grant Application,Grant Application
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Total Order Considered,Ukupno Naručite Smatra
DocType: Certification Application,Not Certified,Nije ovjerena
DocType: Asset Value Adjustment,New Asset Value,Nova vrijednost imovine
DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,Stopa po kojoj Kupac valuta se pretvaraju u kupca osnovne valute
DocType: Course Scheduling Tool,Course Scheduling Tool,Naravno alat za raspoređivanje
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},"Red # {0}: Kupnja Račun, ne može se protiv postojećeg sredstva {1}"
DocType: Crop Cycle,LInked Analysis,LInked analiza
DocType: POS Closing Voucher,POS Closing Voucher,POS voucher za zatvaranje
apps/erpnext/erpnext/support/doctype/issue_priority/issue_priority.py,Issue Priority Already Exists,Prioritet izdanja već postoji
DocType: Invoice Discounting,Loan Start Date,Datum početka zajma
DocType: Contract,Lapsed,posrnuo
DocType: Item Tax Template Detail,Tax Rate,Porezna stopa
apps/erpnext/erpnext/education/doctype/course_activity/course_activity.py,Course Enrollment {0} does not exists,Upis na tečaj {0} ne postoji
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Application period cannot be across two allocation records,Razdoblje primjene ne može se nalaziti na dva zapisa o dodjeli
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,{0} already allocated for Employee {1} for period {2} to {3},{0} već dodijeljeno za zaposlenika {1} za vrijeme {2} {3}
DocType: Buying Settings,Backflush Raw Materials of Subcontract Based On,Na temelju sirovina povratne fluktuacije podugovaranja
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Purchase Invoice {0} is already submitted,Nabavni račun {0} je već podnesen
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Batch No must be same as {1} {2},Red # {0}: Batch Ne mora biti ista kao {1} {2}
DocType: Material Request Plan Item,Material Request Plan Item,Stavka plana materijala
DocType: Leave Type,Allow Encashment,Dopusti ulaganje
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to non-Group,Pretvori u ne-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,Duguje iznos
apps/erpnext/erpnext/accounts/party.py,There can only be 1 Account per Company in {0} {1},Tu može biti samo 1 račun po društvo u {0} {1}
DocType: Support Search Source,Response Result Key Path,Rezultat odgovora Ključni put
DocType: Journal Entry,Inter Company Journal Entry,Unos dnevnika Inter tvrtke
apps/erpnext/erpnext/accounts/party.py,Due Date cannot be before Posting / Supplier Invoice Date,Datum roka ne može biti prije datuma knjiženja / fakture dobavljača
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For quantity {0} should not be grater than work order quantity {1},Za veličinu {0} ne bi trebalo biti veće od količine radne narudžbe {1}
DocType: Employee Training,Employee Training,Obuka zaposlenika
DocType: Quotation Item,Additional Notes,dodatne napomene
DocType: Purchase Order,% Received,% Zaprimljeno
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Create Student Groups,Stvaranje grupe učenika
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Available quantity is {0}, you need {1}","Dostupna količina je {0}, treba vam {1}"
DocType: Volunteer,Weekends,Vikendi
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Credit Note Amount,Iznos uplate kredita
DocType: Setup Progress Action,Action Document,Akcijski dokument
DocType: Chapter Member,Website URL,Website URL
,Finished Goods,Gotovi proizvodi
DocType: Delivery Note,Instructions,Instrukcije
DocType: Quality Inspection,Inspected By,Pregledati
DocType: Asset,ACC-ASS-.YYYY.-,ACC-ASS-.YYYY.-
DocType: Asset Maintenance Log,Maintenance Type,Tip održavanja
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Course {2},{0} - {1} nije upisana u tečaj {2}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Name: ,Ime studenta:
DocType: POS Closing Voucher,Difference,Razlika
DocType: Delivery Settings,Delay between Delivery Stops,Odgoda između isporuke prestaje
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Serial No {0} does not belong to Delivery Note {1},Serijski Ne {0} ne pripada isporuke Napomena {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.","Čini se da postoji problem s konfiguracijom GoCardless poslužitelja. Ne brinite, u slučaju neuspjeha, iznos će biti vraćen 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 artikle
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Parametar provjere kvalitete proizvoda
DocType: Leave Application,Leave Approver Name,Ime osobe ovlaštene za odobrenje odsustva
DocType: Depreciation Schedule,Schedule Date,Raspored Datum
DocType: Amazon MWS Settings,FR,FR
DocType: Packed Item,Packed Item,Pakirani proizvod
DocType: Job Offer Term,Job Offer Term,Pojam ponude za posao
apps/erpnext/erpnext/config/buying.py,Default settings for buying transactions.,Zadane postavke za transakciju kupnje.
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,Activity Cost exists for Employee {0} against Activity Type - {1},Aktivnost Trošak postoji zaposlenom {0} protiv tip aktivnosti - {1}
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Get Students From,Obavezno polje - Get Students From
DocType: Program Enrollment,Enrolled courses,Upisani tečajevi
DocType: Currency Exchange,Currency Exchange,Mjenjačnica
apps/erpnext/erpnext/support/doctype/issue/issue.js,Resetting Service Level Agreement.,Ponovno postavljanje ugovora o razini usluge.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Item Name,Naziv proizvoda
DocType: Authorization Rule,Approving User  (above authorized value),Odobravanje korisnik (iznad ovlaštenog vrijednosti)
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Credit Balance,Kreditna bilanca
DocType: Employee,Widowed,Udovički
DocType: Request for Quotation,Request for Quotation,Zahtjev za ponudu
DocType: Healthcare Settings,Require Lab Test Approval,Potrebno odobrenje laboratorijskog ispitivanja
DocType: Attendance,Working Hours,Radnih sati
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Total Outstanding,Ukupno izvanredno
DocType: Naming Series,Change the starting / current sequence number of an existing series.,Promjena polaznu / tekući redni broj postojeće serije.
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.,"Postotak koji vam dopušta naplatu više u odnosu na naručeni iznos. Na primjer: Ako je vrijednost narudžbe za artikl 100 USD, a tolerancija postavljena na 10%, tada vam je dopušteno naplaćivanje 110 USD."
DocType: Dosage Strength,Strength,snaga
apps/erpnext/erpnext/public/js/controllers/transaction.js,Cannot find Item with this barcode,Stavka nije moguće pronaći s ovim barkodom
apps/erpnext/erpnext/accounts/page/pos/pos.js,Create a new Customer,Stvaranje novog kupca
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Expiring On,Istječe
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.","Ako više Cijene pravila i dalje prevladavaju, korisnici su zamoljeni da postavite prioritet ručno riješiti sukob."
apps/erpnext/erpnext/utilities/activation.py,Create Purchase Orders,Izrada narudžbenice
,Purchase Register,Popis nabave
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Patient not found,Pacijent nije pronađen
DocType: Landed Cost Item,Applicable Charges,Troškove u
DocType: Workstation,Consumable Cost,potrošni cost
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Response Time for {0} at index {1} can't be greater than Resolution Time.,Vrijeme odgovora za {0} u indeksu {1} ne može biti veće od vremena razlučivosti.
DocType: Purchase Receipt,Vehicle Date,Datum vozila
DocType: Campaign Email Schedule,Campaign Email Schedule,Raspored e-pošte kampanje
DocType: Student Log,Medical,Liječnički
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Drug,Odaberite Lijek
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Lead Owner cannot be same as the Lead,Olovo Vlasnik ne može biti ista kao i olova
DocType: Announcement,Receiver,Prijamnik
DocType: Location,Area UOM,Područje UOM
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,Workstation is closed on the following dates as per Holiday List: {0},Radna stanica je zatvorena na sljedeće datume po Holiday Popis: {0}
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Opportunities,Mogućnosti
apps/erpnext/erpnext/www/all-products/index.html,Clear filters,Očistite filtre
DocType: Lab Test Template,Single,Singl
DocType: Compensatory Leave Request,Work From Date,Rad s datumom
DocType: Salary Slip,Total Loan Repayment,Ukupno otplate kredita
DocType: Project User,View attachments,Pogledajte privitke
DocType: Account,Cost of Goods Sold,Troškovi prodane robe
DocType: Article,Publish Date,Datum objave
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please enter Cost Center,Unesite troška
DocType: Drug Prescription,Dosage,Doziranje
DocType: Journal Entry Account,Sales Order,Narudžba kupca
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Avg. Selling Rate,Prosječna prodajna cijena
DocType: Assessment Plan,Examiner Name,Naziv ispitivač
DocType: Lab Test Template,No Result,Nema rezultata
DocType: Woocommerce Settings,"The fallback series is ""SO-WOO-"".",Povratna serija je &quot;SO-WOO-&quot;.
DocType: Purchase Invoice Item,Quantity and Rate,Količina i stopa
DocType: Delivery Note,% Installed,% Instalirano
apps/erpnext/erpnext/utilities/user_progress.py,Classrooms/ Laboratories etc where lectures can be scheduled.,"Učionice / laboratoriji i sl, gdje predavanja može biti na rasporedu."
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Company currencies of both the companies should match for Inter Company Transactions.,Valute trgovačkih društava obje tvrtke trebale bi se podudarati s transakcijama tvrtke Inter.
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Please enter company name first,Unesite ime tvrtke prvi
DocType: Travel Itinerary,Non-Vegetarian,Ne-vegetarijanska
DocType: Purchase Invoice,Supplier Name,Dobavljač Ime
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Read the ERPNext Manual,Pročitajte ERPNext priručnik
DocType: HR Settings,Show Leaves Of All Department Members In Calendar,Prikaži lišće svih članova odjela u kalendaru
DocType: Purchase Invoice,01-Sales Return,01-Povratak prodaje
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Qty per BOM Line,Količina po BOM liniji
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,Temporarily on Hold,Privremeno na čekanju
DocType: Account,Is Group,Je grupe
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Credit Note {0} has been created automatically,Kreditna bilješka {0} izrađena je automatski
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Request for Raw Materials,Zahtjev za sirovine
DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Automatski Postavljanje Serijski broj na temelju FIFO
DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Provjerite Dobavljač Račun broj Jedinstvenost
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js,Primary Address Details,Primarni podaci o adresi
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Public token is missing for this bank,Javni token nedostaje za ovu banku
DocType: Vehicle Service,Oil Change,Promjena ulja
DocType: Leave Encashment,Leave Balance,Napusti ravnotežu
DocType: Asset Maintenance Log,Asset Maintenance Log,Zapisnik o održavanju imovine
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,'To Case No.' cannot be less than 'From Case No.','Za Predmet br' ne može biti manje od 'Od Predmeta br'
DocType: Certification Application,Non Profit,Neprofitno
DocType: Production Plan,Not Started,Ne pokrenuto
DocType: Lead,Channel Partner,Channel Partner
DocType: Account,Old Parent,Stari Roditelj
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Academic Year,Obavezno polje - akademska godina
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} is not associated with {2} {3},{0} {1} nije povezan s {2} {3}
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,You need to login as a Marketplace User before you can add any reviews.,"Prije nego što dodate bilo koju recenziju, morate se prijaviti kao korisnik Marketplacea."
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0} : Operation is required against the raw material item {1},Redak {0}: Potrebna je operacija prema stavci sirovine {1}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Please set default payable account for the company {0},Postavite zadani dugovni račun za tvrtku {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Transaction not allowed against stopped Work Order {0},Transakcija nije dopuštena protiv zaustavljene radne narudžbe {0}
DocType: Setup Progress Action,Min Doc Count,Min doktor grofa
apps/erpnext/erpnext/config/manufacturing.py,Global settings for all manufacturing processes.,Globalne postavke za sve proizvodne procese.
DocType: Accounts Settings,Accounts Frozen Upto,Računi Frozen Upto
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Day Book Data,Obradi podatke o dnevnim knjigama
DocType: SMS Log,Sent On,Poslan Na
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Incoming call from {0},Dolazni poziv od {0}
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute {0} selected multiple times in Attributes Table,Osobina {0} izabrani više puta u Svojstva tablice
DocType: HR Settings,Employee record is created using selected field. ,Zaposlenika rekord je stvorio pomoću odabranog polja.
DocType: Sales Order,Not Applicable,Nije primjenjivo
DocType: Amazon MWS Settings,UK,Velika Britanija
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Opening Invoice Item,Stavka fakture otvaranja fakture
DocType: Request for Quotation Item,Required Date,Potrebna Datum
DocType: Accounts Settings,Billing Address,Adresa za naplatu
DocType: Bank Statement Settings,Statement Headers,Izrazi Headers
DocType: Travel Request,Costing,Koštanje
DocType: Tax Rule,Billing County,županija naplate
DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Ako je označeno, iznos poreza će se smatrati već uključena u Print Rate / Ispis Iznos"
DocType: Request for Quotation,Message for Supplier,Poruka za dobavljača
DocType: BOM,Work Order,Radni nalog
DocType: Sales Invoice,Total Qty,Ukupna količina
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ID e-pošte Guardian2
DocType: Item,Show in Website (Variant),Prikaži u Web (Variant)
DocType: Employee,Health Concerns,Zdravlje Zabrinutost
DocType: Payroll Entry,Select Payroll Period,Odaberite Platne razdoblje
DocType: Purchase Invoice,Unpaid,Neplaćen
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sale,Rezervirano za prodaju
DocType: Packing Slip,From Package No.,Iz paketa broj
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Row #{0}: Payment document is required to complete the transaction,Redak # {0}: Dokument za plaćanje potreban je za dovršavanje transakcije
DocType: Item Attribute,To Range,U rasponu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Securities and Deposits,Vrijednosni papiri i depoziti
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",Nije moguće promijeniti način vrednovanja jer postoje transakcije protiv nekih stavki koje nemaju vlastitu metodu vrednovanja
DocType: Student Report Generation Tool,Attended by Parents,Prisustvovali su roditelji
apps/erpnext/erpnext/hr/doctype/shift_assignment/shift_assignment.py,Employee {0} has already applied for {1} on {2} : ,Zaposlenik {0} već je podnio zahtjev za {1} na {2}:
DocType: Inpatient Record,AB Positive,AB Pozitivan
DocType: Job Opening,Description of a Job Opening,Opis je otvaranju novih radnih mjesta
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Pending activities for today,Čekanju aktivnosti za danas
DocType: Salary Structure,Salary Component for timesheet based payroll.,Plaća Komponenta za timesheet temelju plaće.
DocType: Driver,Applicable for external driver,Primjenjivo za vanjske upravljačke programe
DocType: Sales Order Item,Used for Production Plan,Koristi se za plan proizvodnje
DocType: BOM,Total Cost (Company Currency),Ukupni trošak (valuta tvrtke)
DocType: Loan,Total Payment,ukupno plaćanja
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Cannot cancel transaction for Completed Work Order.,Nije moguće otkazati transakciju za dovršenu radnu nalog.
DocType: Manufacturing Settings,Time Between Operations (in mins),Vrijeme između operacije (u minutama)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,PO already created for all sales order items,PO već stvoren za sve stavke prodajnog naloga
DocType: Healthcare Service Unit,Occupied,okupiran
DocType: Clinical Procedure,Consumables,Potrošni
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js,Include Default Book Entries,Uključite zadane unose u knjige
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled so the action cannot be completed,{0} {1} je otkazana pa se radnja ne može dovršiti
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 planiranih količina: Količina za koju je radni nalog podizan, ali čeka se izrada."
DocType: Customer,Buyer of Goods and Services.,Kupac robe i usluga.
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,'employee_field_value' and 'timestamp' are required.,Obavezni su&#39;posleni_polovi_vrijednost &#39;i&#39; vremenska oznaka &#39;.
DocType: Journal Entry,Accounts Payable,Naplativi računi
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.,Iznos {0} postavljen u ovom zahtjevu za plaćanje razlikuje se od izračunatog iznosa svih planova plaćanja: {1}. Provjerite je li to ispravno prije slanja dokumenta.
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,Odabrane Sastavnice nisu za istu stavku
apps/erpnext/erpnext/stock/doctype/item_variant_settings/item_variant_settings.py,Cannot set the field <b>{0}</b> for copying in variants,Ne može se postaviti polje <b>{0}</b> za kopiranje u inačicama
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Item Code,Promijeni šifru stavke
DocType: Supplier Scorecard Standing,Notify Other,Obavijesti ostalo
DocType: Vital Signs,Blood Pressure (systolic),Krvni tlak (sistolički)
apps/erpnext/erpnext/controllers/buying_controller.py,{0} {1} is {2},{0} {1} je {2}
DocType: Item Price,Valid Upto,Vrijedi Upto
DocType: Leave Type,Expire Carry Forwarded Leaves (Days),Isteče prijenosni listovi (dani)
DocType: Training Event,Workshop,Radionica
DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Upozorite narudžbenice
apps/erpnext/erpnext/utilities/user_progress.py,List a few of your customers. They could be organizations or individuals.,Navedite nekoliko svojih kupaca. Oni mogu biti tvrtke ili fizičke osobe.
DocType: Employee Tax Exemption Proof Submission,Rented From Date,Najam od datuma
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Enough Parts to Build,Dosta Dijelovi za izgradnju
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Please save first,Prvo spremite
DocType: POS Profile User,POS Profile User,Korisnik POS profila
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Row {0}: Depreciation Start Date is required,Redak {0}: potreban je početni datum amortizacije
DocType: Purchase Invoice Item,Service Start Date,Datum početka usluge
DocType: Subscription Invoice,Subscription Invoice,Pretplatnička faktura
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Income,Izravni dohodak
DocType: Patient Appointment,Date TIme,Datum vrijeme
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"Can not filter based on Account, if grouped by Account","Ne možete filtrirati na temelju računa, ako je grupirano po računu"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Administrative Officer,Administrativni službenik
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Course,Odaberite Tečaj
DocType: Codification Table,Codification Table,Tablica kodifikacije
DocType: Timesheet Detail,Hrs,hrs
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Changes in {0},Promjene u {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Please select Company,Odaberite tvrtke
DocType: Employee Skill,Employee Skill,Vještina zaposlenika
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Difference Account,Račun razlike
DocType: Pricing Rule,Discount on Other Item,Popust na drugi artikl
DocType: Purchase Invoice,Supplier GSTIN,Dobavljač GSTIN
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,View Form,Pogledajte obrazac
DocType: Work Order,Additional Operating Cost,Dodatni trošak
DocType: Lab Test Template,Lab Routine,Laboratorijska rutina
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,Molimo odaberite Datum završetka za Dovršeni dnevnik održavanja imovine
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} is not the default supplier for any items.,{0} nije zadani dobavljač za bilo koju robu.
apps/erpnext/erpnext/stock/doctype/item/item.py,"To merge, following properties must be same for both items","Spojiti , ova svojstva moraju biti isti za obje stavke"
DocType: Supplier,Block Supplier,Blokirajte dobavljača
DocType: Shipping Rule,Net Weight,Neto težina
DocType: Job Opening,Planned number of Positions,Planirani broj pozicija
DocType: Employee,Emergency Phone,Telefon hitne službe
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,{0} {1} does not exist.,{0} {1} ne postoji.
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Buy,Kupiti
,Serial No Warranty Expiry,Istek jamstva serijskog broja
DocType: Sales Invoice,Offline POS Name,Offline POS Ime
DocType: Task,Dependencies,ovisnosti
apps/erpnext/erpnext/utilities/user_progress.py,Student Application,Studentska prijava
DocType: Bank Statement Transaction Payment Item,Payment Reference,Uputstvo za plaćanje
DocType: Supplier,Hold Type,Držite tip
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Please define grade for Threshold 0%,Definirajte ocjenu za Prag 0%
DocType: Bank Statement Transaction Payment Item,Bank Statement Transaction Payment Item,Stavka plaćanja transakcije bankovne izjave
DocType: Sales Order,To Deliver,Za isporuku
DocType: Purchase Invoice Item,Item,Proizvod
apps/erpnext/erpnext/healthcare/setup.py,High Sensitivity,Visoka osjetljivost
apps/erpnext/erpnext/config/non_profit.py,Volunteer Type information.,Informacije o volonteru.
DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Predložak za mapiranje novčanog toka
DocType: Travel Request,Costing Details,Pojedinosti o cijeni
apps/erpnext/erpnext/selling/report/sales_partner_transaction_summary/sales_partner_transaction_summary.js,Show Return Entries,Prikaži povratne unose
apps/erpnext/erpnext/accounts/page/pos/pos.js,Serial no item cannot be a fraction,Serijski nema stavke ne može biti dio
DocType: Journal Entry,Difference (Dr - Cr),Razlika ( dr. - Cr )
DocType: Bank Guarantee,Providing,pružanje
DocType: Account,Profit and Loss,Račun dobiti i gubitka
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","Nije dopušteno, konfigurirajte predložak laboratorija za testiranje prema potrebi"
DocType: Patient,Risk Factors,Faktori rizika
DocType: Patient,Occupational Hazards and Environmental Factors,Radna opasnost i čimbenici okoliša
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Stock Entries already created for Work Order ,Dionice već stvorene za radni nalog
apps/erpnext/erpnext/templates/pages/cart.html,See past orders,Pogledajte prošle narudžbe
apps/erpnext/erpnext/public/js/hub/pages/Selling.vue,{0} conversations,{0} razgovora
DocType: Vital Signs,Respiratory rate,Brzina dišnog sustava
apps/erpnext/erpnext/config/help.py,Managing Subcontracting,Upravljanje podugovaranje
DocType: Vital Signs,Body Temperature,Temperatura tijela
DocType: Project,Project will be accessible on the website to these users,Projekt će biti dostupan na web-stranici ovih korisnika
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},Ne mogu otkazati {0} {1} jer serijski broj {2} ne pripada skladištu {3}
DocType: Detected Disease,Disease,Bolest
DocType: Company,Default Deferred Expense Account,Zadani odgođeni raćun rashoda
apps/erpnext/erpnext/config/projects.py,Define Project type.,Definiraj vrstu projekta.
DocType: Supplier Scorecard,Weighting Function,Funkcija vaganja
DocType: Employee Tax Exemption Proof Submission,Total Actual Amount,Ukupni stvarni iznos
DocType: Healthcare Practitioner,OP Consulting Charge,OP Savjetodavna naknada
apps/erpnext/erpnext/utilities/user_progress.py,Setup your ,Postavi svoj
DocType: Student Report Generation Tool,Show Marks,Prikaži oznake
DocType: Support Settings,Get Latest Query,Dohvati najnoviji upit
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,Stopa po kojoj Cjenik valute se pretvaraju u tvrtke bazne valute
apps/erpnext/erpnext/setup/doctype/company/company.py,Account {0} does not belong to company: {1},Račun {0} ne pripada tvrtki: {1}
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation already used for another company,Naziv već koristi druga tvrtka
DocType: Selling Settings,Default Customer Group,Zadana grupa kupaca
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Payment Tems,Teme plaćanja
DocType: Employee,IFSC Code,IFSC kod
DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Ako onemogućite, &#39;Ukupno&#39; Zaobljeni polje neće biti vidljiv u bilo kojoj transakciji"
DocType: BOM,Operating Cost,Operativni troškovi
DocType: Crop,Produced Items,Proizvedene stavke
DocType: Bank Statement Transaction Entry,Match Transaction to Invoices,Podudaranje transakcije s fakturama
DocType: Sales Order Item,Gross Profit,Bruto dobit
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Unblock Invoice,Deblokiraj fakturu
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Increment cannot be 0,Prirast ne može biti 0
DocType: Company,Delete Company Transactions,Brisanje transakcije tvrtke
DocType: Production Plan Item,Quantity and Description,Količina i opis
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Reference No and Reference Date is mandatory for Bank transaction,Referentni broj i reference Datum obvezna je za banke transakcije
DocType: Purchase Receipt,Add / Edit Taxes and Charges,Dodaj / uredi porez i pristojbe
DocType: Payment Entry Reference,Supplier Invoice No,Dobavljač Račun br
DocType: Territory,For reference,Za referencu
DocType: Healthcare Settings,Appointment Confirmation,Potvrda imenovanja
DocType: Inpatient Record,HLC-INP-.YYYY.-,FHP-INP-.YYYY.-
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot delete Serial No {0}, as it is used in stock transactions","Ne možete izbrisati Serijski broj {0}, kao što se koristi na lageru transakcija"
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Closing (Cr),Zatvaranje (Cr)
DocType: Purchase Invoice,Registered Composition,Registrirani sastav
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html,Hello,zdravo
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Move Item,Premještanje stavke
DocType: Employee Incentive,Incentive Amount,Iznos poticaja
,Employee Leave Balance Summary,Sažetak stanja ravnoteže zaposlenika
DocType: Serial No,Warranty Period (Days),Jamstveni period (dani)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Total Credit/ Debit Amount should be same as linked Journal Entry,Ukupni iznos kredita / debitnog iznosa mora biti isti kao i povezani unos dnevnika
DocType: Installation Note Item,Installation Note Item,Napomena instalacije proizvoda
DocType: Production Plan Item,Pending Qty,U tijeku Kom
DocType: Budget,Ignore,Ignorirati
apps/erpnext/erpnext/accounts/party.py,{0} {1} is not active,{0} {1} nije aktivan
DocType: Woocommerce Settings,Freight and Forwarding Account,Račun za otpremu i prosljeđivanje
apps/erpnext/erpnext/config/accounting.py,Setup cheque dimensions for printing,Provjera postavljanje dimenzije za ispis
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Create Salary Slips,Stvorite plaće za sklizanje
DocType: Vital Signs,Bloated,Otečen
DocType: Salary Slip,Salary Slip Timesheet,Plaća proklizavanja timesheet
apps/erpnext/erpnext/controllers/buying_controller.py,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dobavljač skladišta obvezan je za sub - ugovoreni kupiti primitka
DocType: Item Price,Valid From,vrijedi od
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Your rating: ,Vaša ocjena:
DocType: Sales Invoice,Total Commission,Ukupno komisija
DocType: Tax Withholding Account,Tax Withholding Account,Račun za zadržavanje poreza
DocType: Pricing Rule,Sales Partner,Prodajni partner
apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Sve ocjene bodova dobavljača.
DocType: Buying Settings,Purchase Receipt Required,Primka je obvezna
DocType: Sales Invoice,Rail,željeznički
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Stvarna cijena
DocType: Item,Website Image,Slika web stranice
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Target warehouse in row {0} must be same as Work Order,Ciljno skladište u retku {0} mora biti isto kao i radni nalog
apps/erpnext/erpnext/stock/doctype/item/item.py,Valuation Rate is mandatory if Opening Stock entered,Vrednovanje stopa je obavezno ako Otvaranje Stock ušao
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,No records found in the Invoice table,Nisu pronađeni zapisi u tablici računa
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Please select Company and Party Type first,Odaberite Društvo i Zabava Tip prvi
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,"Already set default in pos profile {0} for user {1}, kindly disabled default","Već ste postavili zadani položaj u poziciji {0} za korisnika {1}, zadovoljavajući zadane postavke"
apps/erpnext/erpnext/config/accounting.py,Financial / accounting year.,Financijska / obračunska godina.
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js,Accumulated Values,Akumulirani Vrijednosti
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Sorry, Serial Nos cannot be merged","Žao nam je , Serial Nos ne mogu spojiti"
DocType: Shopify Settings,Customer Group will set to selected group while syncing customers from Shopify,Skupina kupaca postavit će se na odabranu skupinu prilikom sinkronizacije kupaca s Shopify
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Territory is Required in POS Profile,Teritorij je potreban u POS profilu
DocType: Supplier,Prevent RFQs,Spriječiti rasprave
DocType: Hub User,Hub User,Korisnik huba
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Salary Slip submitted for period from {0} to {1},Plaća poslana za razdoblje od {0} do {1}
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Passing Score value should be between 0 and 100,Vrijednost prolaska rezultata trebala bi biti između 0 i 100
DocType: Loyalty Point Entry Redemption,Redeemed Points,Otkupljene točke
,Lead Id,Id potencijalnog kupca
DocType: C-Form Invoice Detail,Grand Total,Ukupno za platiti
DocType: Assessment Plan,Course,naravno
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Section Code,Kod sekcije
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Valuation Rate required for Item {0} at row {1},Stopa vrednovanja potrebna za stavku {0} u retku {1}
DocType: Timesheet,Payslip,Payslip
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Pricing Rule {0} is updated,Pravilo cijene {0} se ažurira
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Half day date should be in between from date and to date,Poludnevni datum treba biti između datuma i do datuma
DocType: POS Closing Voucher,Expense Amount,Iznos troškova
apps/erpnext/erpnext/public/js/pos/pos.html,Item Cart,stavka Košarica
DocType: Quality Action,Resolution,Rezolucija
DocType: Employee,Personal Bio,Osobni biografija
DocType: C-Form,IV,IV
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Membership ID,ID čl
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Receive at Warehouse Entry,Primanje na ulazu u skladište
apps/erpnext/erpnext/templates/pages/material_request_info.html,Delivered: {0},Isporučuje se: {0}
DocType: QuickBooks Migrator,Connected to QuickBooks,Povezano s QuickBooksom
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please identify/create Account (Ledger) for type - {0},Identificirajte / kreirajte račun (knjigu) za vrstu - {0}
DocType: Bank Statement Transaction Entry,Payable Account,Obveze prema dobavljačima
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,You haven\,Niste \
DocType: Payment Entry,Type of Payment,Vrsta plaćanja
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date is mandatory,Poludnevni datum je obavezan
DocType: Sales Order,Billing and Delivery Status,Naplate i isporuke status
DocType: Job Applicant,Resume Attachment,Nastavi Prilog
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customers,Ponoviti kupaca
DocType: Leave Control Panel,Allocate,Dodijeliti
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variant,Izradi inačicu
DocType: Sales Invoice,Shipping Bill Date,Datum dostave računa
DocType: Production Plan,Production Plan,Plan proizvodnje
DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Otvaranje alata za izradu računa
DocType: Salary Component,Round to the Nearest Integer,Zaokružite na najbliži cijeli broj
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Povrat robe
DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Postavite količinu u transakcijama na temelju serijskog unosa
,Total Stock Summary,Ukupni zbroj dionica
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}.",Možete planirati samo do {0} slobodnih radnih mjesta i budžeta {1} \ for {2} po planu osoblja {3} za matičnu tvrtku {4}.
DocType: Announcement,Posted By,Objavio
apps/erpnext/erpnext/controllers/stock_controller.py,Quality Inspection required for Item {0} to submit,Inspekcija kvalitete potrebna je za predavanje predmeta {0}
DocType: Item,Delivered by Supplier (Drop Ship),Dostavlja Dobavljač (Drop Ship)
DocType: Healthcare Settings,Confirmation Message,Poruka o potvrdi
apps/erpnext/erpnext/config/crm.py,Database of potential customers.,Baza potencijalnih kupaca.
DocType: Authorization Rule,Customer or Item,Kupac ili predmeta
apps/erpnext/erpnext/config/crm.py,Customer database.,Baza kupaca.
DocType: Quotation,Quotation To,Ponuda za
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Middle Income,Srednji Prihodi
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Cr),Otvaranje ( 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.,"Zadana mjerna jedinica za točke {0} se ne može mijenjati izravno, jer ste već napravili neke transakcije (e) s drugim UOM. Morat ćete stvoriti novu stavku za korištenje drugačiji Default UOM."
DocType: Purchase Invoice,Overseas,preko mora
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Please set the Company,Postavite tvrtku
DocType: Share Balance,Share Balance,Dionički saldo
DocType: Amazon MWS Settings,AWS Access Key ID,ID ključa za pristup AWS-u
DocType: Employee Tax Exemption Declaration,Monthly House Rent,Mjesečni najam kuće
apps/erpnext/erpnext/projects/doctype/task/task_list.js,Set as Completed,Postavite kao dovršeno
DocType: Purchase Order Item,Billed Amt,Naplaćeno Amt
DocType: Training Result Employee,Training Result Employee,Obuku zaposlenika Rezultat
DocType: Warehouse,A logical Warehouse against which stock entries are made.,Kreirano Skladište za ulazne stavke
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Principal Amount,iznos glavnice
DocType: Loan Application,Total Payable Interest,Ukupno obveze prema dobavljačima kamata
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Outstanding: {0},Ukupno izvrsno: {0}
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Open Contact,Otvori kontakt
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},Reference Nema & Reference Datum je potrebno za {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Serial no(s) required for serialized item {0},Serijski brojevi potrebni za serijsku stavku {0}
DocType: Payroll Entry,Select Payment Account to make Bank Entry,Odaberite Račun za plaćanje kako bi Bank Entry
apps/erpnext/erpnext/config/accounting.py,Opening and Closing,Otvaranje i zatvaranje
DocType: Hotel Settings,Default Invoice Naming Series,Zadana serija za imenovanje faktura
apps/erpnext/erpnext/utilities/activation.py,"Create Employee records to manage leaves, expense claims and payroll","Stvaranje zaposlenika evidencije za upravljanje lišće, trošak tvrdnje i obračun plaća"
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,An error occurred during the update process,Došlo je do pogreške tijekom postupka ažuriranja
DocType: Restaurant Reservation,Restaurant Reservation,Rezervacija restorana
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Your Items,Vaše stavke
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal Writing,Pisanje prijedlog
DocType: Payment Entry Deduction,Payment Entry Deduction,Plaćanje Ulaz Odbitak
DocType: Service Level Priority,Service Level Priority,Prioritet na razini usluge
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Wrapping up,Završavati
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Notify Customers via Email,Obavijesti korisnike putem e-pošte
DocType: Item,Batch Number Series,Serije brojeva serije
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,Another Sales Person {0} exists with the same Employee id,Još jedna prodaja Osoba {0} postoji s istim ID zaposlenika
DocType: Employee Advance,Claimed Amount,Zahtjev za iznos potraživanja
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.js,Expire Allocation,Isteče dodjela
DocType: QuickBooks Migrator,Authorization Settings,Postavke autorizacije
DocType: Travel Itinerary,Departure Datetime,Datum odlaska
apps/erpnext/erpnext/hub_node/api.py,No items to publish,Nema stavki za objavljivanje
DocType: Customer,CUST-.YYYY.-,Prilagodi-.YYYY.-
DocType: Travel Request Costing,Travel Request Costing,Trošak zahtjeva za putovanje
apps/erpnext/erpnext/config/healthcare.py,Masters,Masteri
DocType: Employee Onboarding,Employee Onboarding Template,Predložak Onboardinga zaposlenika
DocType: Assessment Plan,Maximum Assessment Score,Maksimalni broj bodova Procjena
apps/erpnext/erpnext/config/accounting.py,Update Bank Transaction Dates,Transakcijski Termini Update banke
apps/erpnext/erpnext/config/projects.py,Time Tracking,praćenje vremena
DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLICATE ZA TRANSPORTER
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Row {0}# Paid Amount cannot be greater than requested advance amount,Redak {0} # Plaćeni iznos ne može biti veći od traženog predujma
DocType: Fiscal Year Company,Fiscal Year Company,Fiskalna godina - tvrtka
DocType: Packing Slip Item,DN Detail,DN detalj
DocType: Training Event,Conference,Konferencija
DocType: Employee Grade,Default Salary Structure,Zadana struktura plaća
DocType: Stock Entry,Send to Warehouse,Pošalji u skladište
apps/erpnext/erpnext/hr/report/daily_work_summary_replies/daily_work_summary_replies.py,Replies,Odgovori
DocType: Timesheet,Billed,Naplaćeno
DocType: Batch,Batch Description,Batch Opis
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Creating student groups,Stvaranje studentskih skupina
apps/erpnext/erpnext/accounts/utils.py,"Payment Gateway Account not created, please create one manually.","Payment Gateway računa nije stvorio, ručno stvoriti jedan."
DocType: Supplier Scorecard,Per Year,Godišnje
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Not eligible for the admission in this program as per DOB,Ne ispunjavaju uvjete za prijem u ovaj program po DOB-u
DocType: Sales Invoice,Sales Taxes and Charges,Prodaja Porezi i naknade
DocType: Supplier Scorecard Period,PU-SSP-.YYYY.-,PU SSP-.YYYY.-
DocType: Vital Signs,Height (In Meter),Visina (u mjeraču)
DocType: Student,Sibling Details,polubrat Detalji
DocType: Vehicle Service,Vehicle Service,usluga vozila
DocType: Employee,Reason for Resignation,Razlog za ostavku
DocType: Sales Invoice,Credit Note Issued,Odobrenje kupcu izdano
DocType: Task,Weight,Težina
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Račun / Temeljnica Detalji
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,{0} bank transaction(s) created,{0} stvorene bankovne transakcije
apps/erpnext/erpnext/accounts/utils.py,{0} '{1}' not in Fiscal Year {2},{0} '{1}' nije u fiskalnoj godini {2}
DocType: Buying Settings,Settings for Buying Module,Postavke za kupnju modula
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Asset {0} does not belong to company {1},Imovina {0} ne pripada društvu {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter Purchase Receipt first,Unesite prvo primku
DocType: Buying Settings,Supplier Naming By,Dobavljač nazivanje
DocType: Activity Type,Default Costing Rate,Zadana Obračun troškova stopa
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Maintenance Schedule,Raspored održavanja
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.","Cjenovna pravila filtriraju se na temelju kupca, grupe kupaca, regije, dobavljača, proizvođača, kampanje, prodajnog partnera i sl."
DocType: Employee Promotion,Employee Promotion Details,Pojedinosti o promociji zaposlenika
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Inventory,Neto promjena u inventar
DocType: Employee,Passport Number,Broj putovnice
DocType: Invoice Discounting,Accounts Receivable Credit Account,Račun za naplatu potraživanja
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian2,Odnos s Guardian2
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Manager,Upravitelj
DocType: Payment Entry,Payment From / To,Plaćanje Od / Do
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,From Fiscal Year,Od fiskalne godine
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},Novi kreditni limit je manja od trenutne preostali iznos za kupca. Kreditni limit mora biti atleast {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please set account in Warehouse {0},Postavite račun u skladištu {0}
apps/erpnext/erpnext/controllers/trends.py,'Based On' and 'Group By' can not be same,'Temelji se na' i 'Grupiranje po' ne mogu biti isti
DocType: Sales Person,Sales Person Targets,Prodajni plan prodavača
DocType: GSTR 3B Report,December,prosinac
DocType: Work Order Operation,In minutes,U minuta
DocType: Production Plan,"If enabled, then system will create the material even if the raw materials are available","Ako je omogućeno, tada će sustav stvoriti materijal čak i ako su sirovine dostupne"
apps/erpnext/erpnext/templates/pages/cart.html,See past quotations,Pogledajte dosadašnje citate
DocType: Issue,Resolution Date,Rezolucija Datum
DocType: Lab Test Template,Compound,Spoj
DocType: Opportunity,Probability (%),Vjerojatnost (%)
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Dispatch Notification,Obavijest o otpremi
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Select Property,Odaberite Svojstva
DocType: Course Activity,Course Activity,Aktivnost tečaja
DocType: Student Batch Name,Batch Name,Batch Name
DocType: Fee Validity,Max number of visit,Maksimalni broj posjeta
DocType: Accounting Dimension Detail,Mandatory For Profit and Loss Account,Obvezno za račun dobiti i gubitka
,Hotel Room Occupancy,Soba za boravak hotela
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please set default Cash or Bank account in Mode of Payment {0},Molimo postavite zadanu gotovinom ili banka računa u načinu plaćanja {0}
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Enroll,Upisati
DocType: GST Settings,GST Settings,Postavke GST-a
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Currency should be same as Price List Currency: {0},Valuta bi trebala biti ista kao i Cjenik Valuta: {0}
DocType: Selling Settings,Customer Naming By,Imenovanje kupca prema
DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Pokazat će student prisutan u Studentskom Mjesečni Attendance Report
DocType: Depreciation Schedule,Depreciation Amount,Amortizacija Iznos
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to Group,Pretvori u Grupi
DocType: Activity Cost,Activity Type,Tip aktivnosti
DocType: Request for Quotation,For individual supplier,Za pojedinog opskrbljivača
DocType: BOM Operation,Base Hour Rate(Company Currency),Baza Sat stopa (Društvo valuta)
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Isporučeno Iznos
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Količina rezervirane za proizvodnju: Količina sirovina za izradu proizvodnih predmeta.
DocType: Loyalty Point Entry Redemption,Redemption Date,Datum otkupa
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Ova je bankovna transakcija već u potpunosti usklađena
DocType: Sales Invoice,Packing List,Popis pakiranja
apps/erpnext/erpnext/config/buying.py,Purchase Orders given to Suppliers.,Narudžbenice poslane dobavljačima
DocType: Contract,Contract Template,Predložak ugovora
DocType: Clinical Procedure Item,Transfer Qty,Količina prijenosa
DocType: Purchase Invoice Item,Asset Location,Lokacija imovine
apps/erpnext/erpnext/projects/report/billing_summary.py, From Date can not be greater than To Date,Od Datum ne može biti veći od Do Dana
DocType: Tax Rule,Shipping Zipcode,Dostava poštanski broj
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Publishing,objavljivanje
DocType: Accounts Settings,Report Settings,Postavke izvješća
DocType: Activity Cost,Projects User,Projekti za korisnike
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Consumed,Konzumira
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,{0}: {1} not found in Invoice Details table,{0}: {1} nije pronađen u Pojedinosti dostavnice stolu
DocType: Asset,Asset Owner Company,Tvrtka vlasnika imovine
DocType: Company,Round Off Cost Center,Zaokružiti troška
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Održavanje Posjetite {0} mora biti otkazana prije poništenja ovu prodajnog naloga
apps/erpnext/erpnext/templates/pages/help.html,What do you need help with?,Što vam je potrebna pomoć?
DocType: Employee Checkin,Shift Start,Shift Start
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Material Transfer,Transfer robe
DocType: Cost Center,Cost Center Number,Broj mjesta troška
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py,Could not find path for ,Nije moguće pronaći put
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Dr),Otvaranje (DR)
DocType: Compensatory Leave Request,Work End Date,Datum završetka radnog vremena
DocType: Loan,Applicant,podnositelj zahtjeva
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Posting timestamp must be after {0},Vremenska oznaka knjiženja mora biti nakon {0}
,GST Itemised Purchase Register,Registar kupnje artikala GST
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is a limited liability company,Primjenjivo ako je društvo s ograničenom odgovornošću
DocType: Course Scheduling Tool,Reschedule,napraviti nov raspored
DocType: Item Tax Template,Item Tax Template,Predložak poreza na stavku
DocType: Loan,Total Interest Payable,Ukupna kamata
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for Hold,Razlog zadržavanja
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Porezi i pristojbe zavisnog troška
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,Redak {0}: Postavite razlog oslobađanja od poreza u porezima i naknadama na promet
DocType: Quality Goal Objective,Quality Goal Objective,Cilj kvaliteta kvalitete
DocType: Work Order Operation,Actual Start Time,Stvarni Vrijeme početka
DocType: Purchase Invoice Item,Deferred Expense Account,Odgođeni raćun rashoda
DocType: BOM Operation,Operation Time,Operacija vrijeme
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Finish,Završi
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Base,Baza
DocType: Timesheet,Total Billed Hours,Ukupno Naplaćene sati
DocType: Pricing Rule Item Group,Pricing Rule Item Group,Skupina stavki pravila o cijenama
DocType: Travel Itinerary,Travel To,Putovati u
apps/erpnext/erpnext/config/accounting.py,Exchange Rate Revaluation master.,Master master revalorizacije tečaja
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Write Off Amount,Napišite paušalni iznos
DocType: Leave Block List Allow,Allow User,Dopusti korisnika
DocType: Journal Entry,Bill No,Bill Ne
DocType: Company,Gain/Loss Account on Asset Disposal,Dobitak / Gubitak računa na sredstva Odlaganje
DocType: Vehicle Log,Service Details,Pojedinosti usluge
DocType: Lab Test Template,Grouped,grupirane
DocType: Selling Settings,Delivery Note Required,Potrebna je otpremnica
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Submitting Salary Slips...,Slanje nagrada za plaće ...
DocType: Bank Guarantee,Bank Guarantee Number,Broj bankarske garancije
DocType: Assessment Criteria,Assessment Criteria,Kriteriji za ocjenjivanje
DocType: BOM Item,Basic Rate (Company Currency),Osnovna stopa (valuta tvrtke)
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","Tijekom stvaranja računa za podmlađivanje Company {0}, nadređeni račun {1} nije pronađen. Napravite nadređeni račun u odgovarajućem COA"
apps/erpnext/erpnext/support/doctype/issue/issue.js,Split Issue,Split Issue
DocType: Student Attendance,Student Attendance,Studentski Gledatelja
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,No data to export,Nema podataka za izvoz
DocType: Sales Invoice Timesheet,Time Sheet,Vrijeme list
DocType: Manufacturing Settings,Backflush Raw Materials Based On,Jedinice za pranje sirovine na temelju
DocType: Sales Invoice,Port Code,Portski kod
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reserve Warehouse,Rezervni skladište
DocType: Lead,Lead is an Organization,Olovo je organizacija
DocType: Guardian Interest,Interest,Interes
apps/erpnext/erpnext/accounts/doctype/tax_category/tax_category_dashboard.py,Pre Sales,Pretprodaja
DocType: Instructor Log,Other Details,Ostali detalji
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,Stvarni datum isporuke
DocType: Lab Test,Test Template,Predložak testa
DocType: Restaurant Order Entry Item,Served,Posluženo
apps/erpnext/erpnext/config/non_profit.py,Chapter information.,Podaci o poglavlju.
DocType: Account,Accounts,Računi
DocType: Vehicle,Odometer Value (Last),Odometar vrijednost (zadnja)
apps/erpnext/erpnext/config/buying.py,Templates of supplier scorecard criteria.,Predlošci kriterija dobavljača bodova.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Marketing,Marketing
DocType: Sales Invoice,Redeem Loyalty Points,Iskoristite bodove lojalnosti
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry is already created,Ulazak Plaćanje je već stvorio
DocType: Request for Quotation,Get Suppliers,Nabavite dobavljače
DocType: Purchase Receipt Item Supplied,Current Stock,Trenutačno stanje skladišta
DocType: Pricing Rule,System will notify to increase or decrease quantity or amount ,Sustav će obavijestiti da poveća ili smanji količinu ili količinu
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} does not linked to Item {2},Red # {0}: Imovina {1} ne povezan s točkom {2}
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Preview Salary Slip,Pregled Plaća proklizavanja
apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Napravite časopis
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Račun {0} unesen više puta
DocType: Account,Expenses Included In Valuation,Troškovi uključeni u vrednovanje
apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Možete obnoviti pretplatu samo ako vaše članstvo istekne u roku od 30 dana
DocType: Shopping Cart Settings,Show Stock Availability,Prikaži raspoloživa roba
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Postavite {0} u kategoriji imovine {1} ili tvrtku {2}
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per section 17(5),Prema odjeljku 17 (5)
DocType: Location,Longitude,dužina
,Absent Student Report,Odsutni Student Report
DocType: Crop,Crop Spacing UOM,Obrezivanje razmaka UOM
DocType: Loyalty Program,Single Tier Program,Program jednog stupnja
DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,Odaberite samo ako imate postavke dokumenata Cash Flow Mapper
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Address 1,Od adrese 1
DocType: Email Digest,Next email will be sent on:,Sljedeći email će biti poslan na:
DocType: Supplier Scorecard,Per Week,Tjedno
apps/erpnext/erpnext/stock/doctype/item/item.py,Item has variants.,Stavka ima varijante.
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Total Student,Ukupno učenika
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Item {0} not found,Stavka {0} nije pronađena
DocType: Bin,Stock Value,Stock vrijednost
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Duplicate {0} found in the table,Duplikat {0} pronađen u tablici
apps/erpnext/erpnext/accounts/doctype/account/account.py,Company {0} does not exist,Tvrtka {0} ne postoji
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} has fee validity till {1},{0} ima valjanost do {1}
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Tree Type,Tree Type
DocType: Leave Control Panel,Employee Grade (optional),Stupanj zaposlenika (izborno)
DocType: Pricing Rule,Apply Rule On Other,Primijenite Pravilo na ostalo
DocType: BOM Explosion Item,Qty Consumed Per Unit,Količina potrošena po jedinici mjere
DocType: Shift Type,Late Entry Grace Period,Kasno razdoblje prijava
DocType: GST Account,IGST Account,IGST račun
DocType: Serial No,Warranty Expiry Date,Datum isteka jamstva
DocType: Material Request Item,Quantity and Warehouse,Količina i skladišta
DocType: Sales Invoice,Commission Rate (%),Komisija stopa (%)
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Program,Odaberite Program
DocType: Project,Estimated Cost,Procjena cijene
DocType: Request for Quotation,Link to material requests,Link na materijalnim zahtjevima
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Publish,Objaviti
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Aerospace,Zračno-kosmički prostor
,Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC]
DocType: Journal Entry,Credit Card Entry,Credit Card Stupanje
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,u vrijednost
DocType: Asset Settings,Depreciation Options,Opcije amortizacije
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Either location or employee must be required,Moraju se tražiti lokacija ili zaposlenik
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Create Employee,Stvorite zaposlenika
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid Posting Time,Nevažeće vrijeme knjiženja
DocType: Salary Component,Condition and Formula,Stanje i Formula
DocType: Lead,Campaign Name,Naziv kampanje
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,There is no leave period in between {0} and {1},Ne postoji razdoblje odmora između {0} i {1}
DocType: Fee Validity,Healthcare Practitioner,Zdravstveni praktičar
DocType: Hotel Room,Capacity,Kapacitet
DocType: Travel Request Costing,Expense Type,Vrsta troška
DocType: Selling Settings,Close Opportunity After Days,Zatvori Prilika Nakon dana
,Reserved,Rezervirano
DocType: Driver,License Details,Detalji licence
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field From Shareholder cannot be blank,Polje Od Dioničara ne može biti prazno
DocType: Leave Allocation,Allocation,namjena
DocType: Purchase Order,Supply Raw Materials,Supply sirovine
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Structures have been assigned successfully,Strukture su uspješno dodijeljene
apps/erpnext/erpnext/config/getting_started.py,Create Opening Sales and Purchase Invoices,Izradite otvaranje računa za prodaju i kupnju
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Current Assets,Dugotrajna imovina
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,{0} is not a stock Item,{0} nije skladišni proizvod
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',"Podijelite svoje povratne informacije s obukom klikom na &quot;Povratne informacije o treningu&quot;, a zatim &quot;Novo&quot;"
DocType: Call Log,Caller Information,Informacije o pozivaocu
DocType: Mode of Payment Account,Default Account,Zadani račun
apps/erpnext/erpnext/stock/doctype/item/item.py,Please select Sample Retention Warehouse in Stock Settings first,Najprije odaberite Pohrana skladišta za uzorke u zalihama
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,Please select the Multiple Tier Program type for more than one collection rules.,Odaberite višestruki tip programa za više pravila za naplatu.
DocType: Payment Entry,Received Amount (Company Currency),Primljeni Iznos (Društvo valuta)
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Cancelled. Please check your GoCardless Account for more details,Plaćanje je otkazano. Više pojedinosti potražite u svojem računu za GoCardless
DocType: Work Order,Skip Material Transfer to WIP Warehouse,Preskočite prijenos materijala u WIP skladište
DocType: Contract,N/A,N / A
DocType: Task Type,Task Type,Vrsta zadatka
DocType: Topic,Topic Content,Sadržaj teme
DocType: Delivery Settings,Send with Attachment,Pošalji s privitkom
DocType: Service Level,Priorities,prioriteti
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py,Please select weekly off day,Odaberite tjednik off dan
DocType: Inpatient Record,O Negative,Negativan
DocType: Work Order Operation,Planned End Time,Planirani End Time
DocType: POS Profile,Only show Items from these Item Groups,Prikažite samo stavke iz ovih grupa predmeta
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction cannot be converted to ledger,Račun s postojećom transakcijom ne može se pretvoriti u glavnu knjigu
apps/erpnext/erpnext/config/non_profit.py,Memebership Type Details,Pojedinosti o vrstama kontakata
DocType: Delivery Note,Customer's Purchase Order No,Kupca Narudžbenica br
DocType: Clinical Procedure,Consume Stock,Potrošnja
DocType: Budget,Budget Against,proračun protiv
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Lost Reasons,Izgubljeni razlozi
apps/erpnext/erpnext/stock/reorder_item.py,Auto Material Requests Generated,Automatski zahtjev za materijalom odobren
DocType: Shift Type,Working hours below which Half Day is marked. (Zero to disable),Radno vrijeme ispod kojeg se obilježava Polovna dana. (Nula za onemogućavanje)
DocType: Job Card,Total Completed Qty,Ukupno završeno Količina
DocType: HR Settings,Auto Leave Encashment,Automatski napustite enkaš
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js,Lost,Izgubljen
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,You can not enter current voucher in 'Against Journal Entry' column,Ne možete unijeti trenutni nalog u stupac 'u odnosu na temeljnicu'
DocType: Employee Benefit Application Detail,Max Benefit Amount,Iznos maksimalne isplate
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for manufacturing,Rezervirano za proizvodnju
DocType: Soil Texture,Sand,Pijesak
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Energy,energija
DocType: Opportunity,Opportunity From,Prilika od
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Redak {0}: {1} Serijski brojevi potrebni za stavku {2}. Naveli ste {3}.
apps/erpnext/erpnext/controllers/accounts_controller.py,Cannot set quantity less than delivered quantity,Ne može se postaviti količina manja od isporučene količine
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please select a table,Odaberite tablicu
DocType: BOM,Website Specifications,Web Specifikacije
apps/erpnext/erpnext/accounts/doctype/account/account.py,Please add the account to root level Company - %s,Dodajte račun u korijensku tvrtku -% s
DocType: Content Activity,Content Activity,Sadržajna aktivnost
DocType: Special Test Items,Particulars,Pojedinosti
DocType: Employee Checkin,Employee Checkin,Checkin zaposlenik
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0}: From {0} of type {1},{0}: Od {0} od tipa {1}
apps/erpnext/erpnext/config/crm.py,Sends Mails to lead or contact based on a Campaign schedule,Šalje poruke e-pošte koja vodi ili kontaktira na temelju rasporeda kampanje
apps/erpnext/erpnext/controllers/selling_controller.py,Row {0}: Conversion Factor is mandatory,Red {0}: pretvorbe Factor je obvezno
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}","Više Pravila Cijena postoji sa istim kriterijima, molimo rješavanje sukoba dodjeljivanjem prioriteta. Pravila Cijena: {0}"
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation Account,Račun revalorizacije tečaja
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Min Amt can not be greater than Max Amt,Min Amt ne može biti veći od Max Amt
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Cannot deactivate or cancel BOM as it is linked with other BOMs,Ne može deaktivirati ili otkazati BOM kao što je povezano s drugim sastavnicama
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Please select Company and Posting Date to getting entries,Odaberite unos za tvrtku i datum knjiženja
DocType: Asset,Maintenance,Održavanje
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Get from Patient Encounter,Dobiti od Patient Encounter
DocType: Subscriber,Subscriber,Pretplatnik
DocType: Item Attribute Value,Item Attribute Value,Stavka Vrijednost atributa
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,Currency Exchange must be applicable for Buying or for Selling.,Mjenjač mora biti primjenjiv za kupnju ili prodaju.
apps/erpnext/erpnext/hr/doctype/leave_ledger_entry/leave_ledger_entry.py,Only expired allocation can be cancelled,Samo je istekla dodjela istekla
DocType: Item,Maximum sample quantity that can be retained,Maksimalna količina uzorka koja se može zadrž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},Red {0} # Stavka {1} ne može se prenijeti više od {2} od narudžbenice {3}
apps/erpnext/erpnext/config/crm.py,Sales campaigns.,Prodajne kampanje.
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Unknown Caller,Nepoznati pozivatelj
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.","Standardni porez predložak koji se može primijeniti na sve prodajnih transakcija. Ovaj predložak može sadržavati popis poreznih glava, a također ostali rashodi / dohotka glave poput ""brodova"", ""osiguranje"", ""Rukovanje"" itd 

 #### Napomena 

 stopa poreza na vas definirati ovdje će biti standardna stopa poreza za sve ** Opcije **. Ako postoje ** Predmeti ** koji imaju različite cijene, one moraju biti dodan u ** točke poreza ** stol u ** točke ** majstora.

 #### Opis Kolumne 

 1. Vrsta Proračun: 
 - To može biti na ** Neto Ukupno ** (to je zbroj osnovnog iznosa).
 - ** U odnosu na prethodnu Row ukupno / Iznos ** (za kumulativne poreza ili troškova). Ako odaberete ovu opciju, porez će se primjenjivati postotak prethodnog reda (u poreznom sustavu) iznos ili ukupno.
 - ** Stvarni ** (kao što je navedeno).
 2. Voditelj račun: knjiga računa pod kojima se ovaj porez će biti rezervirano 
 3. Trošak Centar: Ako porezni / naboj je prihod (kao što su utovar) i rashoda treba biti rezervirano protiv troška.
 4. Opis: Opis poreza (koji će se tiskati u račune / citati).
 5. Rate: Porezna stopa.
 6. Iznos: Iznos poreza.
 7. Ukupno: Kumulativna ukupno do ove točke.
 8. Unesite Row: Ako na temelju ""prethodnog retka Ukupno"" možete odabrati broj retka koji će se uzeti kao osnova za ovaj izračun (zadana je prethodni redak).
 9. Je li taj porez uključen u osnovna stopa ?: Ako ste to provjerili, to znači da je taj porez neće biti prikazani ispod točke stola, nego će biti uključeni u osnovne stope u glavnom točkom stolu. To je korisno kada želite dati stan cijenu (uključujući sve poreze) cijene za kupce."
DocType: Quality Action,Corrective,korektiv
DocType: Employee,Bank A/C No.,Bankovni  A/C br.
DocType: Quality Inspection Reading,Reading 7,Čitanje 7
DocType: Purchase Invoice,UIN Holders,Držači UIN-a
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Ordered,djelomično Ž
DocType: Lab Test,Lab Test,Lab Test
DocType: Student Report Generation Tool,Student Report Generation Tool,Alat za generiranje izvještaja studenata
DocType: Healthcare Schedule Time Slot,Healthcare Schedule Time Slot,Raspored sati za zdravstvenu skrb
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Name,Doc ime
DocType: Expense Claim Detail,Expense Claim Type,Rashodi Vrsta polaganja
DocType: Shopping Cart Settings,Default settings for Shopping Cart,Zadane postavke za Košarica
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Save Item,Spremi stavku
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Expense,Novi trošak
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Ignore Existing Ordered Qty,Zanemari postojeće naručene količine
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Timeslots,Dodaj vremenske brojeve
apps/erpnext/erpnext/stock/__init__.py,Please set Account in Warehouse {0} or Default Inventory Account in Company {1},Postavite račun u skladištu {0} ili zadani račun oglasnog prostora u tvrtki {1}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset scrapped via Journal Entry {0},Imovine otpisan putem Temeljnica {0}
DocType: Loan,Interest Income Account,Prihod od kamata računa
DocType: Bank Transaction,Unreconciled,nesaglašen
DocType: Shift Type,Allow check-out after shift end time (in minutes),Dopuštanje odjave nakon završetka vremena smjene (u minutama)
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Max benefits should be greater than zero to dispense benefits,Maksimalne koristi bi trebale biti veće od nule kako bi se oslobodile prednosti
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py,Review Invitation Sent,Pregledajte pozivnicu poslanu
DocType: Shift Assignment,Shift Assignment,Dodjela smjene
DocType: Employee Transfer Property,Employee Transfer Property,Vlasništvo prijenosa zaposlenika
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field Equity/Liability Account cannot be blank,Polje na računu glavnice / odgovornosti ne može biti prazno
apps/erpnext/erpnext/accounts/doctype/cashier_closing/cashier_closing.py,From Time Should Be Less Than To Time,Iz vremena treba biti manje od vremena
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}.",Stavka {0} (serijski broj: {1}) ne može se potrošiti jer je rezervirano za ispunjavanje prodajnog naloga {2}.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Maintenance Expenses,Troškovi održavanja ureda
,BOM Explorer,BOM Explorer
apps/erpnext/erpnext/utilities/user_progress.py,Go to ,Ići
DocType: Shopify Settings,Update Price from Shopify To ERPNext Price List,Ažurirajte cijenu od Shopify do ERPNext Cjenik
apps/erpnext/erpnext/config/help.py,Setting up Email Account,Postavljanje račun e-pošte
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Please enter Item first,Unesite predmeta prvi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Needs Analysis,Analiza potreba
DocType: Asset Repair,Downtime,Prekid rada
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}.,Kažnjeni Iznos ne može biti veći od Zahtjeva Iznos u nizu {0}.
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Academic Term: ,Akademski naziv:
DocType: Salary Detail,Do not include in total,Ne uključujte ukupno
DocType: Quiz Activity,Quiz Activity,Aktivnost kviza
DocType: Company,Default Cost of Goods Sold Account,Zadana vrijednost prodane robe računa
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Sample quantity {0} cannot be more than received quantity {1},Uzorak {0} ne može biti veći od primljene količine {1}
apps/erpnext/erpnext/stock/get_item_details.py,Price List not selected,Popis Cijena ne bira
DocType: Employee,Family Background,Obitelj Pozadina
DocType: Request for Quotation Supplier,Send Email,Pošaljite e-poštu
DocType: Quality Goal,Weekday,radni dan
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid Attachment {0},Upozorenje: Invalid Prilog {0}
DocType: Item,Max Sample Quantity,Maksimalna količina uzorka
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,No Permission,Nemate dopuštenje
DocType: Contract Fulfilment Checklist,Contract Fulfilment Checklist,Kontrolni popis ispunjavanja ugovora
DocType: Vital Signs,Heart Rate / Pulse,Puls / srčane frekvencije
DocType: Supplier,Default Bank Account,Zadani bankovni račun
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"To filter based on Party, select Party Type first","Za filtriranje se temelji na stranke, odaberite stranka Upišite prvi"
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,'Update Stock' can not be checked because items are not delivered via {0},Opcija 'Ažuriraj zalihe' nije dostupna jer stavke nisu dostavljene putem {0}
DocType: Vehicle,Acquisition Date,Datum akvizicije
apps/erpnext/erpnext/regional/italy/utils.py,Nos,kom
DocType: Item,Items with higher weightage will be shown higher,Stavke sa višim weightage će se prikazati više
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py,Lab Tests and Vital Signs,Lab testovi i vitalni znakovi
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Banka Pomirenje Detalj
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} must be submitted,Red # {0}: Imovina {1} mora biti predana
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,No employee found,Nisu pronađeni zaposlenici
DocType: Supplier Quotation,Stopped,Zaustavljen
DocType: Item,If subcontracted to a vendor,Ako podugovoren dobavljaču
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Student Group is already updated.,Studentska grupa je već ažurirana.
apps/erpnext/erpnext/config/projects.py,Project Update.,Ažuriranje projekta.
DocType: SMS Center,All Customer Contact,Svi kontakti kupaca
DocType: Location,Tree Details,stablo Detalji
DocType: Marketplace Settings,Registered,zabilježen
DocType: Training Event,Event Status,Status događaja
DocType: Volunteer,Availability Timeslot,Dostupnost vremena
apps/erpnext/erpnext/config/support.py,Support Analytics,Analitike podrške
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,"If you have any questions, please get back to us.","Ako imate bilo kakvih pitanja, molimo vratite se u nas."
DocType: Cash Flow Mapper,Cash Flow Mapper,Mapper novčanog toka
DocType: Item,Website Warehouse,Skladište web stranice
DocType: Payment Reconciliation,Minimum Invoice Amount,Minimalni iznos fakture
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Troškovno mjesto {2} ne pripada Društvu {3}
apps/erpnext/erpnext/www/lms/program.py,Program {0} does not exist.,Program {0} ne postoji.
apps/erpnext/erpnext/utilities/user_progress.py,Upload your letter head (Keep it web friendly as 900px by 100px),Prenesite glavu slova (Držite ga prijateljskim webom kao 900 piksela za 100 px)
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} cannot be a Group,{0} {1}: Račun {2} ne može biti grupa
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Timesheet {0} is already completed or cancelled,Timesheet {0} već je završen ili otkazan
DocType: QuickBooks Migrator,QuickBooks Migrator,Migrator za QuickBooks
apps/erpnext/erpnext/templates/pages/projects.html,No tasks,Nema zadataka
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Sales Invoice {0} created as paid,Prodajna faktura {0} izrađena je kao plaćena
DocType: Item Variant Settings,Copy Fields to Variant,Kopiranje polja u inačicu
DocType: Asset,Opening Accumulated Depreciation,Otvaranje Akumulirana amortizacija
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js,Score must be less than or equal to 5,Rezultat mora biti manja od ili jednaka 5
DocType: Program Enrollment Tool,Program Enrollment Tool,Program za upis alat
apps/erpnext/erpnext/config/accounting.py,C-Form records,C-obrazac zapisi
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shares already exist,Dionice već postoje
apps/erpnext/erpnext/config/help.py,Customer and Supplier,Kupaca i dobavljača
DocType: Email Digest,Email Digest Settings,E-pošta postavke
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Thank you for your business!,Hvala vam na poslovanju!
apps/erpnext/erpnext/config/support.py,Support queries from customers.,Upiti podršci.
DocType: Employee Property History,Employee Property History,Povijest imovine zaposlenika
apps/erpnext/erpnext/stock/doctype/item/item.py,Variant Based On cannot be changed,Varijanta na temelju temelji se ne može promijeniti
DocType: Setup Progress Action,Action Doctype,Djelovanje Doctype
DocType: HR Settings,Retirement Age,Umirovljenje Dob
DocType: Bin,Moving Average Rate,Stopa prosječne ponderirane cijene
DocType: Share Transfer,To Shareholder,Dioničarima
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Bill {1} dated {2},{0} u odnosu na račun {1} s datumom {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,Institucija za postavljanje
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Allocating leaves...,Dodjeljivanje lišća ...
DocType: Program Enrollment,Vehicle/Bus Number,Broj vozila / autobusa
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Create New Contact,Stvorite novi kontakt
apps/erpnext/erpnext/education/doctype/course/course.js,Course Schedule,Raspored predmeta
DocType: GSTR 3B Report,GSTR 3B Report,Izvještaj GSTR 3B
DocType: Request for Quotation Supplier,Quote Status,Status citata
DocType: GoCardless Settings,Webhooks Secret,Webhooks Secret
DocType: Maintenance Visit,Completion Status,Završetak Status
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Total payments amount can't be greater than {},Ukupni iznos plaćanja ne može biti veći od {}
DocType: Daily Work Summary Group,Select Users,Odaberite Korisnici
DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,Cjelokupna cijena sobe hotela
DocType: Loyalty Program Collection,Tier Name,Tier Name
DocType: HR Settings,Enter retirement age in years,Unesite dob za umirovljenje u godinama
DocType: Crop,Target Warehouse,Ciljana galerija
DocType: Payroll Employee Detail,Payroll Employee Detail,Pojedinosti zaposlenika plaće
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select a warehouse,Odaberite skladište
DocType: Cheque Print Template,Starting location from left edge,Počevši lokaciju od lijevog ruba
,Territory Target Variance Based On Item Group,Varijacija ciljne teritorija na temelju grupe predmeta
DocType: Upload Attendance,Import Attendance,Uvoz posjećenost
apps/erpnext/erpnext/public/js/pos/pos.html,All Item Groups,Sve skupine proizvoda
DocType: Work Order,Item To Manufacture,Proizvod za proizvodnju
DocType: Leave Control Panel,Employment Type (optional),Vrsta zaposlenja (izborno)
DocType: Pricing Rule,Threshold for Suggestion,Prag za prijedlog
apps/erpnext/erpnext/buying/utils.py,{0} {1} status is {2},{0} {1} status je {2}
DocType: Water Analysis,Collection Temperature ,Temperatura zbirke
DocType: Employee,Provide Email Address registered in company,Osigurati adresu e-pošte registriranu u društvu
DocType: Shopping Cart Settings,Enable Checkout,Omogući Checkout
apps/erpnext/erpnext/config/help.py,Purchase Order to Payment,Narudžbenice za plaćanje
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Projected Qty,Predviđena količina
DocType: Sales Invoice,Payment Due Date,Plaćanje Due Date
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Reserved Qty: Quantity ordered for sale, but not delivered.","Rezervirano Količina : Količina naručiti za prodaju , ali nije dostavljena ."
DocType: Drug Prescription,Interval UOM,Interval UOM
DocType: Customer,"Reselect, if the chosen address is edited after save",Ponovno odaberite ako je odabrana adresa uređena nakon spremanja
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Subcontract: Raw materials quantity to make subcotracted items.,Količina rezerviranog za podugovor: Količina sirovina za izradu poduhvata.
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant {0} already exists with same attributes,Stavka Varijanta {0} već postoji s istim atributima
DocType: Item,Hub Publishing Details,Pojedinosti objavljivanja središta
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,'Opening',&quot;Otvaranje &#39;
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open To Do,Otvoreni učiniti
DocType: Pricing Rule,Mixed Conditions,Mješoviti uvjeti
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Summary Saved,Sažetak poziva je spremljen
DocType: Issue,Via Customer Portal,Putem portala kupca
DocType: Employee Tax Exemption Proof Submission Detail,Actual Amount,Stvarni iznos
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,SGST Amount,Iznos SGST
DocType: Lab Test Template,Result Format,Format rezultata
DocType: Expense Claim,Expenses,troškovi
DocType: Service Level,Support Hours,Sati podrške
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Delivery Notes,Obavijesti o isporuci
DocType: Item Variant Attribute,Item Variant Attribute,Stavka Varijanta Osobina
,Purchase Receipt Trends,Trend primki
DocType: Payroll Entry,Bimonthly,časopis koji izlazi svaka dva mjeseca
DocType: Vehicle Service,Brake Pad,Pad kočnice
DocType: Fertilizer,Fertilizer Contents,Sadržaj gnojiva
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Research & Development,Istraživanje i razvoj
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py,Amount to Bill,Iznositi Billa
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Based On Payment Terms,Na temelju uvjeta plaćanja
apps/erpnext/erpnext/config/settings.py,ERPNext Settings,Postavke ERPNext
DocType: Company,Registration Details,Registracija Brodu
apps/erpnext/erpnext/support/doctype/issue/issue.py,Couldn't Set Service Level Agreement {0}.,Nije moguće postaviti ugovor o razini usluge {0}.
DocType: Timesheet,Total Billed Amount,Ukupno naplaćeni iznos
DocType: Item Reorder,Re-Order Qty,Re-order Kom
DocType: Leave Block List Date,Leave Block List Date,Datum popisa neodobrenih odsustava
DocType: Quality Feedback Parameter,Quality Feedback Parameter,Parametar povratne informacije o kvaliteti
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM #{0}: Raw material cannot be same as main Item,BOM # {0}: Sirovina ne može biti isti kao i glavna stavka
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,Ukupno odgovarajuće naknade u potvrdi o kupnji stavke stolu mora biti ista kao i Total poreza i naknada
DocType: Production Plan Item,"If enabled, system will create the work order for the exploded items against which BOM is available.","Ako je omogućeno, sustav će stvoriti radni nalog za eksplodirane predmete protiv kojih je BOM dostupan."
DocType: Sales Team,Incentives,Poticaji
DocType: SMS Log,Requested Numbers,Traženi brojevi
DocType: Volunteer,Evening,Večer
DocType: Quiz,Quiz Configuration,Konfiguracija kviza
DocType: Vital Signs,Normal,Normalan
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","Omogućavanje &#39;Koristi za košaricu&#39;, kao što Košarica je omogućena i tamo bi trebao biti barem jedan Porezna pravila za Košarica"
DocType: Sales Invoice Item,Stock Details,Stock Detalji
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Value,Vrijednost projekta
apps/erpnext/erpnext/config/help.py,Point-of-Sale,Prodajno mjesto
DocType: Fee Schedule,Fee Creation Status,Status kreiranja naknade
apps/erpnext/erpnext/utilities/activation.py,Create Sales Orders to help you plan your work and deliver on-time,Izradite prodajne naloge za lakše planiranje posla i isporuku na vrijeme
DocType: Vehicle Log,Odometer Reading,Stanje kilometraže
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 računa već u kredit, što se ne smije postaviti 'ravnoteža se mora' kao 'zaduženje """
DocType: Account,Balance must be,Bilanca mora biti
,Available Qty,Dostupno Količina
DocType: Shopify Settings,Default Warehouse to to create Sales Order and Delivery Note,Zadana skladišta za izradu narudžbe o prodaji i dostavi
DocType: Purchase Taxes and Charges,On Previous Row Total,Na prethodni redak Ukupno
DocType: Purchase Invoice Item,Rejected Qty,Odbijen Kol
DocType: Setup Progress Action,Action Field,Polje djelovanja
DocType: Healthcare Settings,Manage Customer,Upravljajte kupcem
DocType: Amazon MWS Settings,Always synch your products from Amazon MWS before synching the Orders details,Uvijek sinkronizirajte svoje proizvode s Amazon MWS prije usklađivanja pojedinosti o narudžbama
DocType: Delivery Trip,Delivery Stops,Dostava prestaje
DocType: Salary Slip,Working Days,Radnih dana
apps/erpnext/erpnext/accounts/deferred_revenue.py,Cannot change Service Stop Date for item in row {0},Nije moguće promijeniti datum zaustavljanja usluge za stavku u retku {0}
DocType: Serial No,Incoming Rate,Dolazni Stopa
DocType: Packing Slip,Gross Weight,Bruto težina
DocType: Leave Type,Encashment Threshold Days,Dani danih naplata
,Final Assessment Grades,Konačna ocjena razreda
apps/erpnext/erpnext/public/js/setup_wizard.js,The name of your company for which you are setting up this system.,Ime vaše tvrtke za koje ste postavljanje ovog sustava .
DocType: HR Settings,Include holidays in Total no. of Working Days,Uključi odmor u ukupnom. radnih dana
apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py,Setup your Institute in ERPNext,Postavite svoj institut u ERPNext
DocType: Agriculture Analysis Criteria,Plant Analysis,Analiza biljaka
DocType: Task,Timeline,Vremenska Crta
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Hold,Zadrži
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Alternate Item,Alternativna stavka
DocType: Shopify Log,Request Data,Zatražite podatke
DocType: Employee,Date of Joining,Datum pristupa
DocType: Naming Series,Update Series,Update serija
DocType: Supplier Quotation,Is Subcontracted,Je podugovarati
DocType: Restaurant Table,Minimum Seating,Minimalna sjedala
DocType: Item Attribute,Item Attribute Values,Stavka vrijednosti atributa
DocType: Examination Result,Examination Result,Rezultat ispita
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Purchase Receipt,Primka
,Received Items To Be Billed,Primljeni Proizvodi se naplaćuje
DocType: Purchase Invoice,Accounting Dimensions,Računovodstvene dimenzije
,Subcontracted Raw Materials To Be Transferred,Podugovaračke sirovine koje treba prenijeti
apps/erpnext/erpnext/config/accounting.py,Currency exchange rate master.,Majstor valute .
,Sales Person Target Variance Based On Item Group,Prodajna ciljana varijanta za osobu na temelju grupe predmeta
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Reference Doctype must be one of {0},Referentni DOCTYPE mora biti jedan 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,Filtar Ukupno Zero Količina
DocType: Work Order,Plan material for sub-assemblies,Plan materijal za pod-sklopova
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} must be active,BOM {0} mora biti aktivna
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,No Items available for transfer,Nema dostupnih stavki za prijenos
DocType: Employee Boarding Activity,Activity Name,Naziv aktivnosti
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Change Release Date,Promijenite datum objavljivanja
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Količina gotovog proizvoda <b>{0}</b> i za količinu <b>{1}</b> ne može se razlikovati
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Closing (Opening + Total),Zatvaranje (otvaranje + ukupno)
DocType: Delivery Settings,Dispatch Notification Attachment,Privitak obavijesti o otpremi
DocType: Payroll Entry,Number Of Employees,Broj zaposlenih
DocType: Journal Entry,Depreciation Entry,Amortizacija Ulaz
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Please select the document type first,Molimo odaberite vrstu dokumenta prvi
apps/erpnext/erpnext/stock/doctype/item/item.py,You have to enable auto re-order in Stock Settings to maintain re-order levels.,"Da biste održali razinu ponovne narudžbe, morate omogućiti automatsku ponovnu narudžbu u Postavkama dionica."
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,Cancel Material Visits {0} before cancelling this Maintenance Visit,Odustani Posjeta materijala {0} prije otkazivanja ovog održavanja pohod
DocType: Pricing Rule,Rate or Discount,Stopa ili Popust
apps/erpnext/erpnext/accounts/doctype/bank/bank_dashboard.py,Bank Details,Bankovni detalji
DocType: Vital Signs,One Sided,Jednostrano
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Item {1},Serijski Ne {0} ne pripada točki {1}
DocType: Purchase Order Item Supplied,Required Qty,Potrebna Kol
DocType: Marketplace Settings,Custom Data,Prilagođeni podaci
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to ledger.,Skladišta s postojećim transakcije ne može pretvoriti u knjigu.
DocType: Service Day,Service Day,Dan usluge
apps/erpnext/erpnext/projects/doctype/project/project.py,Project Summary for {0},Sažetak projekta za {0}
apps/erpnext/erpnext/hub_node/api.py,Unable to update remote activity,Nije moguće ažurirati daljinsku aktivnost
apps/erpnext/erpnext/controllers/buying_controller.py,Serial no is mandatory for the item {0},Serijski broj je obavezan za stavku {0}
DocType: Bank Reconciliation,Total Amount,Ukupan iznos
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,From Date and To Date lie in different Fiscal Year,Datum i datum leže u različitoj fiskalnoj godini
apps/erpnext/erpnext/healthcare/utils.py,The Patient {0} do not have customer refrence to invoice,Pacijent {0} nema fakturu kupca
DocType: Quality Feedback Template,Quality Feedback Template,Predložak povratne informacije o kvaliteti
apps/erpnext/erpnext/config/education.py,LMS Activity,LMS aktivnost
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Internet Publishing,Internet izdavaštvo
DocType: Prescription Duration,Number,Broj
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Creating {0} Invoice,Izrada fakture {0}
DocType: Medical Code,Medical Code Standard,Standard medicinskog koda
DocType: Soil Texture,Clay Composition (%),Sastava glina (%)
DocType: Item Group,Item Group Defaults,Defaults grupe stavke
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Please save before assigning task.,Spremite prije dodjele zadatka.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Balance Value,Vrijednost bilance
DocType: Lab Test,Lab Technician,Laboratorijski tehničar
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,Sales Price List,Prodajni cjenik
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.","Ako je označeno, izradit će se kupac, mapiran pacijentu. Pacijentne fakture će biti stvorene protiv ovog klijenta. Također možete odabrati postojeći Korisnik tijekom izrade pacijenta."
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,Customer isn't enrolled in any Loyalty Program,Kupac nije upisan u bilo koji program lojalnosti
DocType: Bank Reconciliation,Account Currency,Valuta računa
DocType: Lab Test,Sample ID,ID uzorka
apps/erpnext/erpnext/accounts/general_ledger.py,Please mention Round Off Account in Company,Molimo spomenuti zaokružiti račun u Društvu
DocType: Purchase Receipt,Range,Domet
DocType: Supplier,Default Payable Accounts,Zadane naplativo račune
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} is not active or does not exist,Zaposlenik {0} nije aktivan ili ne postoji
DocType: Fee Structure,Components,Komponente
DocType: Support Search Source,Search Term Param Name,Param Naziv pojma za pretraživanje
DocType: Item Barcode,Item Barcode,Barkod proizvoda
DocType: Delivery Trip,In Transit,U tranzitu
DocType: Woocommerce Settings,Endpoints,Krajnje točke
DocType: Shopping Cart Settings,Show Configure Button,Prikaži gumb Konfiguriraj
DocType: Quality Inspection Reading,Reading 6,Čitanje 6
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Cannot {0} {1} {2} without any negative outstanding invoice,Ne mogu {0} {1} {2} bez ikakvih negativnih izvanredan fakture
DocType: Share Transfer,From Folio No,Iz folije br
DocType: Purchase Invoice Advance,Purchase Invoice Advance,Ulazni račun - predujam
DocType: Shift Type,Every Valid Check-in and Check-out,Svaka valjana prijava i odjava
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Credit entry can not be linked with a {1},Red {0}: Kredit unos ne može biti povezan s {1}
apps/erpnext/erpnext/config/accounting.py,Define budget for a financial year.,Odredite proračun za financijsku godinu.
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 akademsku godinu i postavite datum početka i završetka.
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} is blocked so this transaction cannot proceed,{0} blokiran je tako da se ova transakcija ne može nastaviti
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on MR,Akcija ako je gomilanje mjesečnog proračuna premašeno na MR
DocType: Employee,Permanent Address Is,Stalna adresa je
DocType: Work Order Operation,Operation completed for how many finished goods?,Operacija završena za koliko gotovih proizvoda?
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Healthcare Practitioner {0} not available on {1},Zdravstveni praktičar {0} nije dostupan na {1}
DocType: Payment Terms Template,Payment Terms Template,Predložak o plaćanju
apps/erpnext/erpnext/public/js/setup_wizard.js,The Brand,Brand
DocType: Employee Tax Exemption Proof Submission,Rented To Date,Iznajmljeno do datuma
DocType: Manufacturing Settings,Allow Multiple Material Consumption,Omogući višestruku potrošnju materijala
DocType: Employee,Exit Interview Details,Izlaz Intervju Detalji
DocType: Item,Is Purchase Item,Je dobavljivi proizvod
DocType: Bank Statement Transaction Invoice Item,Purchase Invoice,Ulazni račun
DocType: Manufacturing Settings,Allow multiple Material Consumption against a Work Order,Dopustite višestruku potrošnju materijala prema radnom nalogu
DocType: GL Entry,Voucher Detail No,Bon Detalj Ne
DocType: Email Digest,New Sales Invoice,Novi prodajni Račun
DocType: Stock Entry,Total Outgoing Value,Ukupna odlazna vrijednost
DocType: Healthcare Practitioner,Appointments,imenovanja
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,Action Initialised,Akcija je pokrenuta
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date and Closing Date should be within same Fiscal Year,Otvaranje i zatvaranje Datum datum mora biti unutar iste fiskalne godine
DocType: Lead,Request for Information,Zahtjev 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),Ocijenite s marginom (valuta tvrtke)
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Categories,Kategorije
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Offline Invoices,Sinkronizacija Offline Računi
DocType: Payment Request,Paid,Plaćen
DocType: Service Level,Default Priority,Zadani prioritet
DocType: Program Fee,Program Fee,Naknada program
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.","Zamijenite određeni BOM u svim ostalim BOM-ovima gdje se upotrebljava. Zamijenit će staru BOM vezu, ažurirati trošak i obnoviti tablicu &quot;BOM Explosion Item&quot; po novom BOM-u. Također ažurira najnoviju cijenu u svim BOM-ovima."
DocType: Employee Skill Map,Employee Skill Map,Mapa vještina zaposlenika
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,The following Work Orders were created:,Izrađeni su sljedeći radni nalozi:
DocType: Salary Slip,Total in words,Ukupno je u riječima
DocType: Inpatient Record,Discharged,Ispražnjen
DocType: Material Request Item,Lead Time Date,Potencijalni kupac - datum
,Employee Advance Summary,Sažetak predujma zaposlenika
DocType: Asset,Available-for-use Date,Datum dostupan za upotrebu
DocType: Guardian,Guardian Name,Naziv Guardian
DocType: Cheque Print Template,Has Print Format,Ima format ispisa
DocType: Support Settings,Get Started Sections,Započnite s radom
DocType: Lead,CRM-LEAD-.YYYY.-,CRM-OLOVO-.YYYY.-
DocType: Invoice Discounting,Sanctioned,kažnjeni
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js,Total Contribution Amount: {0},Iznos ukupnog iznosa doprinosa: {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Navedite rednim brojem predmeta za {1}
DocType: Payroll Entry,Salary Slips Submitted,Plaćene zamke poslane
DocType: Crop Cycle,Crop Cycle,Ciklus usjeva
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 &#39;proizvod Bundle&#39; predmeta, skladište, rednim i hrpa Ne smatrat će se iz &quot;Popis pakiranja &#39;stol. Ako Skladište i serije ne su isti za sve pakiranje predmeta za bilo &#39;proizvod Bundle&#39; točke, te vrijednosti može se unijeti u glavnoj točki stol, vrijednosti će se kopirati u &#39;pakiranje popis&#39; stol."
DocType: Amazon MWS Settings,BR,BR
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Place,Od mjesta
DocType: Student Admission,Publish on website,Objavi na web stranici
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice Date cannot be greater than Posting Date,Datum Dobavljač Račun ne može biti veća od datum knjiženja
DocType: Installation Note,MAT-INS-.YYYY.-,MAT-INS-.YYYY.-
DocType: Subscription,Cancelation Date,Datum otkazivanja
DocType: Purchase Invoice Item,Purchase Order Item,Stavka narudžbenice
DocType: Agriculture Task,Agriculture Task,Zadatak poljoprivrede
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Indirect Income,Neizravni dohodak
DocType: Student Attendance Tool,Student Attendance Tool,Studentski Gledatelja alat
DocType: Restaurant Menu,Price List (Auto created),Cjenik (automatski izrađen)
DocType: Pick List Item,Picked Qty,Izabrani broj
DocType: Cheque Print Template,Date Settings,Datum Postavke
apps/erpnext/erpnext/education/doctype/question/question.py,A question must have more than one options,Pitanje mora imati više opcija
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Variance,Varijacija
DocType: Employee Promotion,Employee Promotion Detail,Detaljan opis promocije zaposlenika
DocType: SMS Center,Total Message(s),Ukupno poruka ( i)
DocType: Share Balance,Purchased,kupljen
DocType: Item Variant Settings,Rename Attribute Value in Item Attribute.,Preimenuj vrijednost svojstva u svojstvu stavke.
DocType: Purchase Invoice,Additional Discount Percentage,Dodatni Postotak Popust
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,View a list of all the help videos,Pregled popisa svih pomoć videa
DocType: Agriculture Analysis Criteria,Soil Texture,Tekstura tla
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,Odaberite račun šefa banke gdje je ček bio pohranjen.
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Dopusti korisniku uređivanje cjenika u transakcijama
DocType: Pricing Rule,Max Qty,Maksimalna količina
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js,Print Report Card,Ispis izvješća
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","Red {0}: Račun {1} je nevažeća, to bi moglo biti poništena / ne postoji. \ Unesite valjanu fakture"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Red {0}: Plaćanje protiv prodaje / narudžbenice treba uvijek biti označena kao unaprijed
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Chemical,kemijski
DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Zadana Banka / Novčani račun će biti automatski ažurira plaće Temeljnica kad je odabran ovaj način rada.
DocType: Quiz,Latest Attempt,Najnoviji pokušaj
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},Ukupni dopušteni dopusti obvezni su za vrstu napuštanja {0}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Red # {0}: Stopa ne može biti veća od stope korištene u {1} {2}
apps/erpnext/erpnext/utilities/user_progress.py,Meter,Metar
DocType: Workstation,Electricity Cost,Troškovi struje
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab testing datetime cannot be before collection datetime,Datetime testiranja laboratorija ne može biti prije datetime prikupljanja
DocType: Subscription Plan,Cost,cijena
DocType: HR Settings,Don't send Employee Birthday Reminders,Ne šaljite podsjetnik za rođendan zaposlenika
DocType: Expense Claim,Total Advance Amount,Ukupni iznos predujma
DocType: Delivery Stop,Estimated Arrival,Očekivani dolazak
apps/erpnext/erpnext/templates/pages/help.html,See All Articles,Pogledajte sve članke
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Walk In,Šetnja u
DocType: Item,Inspection Criteria,Inspekcijski Kriteriji
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Transfered,Prenose
DocType: BOM Website Item,BOM Website Item,BOM web stranica predmeta
apps/erpnext/erpnext/public/js/setup_wizard.js,Upload your letter head and logo. (you can edit them later).,Upload Vaše pismo glavu i logotip. (Možete ih uređivati kasnije).
DocType: Timesheet Detail,Bill,Račun
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,White,Bijela
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid Company for Inter Company Transaction.,Nevažeća tvrtka za transakcije između kompanija.
DocType: SMS Center,All Lead (Open),Svi potencijalni kupci (aktualni)
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.,Na popisu potvrdnih okvira možete odabrati najviše jednu opciju.
DocType: Purchase Invoice,Get Advances Paid,Kreiraj avansno plaćanje
DocType: Item,Automatically Create New Batch,Automatski kreira novu seriju
DocType: Woocommerce Settings,"The user that will be used to create Customers, Items and Sales Orders. This user should have the relevant permissions.","Korisnik koji će se koristiti za kreiranje kupaca, predmeta i naloga za prodaju. Taj bi korisnik trebao imati relevantna dopuštenja."
DocType: Supplier,Represents Company,Predstavlja tvrtku
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Make ,Napravi
DocType: Student Admission,Admission Start Date,Prijem Datum početka
DocType: Journal Entry,Total Amount in Words,Ukupan iznos riječima
apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js,New Employee,Novi zaposlenik
apps/erpnext/erpnext/controllers/selling_controller.py,Order Type must be one of {0},Tip narudžbe mora biti jedan od {0}
DocType: Lead,Next Contact Date,Sljedeći datum kontakta
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Opening Qty,Otvaranje Kol
DocType: Healthcare Settings,Appointment Reminder,Podsjetnik za sastanak
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please enter Account for Change Amount,Unesite račun za promjene visine
DocType: Program Enrollment Tool Student,Student Batch Name,Studentski Batch Name
DocType: Holiday List,Holiday List Name,Ime popisa praznika
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Uvoz predmeta i UOM-ova
DocType: Repayment Schedule,Balance Loan Amount,Stanje Iznos kredita
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Dodano detaljima
DocType: Communication Medium,Catch All,Uhvatiti sve
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Raspored nastave
DocType: Budget,Applicable on Material Request,Primjenjivo na zahtjev za materijal
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Stock Options,Burzovnih opcija
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,No Items added to cart,Nijedna stavka nije dodana u košaricu
DocType: Journal Entry Account,Expense Claim,Rashodi polaganja
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Do you really want to restore this scrapped asset?,Da li stvarno želite vratiti ovaj otpisan imovine?
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Qty for {0},Količina za {0}
DocType: Attendance,Leave Application,Zahtjev za odsustvom
DocType: Patient,Patient Relation,Pacijentna veza
DocType: Item,Hub Category to Publish,Kategorija hub za objavljivanje
DocType: Leave Block List,Leave Block List Dates,Datumi popisa neodobrenih odsustava
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","Prodajni nalog {0} ima rezervaciju za stavku {1}, možete dostaviti rezervirano {1} samo od {0}. Serijski broj {2} ne može biti isporučen"
DocType: Sales Invoice,Billing Address GSTIN,Adresa za naplatu GSTIN
DocType: Homepage,Hero Section Based On,Odjeljak hero na temelju
DocType: Employee Tax Exemption Proof Submission,Total Eligible HRA Exemption,Ukupan povlašteni HRA izuzeće
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! A GSTIN must have 15 characters.,Nevažeći GSTIN! GSTIN mora imati 15 znakova.
DocType: Assessment Plan,Evaluate,procijeniti
DocType: Workstation,Net Hour Rate,Neto sat cijena
DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Ulazni račun zavisnog troška
DocType: Supplier Scorecard Period,Criteria,kriteriji
DocType: Packing Slip Item,Packing Slip Item,Odreskom predmet
DocType: Purchase Invoice,Cash/Bank Account,Novac / bankovni račun
DocType: Travel Itinerary,Train,Vlak
,Delayed Item Report,Izvješće o odgođenom stavci
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Eligible ITC,Ispunjava uvjete ITC
DocType: Healthcare Service Unit,Inpatient Occupancy,Bolničko liječenje
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,Publish Your First Items,Objavite svoje prve stavke
DocType: Sample Collection,HLC-SC-.YYYY.-,FHP-SC-.YYYY.-
DocType: Shift Type,Time after the end of shift during which check-out is considered for attendance.,Vrijeme nakon završetka smjene tijekom koje se odjava odlazi na raspolaganje.
apps/erpnext/erpnext/public/js/queries.js,Please specify a {0},Navedite a {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Removed items with no change in quantity or value.,Uklonjene stvari bez promjena u količini ili vrijednosti.
DocType: Delivery Note,Delivery To,Dostava za
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant creation has been queued.,Izrada inačice je u redu čekanja.
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,Work Summary for {0},Sažetak rada za {0}
DocType: Department,The first Leave Approver in the list will be set as the default Leave Approver.,Prvo odobrenje za odsustvo na popisu će biti postavljeno kao zadani odobrenja za otpust.
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute table is mandatory,Osobina stol je obavezno
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Delayed Days,Odloženi dani
DocType: Production Plan,Get Sales Orders,Kreiraj narudžbe
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} can not be negative,{0} ne može biti negativna
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Connect to Quickbooks,Povežite se s QuickBooksom
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Clear values,Jasne vrijednosti
DocType: Training Event,Self-Study,Samostalno istraživanje
DocType: POS Closing Voucher,Period End Date,Datum završetka razdoblja
apps/erpnext/erpnext/regional/india/utils.py,Transport Receipt No and Date are mandatory for your chosen Mode of Transport,Broj potvrde prijevoza i datum obvezni su za odabrani način prijevoza
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py,Soil compositions do not add up to 100,Sastavi tla ne dodaju 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,Redak {0}: {1} potreban je za izradu faktura otvaranja {2}
DocType: Membership,Membership,Članstvo
DocType: Asset,Total Number of Depreciations,Ukupan broj deprecijaciju
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Debit A/C Number,Debitni A / C broj
DocType: Sales Invoice Item,Rate With Margin,Ocijenite s marginom
DocType: Purchase Invoice,Is Return (Debit Note),Je li povrat (debitna bilješka)
DocType: Workstation,Wages,Plaće
DocType: Asset Maintenance,Maintenance Manager Name,Ime upravitelja održavanja
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Transactions against the company already exist! ,Transakcije protiv tvrtke već postoje!
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requesting Site,Podnositelj zahtjeva
DocType: Agriculture Task,Urgent,Hitan
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Fetching records......,Dohvaćanje zapisa ......
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please specify a valid Row ID for row {0} in table {1},Navedite valjanu Row ID za redom {0} u tablici {1}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py,Unable to find variable: ,Nije moguće pronaći varijablu:
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select a field to edit from numpad,Odaberite polje za uređivanje iz numpad
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot be a fixed asset item as Stock Ledger is created.,Ne može biti fiksna stavka imovine jer je Lozinka stanja stvorena.
DocType: Subscription Plan,Fixed rate,Fiksna stopa
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.js,Admit,Priznati
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Go to the Desktop and start using ERPNext,Idi na radnu površinu i početi koristiti ERPNext
apps/erpnext/erpnext/templates/pages/order.js,Pay Remaining,Plaćanje preostalo
DocType: Purchase Invoice Item,Manufacturer,Proizvođač
DocType: Landed Cost Item,Purchase Receipt Item,Stavka primke
DocType: Leave Allocation,Total Leaves Encashed,Ukupni listovi
DocType: POS Profile,Sales Invoice Payment,Prodaja fakture za plaćanje
DocType: Quality Inspection Template,Quality Inspection Template Name,Naziv predloška inspekcije kvalitete
DocType: Project,First Email,Prva e-pošta
DocType: Company,Exception Budget Approver Role,Uloga odobravanja proračuna za izuzeće
DocType: Purchase Invoice,"Once set, this invoice will be on hold till the set date","Nakon postavljanja, ova će faktura biti na čekanju do zadanog datuma"
DocType: Cashier Closing,POS-CLO-,POS-CLO-
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Selling Amount,Prodaja Iznos
DocType: Repayment Schedule,Interest Amount,Iznos kamata
DocType: Job Card,Time Logs,Vrijeme Trupci
DocType: Sales Invoice,Loyalty Amount,Iznos odanosti
DocType: Employee Transfer,Employee Transfer Detail,Detalj prijenosa zaposlenika
DocType: Serial No,Creation Document No,Stvaranje dokumenata nema
DocType: Location,Location Details,Detalji o lokaciji
DocType: Share Transfer,Issue,Izazov
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter_dashboard.py,Records,ploče
DocType: Asset,Scrapped,otpisan
DocType: Item,Item Defaults,Stavke zadane vrijednosti
DocType: Cashier Closing,Returns,vraća
DocType: Job Card,WIP Warehouse,WIP Skladište
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} is under maintenance contract upto {1},Serijski Ne {0} je pod ugovorom za održavanje upto {1}
apps/erpnext/erpnext/config/hr.py,Recruitment,regrutacija
DocType: Lead,Organization Name,Naziv organizacije
DocType: Support Settings,Show Latest Forum Posts,Prikaži najnovije postove na forumu
DocType: Tax Rule,Shipping State,Državna dostava
,Projected Quantity as Source,Planirana količina kao izvor
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Item must be added using 'Get Items from Purchase Receipts' button,Stavka mora biti dodana pomoću 'se predmeti od kupnje primitaka' gumb
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Delivery Trip,Putovanje isporuke
DocType: Student,A-,A-
DocType: Share Transfer,Transfer Type,Vrsta prijenosa
DocType: Pricing Rule,Quantity and Amount,Količina i količina
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Sales Expenses,Prodajni troškovi
DocType: Diagnosis,Diagnosis,Dijagnoza
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Buying,Standardna kupnju
DocType: Attendance Request,Explanation,Obrazloženje
DocType: GL Entry,Against,Protiv
DocType: Item Default,Sales Defaults,Defaults prodaja
DocType: Sales Order Item,Work Order Qty,Radni nalog
DocType: Item Default,Default Selling Cost Center,Zadani trošak prodaje
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Disc,disk
DocType: Buying Settings,Material Transferred for Subcontract,Prijenos materijala za podugovaranje
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Date,Datum narudžbe
DocType: Email Digest,Purchase Orders Items Overdue,Narudžbenice su stavke dospjele
apps/erpnext/erpnext/accounts/page/pos/pos.js,ZIP Code,Poštanski broj
apps/erpnext/erpnext/controllers/selling_controller.py,Sales Order {0} is {1},Prodaja Naručite {0} {1}
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Select interest income account in loan {0},Odaberite račun za dohodak od kamata u zajam {0}
DocType: Opportunity,Contact Info,Kontakt Informacije
apps/erpnext/erpnext/config/help.py,Making Stock Entries,Izrada Stock unose
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Cannot promote Employee with status Left,Ne mogu promovirati zaposlenika sa statusom lijevo
DocType: Packing Slip,Net Weight UOM,Težina mjerna jedinica
DocType: Item Default,Default Supplier,Glavni dobavljač
DocType: Loan,Repayment Schedule,Otplata Raspored
DocType: Shipping Rule Condition,Shipping Rule Condition,Dostava Pravilo Stanje
apps/erpnext/erpnext/hr/doctype/payroll_period/payroll_period.py,End Date can not be less than Start Date,Datum završetka ne može biti manja od početnog datuma
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Invoice can't be made for zero billing hour,Račun se ne može izvršiti za nulti sat naplate
DocType: Company,Date of Commencement,Datum početka
DocType: Sales Person,Select company name first.,Prvo odaberite naziv tvrtke.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Email sent to {0},E-mail poslan na {0}
apps/erpnext/erpnext/config/buying.py,Quotations received from Suppliers.,Ponude dobivene od dobavljača.
DocType: Quality Goal,January-April-July-October,Siječanj-travanj-srpanj-listopad
apps/erpnext/erpnext/config/manufacturing.py,Replace BOM and update latest price in all BOMs,Zamijenite BOM i ažurirajte najnoviju cijenu u svim BOM-ovima
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.,Ovo je grupa dobavljača i ne može se uređivati.
DocType: Sales Invoice,Driver Name,Naziv upravljačkog programa
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Average Age,Prosječna starost
DocType: Education Settings,Attendance Freeze Date,Datum zamrzavanja pohađanja
DocType: Payment Request,Inward,Unutra
apps/erpnext/erpnext/utilities/user_progress.py,List a few of your suppliers. They could be organizations or individuals.,Navedite nekoliko svojih dobavljača. Oni mogu biti tvrtke ili fizičke osobe.
DocType: Accounting Dimension,Dimension Defaults,Zadane dimenzije
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Minimum Lead Age (Days),Minimalna dob (olovo)
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,All BOMs,Svi Sastavnice
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Create Inter Company Journal Entry,Napravite unos časopisa Inter Company
DocType: Company,Parent Company,Matično društvo
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Hotel Rooms of type {0} are unavailable on {1},Hotel Sobe tipa {0} nisu dostupne na {1}
apps/erpnext/erpnext/config/manufacturing.py,Compare BOMs for changes in Raw Materials and Operations,Usporedite BOM za promjene u sirovinama i načinu rada
apps/erpnext/erpnext/accounts/doctype/bank_transaction/bank_transaction.js,Document {0} successfully uncleared,Dokument {0} uspješno izbrisan
DocType: Healthcare Practitioner,Default Currency,Zadana valuta
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Reconcile this account,Uskladi ovaj račun
apps/erpnext/erpnext/controllers/selling_controller.py,Maximum discount for Item {0} is {1}%,Maksimalni popust za stavku {0} je {1}%
DocType: Chart of Accounts Importer,Attach custom Chart of Accounts file,Priložite datoteku prilagođenog računa računa
DocType: Asset Movement,From Employee,Od zaposlenika
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of services,Uvoz usluga
DocType: Driver,Cellphone Number,broj mobitela
DocType: Project,Monitor Progress,Monitor napredak
DocType: Pricing Rule Item Code,Pricing Rule Item Code,Pravilo cijene Kôd predmeta
apps/erpnext/erpnext/controllers/accounts_controller.py,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Upozorenje : Sustav neće provjeravati overbilling od iznosa za točku {0} u {1} je nula
DocType: Journal Entry,Make Difference Entry,Čine razliku Entry
DocType: Supplier Quotation,Auto Repeat Section,Auto Repeat Section
DocType: Service Level Priority,Response Time,Vrijeme odziva
DocType: Upload Attendance,Attendance From Date,Gledanost od datuma
DocType: Appraisal Template Goal,Key Performance Area,Zona ključnih performansi
DocType: Program Enrollment,Transportation,promet
apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Pogrešna Osobina
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} mora biti podnesen
apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Kampanje e-pošte
DocType: Buying Settings,Default Supplier Group,Zadana skupina dobavljača
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Količina mora biti manji ili jednak {0}
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Maksimalni iznos koji ispunjava uvjete za komponentu {0} prelazi {1}
DocType: Department Approver,Department Approver,Odjel za odobrenje
DocType: QuickBooks Migrator,Application Settings,Postavke aplikacije
DocType: SMS Center,Total Characters,Ukupno Likovi
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Creating Company and Importing Chart of Accounts,Stvaranje tvrtke i uvoz računa
DocType: Employee Advance,Claimed,tvrdio
DocType: Crop,Row Spacing,Spremanje redaka
apps/erpnext/erpnext/controllers/buying_controller.py,Please select BOM in BOM field for Item {0},Odaberite BOM u BOM polje za točku {0}
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,There isn't any item variant for the selected item,Nema odabrane stavke za odabranu stavku
DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-obrazac detalj računa
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Pomirenje Plaćanje fakture
DocType: Clinical Procedure,Procedure Template,Predložak za postupak
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Publish Items,Objavite stavke
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution %,Doprinos%
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}","Prema postavkama kupnje ako je potrebna narudžbenica == &#39;DA&#39;, a zatim za izradu računa za kupnju, korisnik mora najprije stvoriti narudžbenicu za stavku {0}"
,HSN-wise-summary of outward supplies,HSN-mudar sažetak vanjske opskrbe
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Tvrtka registracijski brojevi za svoju referencu. Porezni brojevi itd.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To State,Izjaviti
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Distributor,Distributer
DocType: Asset Finance Book,Asset Finance Book,Financijska knjiga o imovini
DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Košarica Dostava Rule
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.py,Please setup a default bank account for company {0},Postavite zadani bankovni račun za tvrtku {0}
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set 'Apply Additional Discount On',Molimo postavite &quot;Primijeni dodatni popust na &#39;
DocType: Party Tax Withholding Config,Applicable Percent,Primjenjivi postotak
,Ordered Items To Be Billed,Naručeni proizvodi za naplatu
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,From Range has to be less than To Range,Od Raspon mora biti manji od u rasponu
DocType: Global Defaults,Global Defaults,Globalne zadane postavke
apps/erpnext/erpnext/projects/doctype/project/project.py,Project Collaboration Invitation,Projekt Suradnja Poziv
DocType: Salary Slip,Deductions,Odbici
DocType: Setup Progress Action,Action Name,Naziv akcije
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Start Year,Početak godine
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.js,Create Loan,Stvorite zajam
DocType: Purchase Invoice,Start date of current invoice's period,Početak datum tekućeg razdoblja dostavnice
DocType: Shift Type,Process Attendance After,Posjedovanje procesa nakon
,IRS 1099,IRS 1099
DocType: Salary Slip,Leave Without Pay,Neplaćeno odsustvo
DocType: Payment Request,Outward,van
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,State/UT Tax,Porez na države / UT
,Trial Balance for Party,Suđenje Stanje na stranku
,Gross and Net Profit Report,Izvješće o bruto i neto dobiti
apps/erpnext/erpnext/config/quality_management.py,Tree of Procedures,Stablo postupaka
DocType: Lead,Consultant,Konzultant
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Parents Teacher Meeting Attendance,Sastanak sudionika učitelja roditelja
DocType: Salary Slip,Earnings,Zarada
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Finished Item {0} must be entered for Manufacture type entry,Gotovi Stavka {0} mora biti upisana za tip Proizvodnja upis
apps/erpnext/erpnext/config/help.py,Opening Accounting Balance,Otvori računovodstveno stanje
,GST Sales Register,GST registar prodaje
DocType: Sales Invoice Advance,Sales Invoice Advance,Predujam prodajnog računa
apps/erpnext/erpnext/public/js/setup_wizard.js,Select your Domains,Odaberite svoje domene
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/sync_product.py,Shopify Supplier,Dobavljač trgovine
DocType: Bank Statement Transaction Entry,Payment Invoice Items,Stavke fakture za plaćanje
DocType: Payroll Entry,Employee Details,Detalji zaposlenika
DocType: Amazon MWS Settings,CN,CN
DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Polja će biti kopirana samo u trenutku stvaranja.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Row {0}: asset is required for item {1},Redak {0}: za stavku {1} potreban je materijal
apps/erpnext/erpnext/projects/doctype/task/task.py,'Actual Start Date' can not be greater than 'Actual End Date',Stvarni datum početka ne može biti veći od stvarnog datuma završetka
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Management,Uprava
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.js,Show {0},Prikaži {0}
DocType: Cheque Print Template,Payer Settings,Postavke Payer
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,No pending Material Requests found to link for the given items.,Nisu pronađeni materijalni zahtjevi na čekanju za povezivanje za određene stavke.
apps/erpnext/erpnext/public/js/utils/party.js,Select company first,Najprije odaberite tvrtku
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 U tijeku je rad i ne može ga ažurirati Entry Journal
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Compare List function takes on list arguments,Funkcija Usporedi popis preuzima argumente liste
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 će biti dodan u šifra varijante. Na primjer, ako je vaš naziv je ""SM"", a točka kod ""T-shirt"", stavka kod varijante će biti ""T-SHIRT-SM"""
DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,Neto plaća (riječima) će biti vidljiva nakon što spremite klizne plaće.
DocType: Delivery Note,Is Return,Je li povratak
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Caution,Oprez
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Import Successful,Uvoz je uspješan
apps/erpnext/erpnext/config/quality_management.py,Goal and Procedure,Cilj i postupak
apps/erpnext/erpnext/agriculture/doctype/disease/disease.py,Start day is greater than end day in task '{0}',Dan početka je veći od završnog dana u zadatku &#39;{0}&#39;
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Return / Debit Note,Povratak / debitna Napomena
DocType: Price List Country,Price List Country,Država cjenika
DocType: Sales Invoice,Set Source Warehouse,Postavi Izvor skladišta
DocType: Tally Migration,UOMs,J. MJ.
DocType: Account Subtype,Account Subtype,Podvrsta računa
apps/erpnext/erpnext/stock/utils.py,{0} valid serial nos for Item {1},{0} valjani serijski nos za Stavka {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item Code cannot be changed for Serial No.,Kod proizvoda ne može se mijenjati za serijski broj.
DocType: Purchase Invoice Item,UOM Conversion Factor,UOM konverzijski faktor
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js,Please enter Item Code to get Batch Number,Unesite Šifra dobiti broj serije
DocType: Loyalty Point Entry,Loyalty Point Entry,Ulaznica za lojalnost
DocType: Employee Checkin,Shift End,Kraj smjene
DocType: Stock Settings,Default Item Group,Zadana grupa proizvoda
DocType: Job Card Time Log,Time In Mins,Vrijeme u minima
apps/erpnext/erpnext/config/non_profit.py,Grant information.,Dati informacije.
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 ?,Ova akcija će prekinuti vezu ovog računa s bilo kojom vanjskom uslugom koja integrira ERPNext s vašim bankovnim računima. To se ne može poništiti. Jesi li siguran ?
apps/erpnext/erpnext/config/buying.py,Supplier database.,Dobavljač baza podataka.
DocType: Contract Template,Contract Terms and Conditions,Uvjeti i odredbe ugovora
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,You cannot restart a Subscription that is not cancelled.,Ne možete ponovo pokrenuti pretplatu koja nije otkazana.
DocType: Account,Balance Sheet,Završni račun
DocType: Leave Type,Is Earned Leave,Je zaradio odlazak
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount,Iznos narudžbe
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Cost Center For Item with Item Code ',Troška za stavku s šifra '
DocType: Fee Validity,Valid Till,Vrijedi do
DocType: Student Report Generation Tool,Total Parents Teacher Meeting,Sastanak učitelja svih roditelja
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ćanja nije konfiguriran. Provjerite, da li je račun postavljen na način rada platnu ili na POS profilu."
apps/erpnext/erpnext/buying/utils.py,Same item cannot be entered multiple times.,Isti predmet ne može se upisati više puta.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Further accounts can be made under Groups, but entries can be made against non-Groups","Daljnje računi mogu biti u skupinama, ali unose se može podnijeti protiv nesrpskog Groups"
DocType: Call Log,Lead,Potencijalni kupac
DocType: Email Digest,Payables,Plativ
DocType: Amazon MWS Settings,MWS Auth Token,MWS autentni token
DocType: Email Campaign,Email Campaign For ,Kampanja e-pošte za
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Entry {0} created,Stock Ulazak {0} stvorio
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,You don't have enought Loyalty Points to redeem,Nemate dovoljno bodova lojalnosti za otkup
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py,Please set associated account in Tax Withholding Category {0} against Company {1},Postavite pridruženi račun u kategoriju zadržavanja poreza {0} tvrtke {1}
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Qty can not be entered in Purchase Return,Red # {0}: Odbijen Kom se ne može upisati u kupnju povratak
apps/erpnext/erpnext/stock/doctype/item/item.js,Changing Customer Group for the selected Customer is not allowed.,Promjena grupe kupaca za odabranog kupca nije dopuštena.
,Purchase Order Items To Be Billed,Stavke narudžbenice za naplatu
DocType: Program Enrollment Tool,Enrollment Details,Pojedinosti o upisu
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot set multiple Item Defaults for a company.,Nije moguće postaviti više zadanih postavki za tvrtku.
DocType: Customer Group,Credit Limits,Kreditna ograničenja
DocType: Purchase Invoice Item,Net Rate,Neto stopa
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select a customer,Odaberite klijenta
DocType: Leave Policy,Leave Allocations,Ostavite dodjele
DocType: Job Card,Started Time,Počelo vrijeme
DocType: Purchase Invoice Item,Purchase Invoice Item,Proizvod ulaznog računa
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,Upisi u glavnu knjigu i GL upisi su ponovno postavljeni za odabrane primke.
DocType: Student Report Generation Tool,Assessment Terms,Uvjeti procjene
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 1,Stavka 1
DocType: Holiday,Holiday,Odmor
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Leave Type is madatory,Vrsta napuštanja je laka
DocType: Support Settings,Close Issue After Days,Zatvori Issue Nakon dana
,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.,Morate biti korisnik s ulogama upravitelja sustava i upravitelja stavki kako biste korisnike dodali na tržište.
DocType: Attendance,Early Exit,Rani izlazak
DocType: Job Opening,Staffing Plan,Plan osoblja
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 može se generirati samo iz poslanog dokumenta
apps/erpnext/erpnext/config/hr.py,Employee Tax and Benefits,Porez na zaposlenike i beneficije
DocType: Bank Guarantee,Validity in Days,Valjanost u danima
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,C-form is not applicable for Invoice: {0},C-oblika nije primjenjiv za fakture: {0}
DocType: Certified Consultant,Name of Consultant,Naziv konzultanta
DocType: Payment Reconciliation,Unreconciled Payment Details,Nesaglašen Detalji plaćanja
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Member Activity,Aktivnost članova
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Count,Broj naloga
DocType: Global Defaults,Current Fiscal Year,Tekuće fiskalne godine
DocType: Purchase Invoice,Group same items,Isti predmeti grupe
DocType: Purchase Invoice,Disable Rounded Total,Ugasiti zaokruženi iznos
DocType: Marketplace Settings,Sync in Progress,Sinkronizacija u tijeku
DocType: Department,Parent Department,Odjel za roditelje
DocType: Loan Application,Repayment Info,Informacije otplate
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,'Entries' cannot be empty,'Ulazi' ne može biti prazno
DocType: Maintenance Team Member,Maintenance Role,Uloga za održavanje
apps/erpnext/erpnext/utilities/transaction_base.py,Duplicate row {0} with same {1},Dupli red {0} sa istim {1}
DocType: Marketplace Settings,Disable Marketplace,Onemogući tržište
DocType: Quality Meeting,Minutes,minuta
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Your Featured Items,Istaknuti predmeti
,Trial Balance,Pretresno bilanca
apps/erpnext/erpnext/templates/pages/projects.js,Show Completed,Prikaži dovršeno
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Fiscal Year {0} not found,Fiskalna godina {0} nije pronađena
apps/erpnext/erpnext/config/help.py,Setting up Employees,Postavljanje zaposlenika
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Unesite zalihe
DocType: Hotel Room Reservation,Hotel Reservation User,Korisnik hotela rezervacije
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Postavite status
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Odaberite prefiks prvi
DocType: Contract,Fulfilment Deadline,Rok provedbe
apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Blizu tebe
DocType: Student,O-,O-
DocType: Subscription Settings,Subscription Settings,Postavke pretplate
DocType: Purchase Invoice,Update Auto Repeat Reference,Ažuriraj referencu za automatsko ponavljanje
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Optional Holiday List not set for leave period {0},Izborni popis za odmor nije postavljen za dopust razdoblja {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Research,istraživanje
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 2,Adresa 2
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0}: From time must be less than to time,Red {0}: S vremena na vrijeme mora biti manje
DocType: Maintenance Visit Purpose,Work Done,Rad Done
apps/erpnext/erpnext/controllers/item_variant.py,Please specify at least one attribute in the Attributes table,Navedite barem jedan atribut u tablici Svojstva
DocType: Announcement,All Students,Svi studenti
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} must be a non-stock item,Stavka {0} mora biti ne-stock točka a
apps/erpnext/erpnext/stock/doctype/batch/batch.js,View Ledger,Pogledaj Ledger
DocType: Grading Scale,Intervals,intervali
DocType: Bank Statement Transaction Entry,Reconciled Transactions,Usklađene transakcije
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Earliest,Najstarije
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","Stavka Grupa postoji s istim imenom , molimo promijenite ime stavku ili preimenovati stavku grupe"
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invocies,Nabavite fakture
DocType: Designation,Skills,vještine
DocType: Crop Cycle,Less than a year,Manje od godinu dana
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Student Mobile No.,Studentski Mobile Ne
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Rest Of The World,Ostatak svijeta
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,The Item {0} cannot have Batch,Stavka {0} ne može imati Hrpa
DocType: Crop,Yield UOM,Prinos UOM
,Budget Variance Report,Proračun varijance Prijavi
DocType: Salary Slip,Gross Pay,Bruto plaća
DocType: Item,Is Item from Hub,Je li stavka iz huba
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Get Items from Healthcare Services,Preuzmite stavke iz zdravstvenih usluga
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: Activity Type is mandatory.,Red {0}: Tip aktivnost je obavezna.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Dividends Paid,Plaćeni Dividende
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Accounting Ledger,Računovodstvo knjiga
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Difference Amount,Razlika Količina
DocType: Purchase Invoice,Reverse Charge,Obrnuti naboj
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Retained Earnings,Zadržana dobit
DocType: Job Card,Timing Detail,Detaljno vrijeme
DocType: Purchase Invoice,05-Change in POS,05-Promjena u POS-u
DocType: Vehicle Log,Service Detail,Detalj usluga
DocType: BOM,Item Description,Opis proizvoda
DocType: Student Sibling,Student Sibling,Studentski iste razine
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py,Payment Mode,Način plaćanja
DocType: Purchase Invoice,Supplied Items,Isporučeni pribor
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please set an active menu for Restaurant {0},Postavite aktivni izbornik za restoran {0}
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Commission Rate %,Stopa komisije%
DocType: Woocommerce Settings,"This warehouse will be used to create Sale Orders. The fallback warehouse is ""Stores"".",Ovo će se skladište koristiti za izradu prodajnih naloga. Rezervno skladište su &quot;Trgovine&quot;.
DocType: Work Order,Qty To Manufacture,Količina za proizvodnju
DocType: Email Digest,New Income,Novi Prihod
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Open Lead,Otvoreno olovo
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Održavaj istu stopu tijekom cijelog ciklusa kupnje
DocType: Opportunity Item,Opportunity Item,Prilika proizvoda
DocType: Quality Action,Quality Review,Pregled kvalitete
,Student and Guardian Contact Details,Studentski i Guardian Kontaktni podaci
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge Account,Spoji 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,Red {0}: Za dobavljača {0} email adresa je potrebno za slanje e-pošte
DocType: Shift Type,Attendance will be marked automatically only after this date.,Pohađanje će biti označeno automatski nakon tog datuma.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Opening,Privremeni Otvaranje
,Employee Leave Balance,Zaposlenik napuste balans
apps/erpnext/erpnext/quality_management/doctype/quality_procedure/quality_procedure_tree.js,New Quality Procedure,Novi postupak kvalitete
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Balance for Account {0} must always be {1},Bilanca računa {0} uvijek mora biti {1}
DocType: Patient Appointment,More Info,Više informacija
DocType: Supplier Scorecard,Scorecard Actions,Akcije tablice rezultata
apps/erpnext/erpnext/utilities/user_progress.py,Example: Masters in Computer Science,Primjer: Masters u Computer Science
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,Supplier {0} not found in {1},Dobavljač {0} nije pronađen {1}
DocType: Purchase Invoice,Rejected Warehouse,Odbijen galerija
DocType: GL Entry,Against Voucher,Protiv Voucheru
DocType: Item Default,Default Buying Cost Center,Zadani trošak kupnje
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Payment,Novo plaćanje
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 biste dobili najbolje iz ERPNext, preporučamo da odvojite malo vremena i gledati te pomoći videa."
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,For Default Supplier (optional),Za dobavljača zadano (neobavezno)
DocType: Supplier Quotation Item,Lead Time in days,Olovo Vrijeme u danima
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,Obveze Sažetak
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Not authorized to edit frozen Account {0},Niste ovlašteni za uređivanje zamrznutog računa {0}
DocType: Journal Entry,Get Outstanding Invoices,Kreiraj neplaćene račune
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Sales Order {0} is not valid,Prodajnog naloga {0} nije ispravan
DocType: Supplier Scorecard,Warn for new Request for Quotations,Upozorenje za novi zahtjev za ponudu
apps/erpnext/erpnext/utilities/activation.py,Purchase orders help you plan and follow up on your purchases,Narudžbenice vam pomoći planirati i pratiti na Vašoj kupnji
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Lab Test Prescriptions,Ispitivanje laboratorijskih ispitivanja
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}",Ukupna količina Pitanje / Prijenos {0} u materijalnim Zahtjevu {1} \ ne može biti veća od tražene količine {2} za točki {3}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Small,Mali
DocType: Shopify Settings,"If Shopify not contains a customer in Order, then while syncing Orders, the system will consider default customer for order","Ako Shopify ne sadrži naručitelja u narudžbi, sustav će tijekom sinkronizacije narudžbi uzeti u obzir zadani klijent za narudžbu"
DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Stavka Alata za stvaranje fakture otvaranja
DocType: Cashier Closing Payments,Cashier Closing Payments,Blagajna isplata blagajnika
DocType: Education Settings,Employee Number,Broj zaposlenika
DocType: Subscription Settings,Cancel Invoice After Grace Period,Otkažite fakturu nakon razdoblja odgode
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Case No(s) already in use. Try from Case No {0},Slučaj Ne ( i) je već u uporabi . Pokušajte s predmetu broj {0}
DocType: Project,% Completed,% Kompletirano
,Invoiced Amount (Exculsive Tax),Dostavljeni iznos ( Exculsive poreza )
DocType: Asset Finance Book,Rate of Depreciation,Stopa amortizacije
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Serial Numbers,Serijski brojevi
apps/erpnext/erpnext/controllers/stock_controller.py,Row {0}: Quality Inspection rejected for item {1},Redak {0}: Odbačena inspekcija kvalitete za stavku {1}
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 2,Stavka 2
DocType: Pricing Rule,Validate Applied Rule,Potvrdite primijenjeno pravilo
DocType: QuickBooks Migrator,Authorization Endpoint,Endpoint autorizacije
DocType: Employee Onboarding,Notify users by email,Obavijestite korisnike e-poštom
DocType: Travel Request,International,međunarodna
DocType: Training Event,Training Event,Događaj za obuku
DocType: Item,Auto re-order,Automatski reorganiziraj
DocType: Attendance,Late Entry,Kasni ulazak
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Total Achieved,Ukupno Ostvareno
DocType: Employee,Place of Issue,Mjesto izdavanja
DocType: Promotional Scheme,Promotional Scheme Price Discount,Popust na cijene promotivne sheme
DocType: Contract,Contract,ugovor
DocType: GSTR 3B Report,May,Svibanj
DocType: Plant Analysis,Laboratory Testing Datetime,Laboratorijsko ispitivanje Datetime
DocType: Email Digest,Add Quote,Dodaj ponudu
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,UOM coversion factor required for UOM: {0} in Item: {1},UOM faktor coversion potrebna za UOM: {0} u točki: {1}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Indirect Expenses,Neizravni troškovi
apps/erpnext/erpnext/controllers/selling_controller.py,Row {0}: Qty is mandatory,Red {0}: Količina je obvezno
DocType: Agriculture Analysis Criteria,Agriculture,Poljoprivreda
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Sales Order,Izradi prodajni nalog
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Accounting Entry for Asset,Računovodstveni unos za imovinu
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Block Invoice,Blokirajte fakturu
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Quantity to Make,Količina za izradu
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Master Data,Sync Master Data
DocType: Asset Repair,Repair Cost,Popravak troškova
apps/erpnext/erpnext/utilities/user_progress.py,Your Products or Services,Vaši proizvodi ili usluge
DocType: Quality Meeting Table,Under Review,U pregledu
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Prijava nije uspjela
apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Izrađen je element {0}
DocType: Special Test Items,Special Test Items,Posebne ispitne stavke
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.,Morate biti korisnik s ulogama upravitelja sustava i upravitelja stavki da biste se registrirali na tržištu.
apps/erpnext/erpnext/config/buying.py,Key Reports,Ključna izvješća
DocType: Bank Statement Transaction Payment Item,Mode of Payment,Način plaćanja
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,As per your assigned Salary Structure you cannot apply for benefits,Prema vašoj dodijeljenoj Strukturi plaća ne možete podnijeti zahtjev za naknadu
apps/erpnext/erpnext/stock/doctype/item/item.py,Website Image should be a public file or website URL,Web slika bi trebala biti javna datoteke ili URL web stranice
DocType: Purchase Invoice Item,BOM,BOM
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,This is a root item group and cannot be edited.,To jekorijen stavka grupa i ne može se mijenjati .
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge,Sjediniti
DocType: Journal Entry Account,Purchase Order,Narudžbenica
DocType: Vehicle,Fuel UOM,Gorivo UOM
DocType: Warehouse,Warehouse Contact Info,Kontakt informacije skladišta
DocType: Payment Entry,Write Off Difference Amount,Otpis razlika visine
DocType: Volunteer,Volunteer Name,Ime volontera
apps/erpnext/erpnext/controllers/accounts_controller.py,Rows with duplicate due dates in other rows were found: {0},Nađeno je redaka s datumima duplikata u drugim redcima: {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,"{0}: Employee email not found, hence email not sent","{0}: Radnik email nije pronađen, stoga ne e-mail poslan"
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,No Salary Structure assigned for Employee {0} on given date {1},Struktura plaće nije dodijeljena za zaposlenika {0} na određeni datum {1}
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule not applicable for country {0},Pravilo isporuke nije primjenjivo za zemlju {0}
DocType: Item,Foreign Trade Details,Vanjskotrgovinska Detalji
,Assessment Plan Status,Status plana procjene
DocType: Email Digest,Annual Income,Godišnji prihod
DocType: Serial No,Serial No Details,Serijski nema podataka
DocType: Purchase Invoice Item,Item Tax Rate,Porezna stopa proizvoda
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Party Name,Od imena stranke
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Net Salary Amount,Neto iznos plaće
DocType: Pick List,Delivery against Sales Order,Dostava protiv prodajnog naloga
DocType: Student Group Student,Group Roll Number,Broj grupe grupa
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"For {0}, only credit accounts can be linked against another debit entry","Za {0}, samo kreditne računi se mogu povezati protiv drugog ulaska debitnom"
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Delivery Note {0} is not submitted,Otpremnica {0} nije potvrđena
apps/erpnext/erpnext/stock/get_item_details.py,Item {0} must be a Sub-contracted Item,Stavka {0} mora bitisklopljen ugovor artikla
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Capital Equipments,Kapitalni 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.","Cijene Pravilo prvo se bira na temelju 'Nanesite na' terenu, koji može biti točka, točka Grupa ili Brand."
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Please set the Item Code first,Najprije postavite šifru stavke
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc tip
apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Ukupno dodijeljeno postotak za prodajni tim bi trebao biti 100
DocType: Subscription Plan,Billing Interval Count,Brojač intervala naplate
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Imenovanja i susreta pacijenata
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Nedostaje vrijednost
DocType: Employee,Department and Grade,Odjel i ocjena
DocType: Antibiotic,Antibiotic,Antibiotik
,Team Updates,tim ažuriranja
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,For Supplier,za Supplier
DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Postavljanje Vrsta računa pomaže u odabiru ovaj račun u prometu.
DocType: Purchase Invoice,Grand Total (Company Currency),Sveukupno (valuta tvrtke)
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Create Print Format,Stvaranje format ispisa
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Created,Kreirana naknada
apps/erpnext/erpnext/utilities/bot.py,Did not find any item called {0},Niste pronašli bilo koju stavku pod nazivom {0}
apps/erpnext/erpnext/stock/report/item_prices/item_prices.js,Items Filter,Filtri stavki
DocType: Supplier Scorecard Criteria,Criteria Formula,Formula kriterija
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Total Outgoing,Ukupno odlazni
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""","Tu može biti samo jedan Dostava Pravilo Stanje sa 0 ili prazni vrijednost za "" Da Value """
DocType: Bank Statement Transaction Settings Item,Transaction,Transakcija
DocType: Call Log,Duration,Trajanje
apps/erpnext/erpnext/controllers/status_updater.py,"For an item {0}, quantity must be positive number","Za stavku {0}, količina mora biti pozitivan broj"
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Napomena : Ovaj troškovni centar je grupa. Nije moguće napraviti računovodstvene unose od grupe.
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Compensatory leave request days not in valid holidays,Doplativi dopusti za dane naplate nisu u važećem odmoru
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Child warehouse exists for this warehouse. You can not delete this warehouse.,Dijete skladište postoji za ovaj skladište. Ne možete izbrisati ovaj skladište.
DocType: Item,Website Item Groups,Grupe proizvoda web stranice
DocType: Purchase Invoice,Total (Company Currency),Ukupno (Društvo valuta)
DocType: Daily Work Summary Group,Reminder,Podsjetnik
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Accessable Value,Pristupačna vrijednost
apps/erpnext/erpnext/stock/utils.py,Serial number {0} entered more than once,Serijski broj {0} ušao više puta
DocType: Bank Statement Transaction Invoice Item,Journal Entry,Temeljnica
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From GSTIN,Od GSTIN-a
DocType: Expense Claim Advance,Unclaimed amount,Neotkriveni iznos
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items in progress,{0} stavke u tijeku
DocType: Workstation,Workstation Name,Ime Workstation
DocType: Grading Scale Interval,Grade Code,Grade Šifra
DocType: POS Item Group,POS Item Group,POS Točka Grupa
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,Email Digest:,E-pošta:
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Alternative item must not be same as item code,Alternativna stavka ne smije biti jednaka kodu stavke
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} does not belong to Item {1},BOM {0} ne pripada Točki {1}
DocType: Promotional Scheme,Product Discount Slabs,Ploče s popustom na proizvode
DocType: Target Detail,Target Distribution,Ciljana Distribucija
DocType: Purchase Invoice,06-Finalization of Provisional assessment,06-Finalizacija privremene procjene
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Parties and Addresses,Uvoz stranaka i adresa
DocType: Salary Slip,Bank Account No.,Žiro račun broj
DocType: Naming Series,This is the number of the last created transaction with this prefix,To je broj zadnjeg stvorio transakcije s ovim prefiksom
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)
","Mogu se koristiti varijable tablice s rezultatima, kao i: {total_score} (ukupni rezultat iz tog razdoblja), {period_number} (broj razdoblja do današnjeg dana)"
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Purchase Order,Izradi narudžbenicu
DocType: Quality Inspection Reading,Reading 8,Čitanje 8
DocType: Inpatient Record,Discharge Note,Napomena za pražnjenje
apps/erpnext/erpnext/config/desktop.py,Getting Started,Početak rada
DocType: Purchase Invoice,Taxes and Charges Calculation,Porezi i naknade Proračun
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Automatski ulazi u amortizaciju imovine u knjizi
DocType: BOM Operation,Workstation,Radna stanica
DocType: Request for Quotation Supplier,Request for Quotation Supplier,Zahtjev za ponudu dobavljača
DocType: Healthcare Settings,Registration Message,Poruka o registraciji
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Hardware,Hardver
DocType: Prescription Dosage,Prescription Dosage,Doziranje na recept
DocType: Contract,HR Manager,HR menadžer
apps/erpnext/erpnext/accounts/party.py,Please select a Company,Odaberite tvrtku
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Privilege Leave,Privilege dopust
DocType: Purchase Invoice,Supplier Invoice Date,Dobavljač Datum fakture
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,You need to enable Shopping Cart,Morate omogućiti košaricu
DocType: Payment Entry,Writeoff,Otpisati
DocType: Maintenance Visit,MAT-MVS-.YYYY.-,MAT-MVS-.YYYY.-
DocType: HR Settings,<b>Example:</b> SAL-{first_name}-{date_of_birth.year} <br>This will generate a password like SAL-Jane-1972,<b>Primjer:</b> SAL- {prvo ime} - {datum_of_birth.god.} <br> Ovo će generirati lozinku poput SAL-Jane-1972
DocType: Stock Settings,Naming Series Prefix,Imenujte prefiks serije
DocType: Appraisal Template Goal,Appraisal Template Goal,Procjena Predložak cilja
DocType: Salary Component,Earning,Zarada
DocType: Supplier Scorecard,Scoring Criteria,Kriteriji za bodovanje
DocType: Purchase Invoice,Party Account Currency,Strana valuta računa
DocType: Delivery Trip,Total Estimated Distance,Ukupna procijenjena udaljenost
DocType: Invoice Discounting,Accounts Receivable Unpaid Account,Neplaćeni račun za potraživanja
DocType: Tally Migration,Tally Company,Tally Company
apps/erpnext/erpnext/config/manufacturing.py,BOM Browser,BOM preglednik
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py,Not allowed to create accounting dimension for {0},Nije dopušteno stvaranje računovodstvenih dimenzija za {0}
apps/erpnext/erpnext/templates/emails/training_event.html,Please update your status for this training event,Ažurirajte svoj status za ovaj trening događaj
DocType: Item Barcode,EAN,EAN
DocType: Purchase Taxes and Charges,Add or Deduct,Zbrajanje ili oduzimanje
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Overlapping conditions found between:,Preklapanje uvjeti nalaze između :
DocType: Bank Transaction Mapping,Field in Bank Transaction,Polje u bankovnoj transakciji
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Against Journal Entry {0} is already adjusted against some other voucher,Protiv Temeljnica {0} već usklađuje se neki drugi bon
,Inactive Sales Items,Neaktivni predmeti prodaje
DocType: Quality Review,Additional Information,dodatne informacije
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Total Order Value,Ukupna vrijednost narudžbe
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,Starenje Raspon 3
DocType: POS Closing Voucher Details,POS Closing Voucher Details,Detalji o voucheru za zatvaranje POS-a
DocType: Bank Account,Is the Default Account,Je li zadani račun
DocType: Shopify Log,Shopify Log,Zapisnik trgovine
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,No communication found.,Nije pronađena komunikacija.
DocType: Inpatient Occupancy,Check In,Prijava
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Create Payment Entry,Izradite unos plaćanja
DocType: Maintenance Schedule Item,No of Visits,Broj pregleda
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance Schedule {0} exists against {1},Raspored održavanja {0} postoji protiv {1}
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Enrolling student,upisa studenata
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Currency of the Closing Account must be {0},Valuta zatvaranja računa 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 preklapa sa {0}. <br> {1} zakazan je sastanak sa {2} u {3} s trajanjem {4} minuta.
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py,Sum of points for all goals should be 100. It is {0},Zbroj bodova svih ciljeva trebao biti 100. To je {0}
DocType: Project,Start and End Dates,Datumi početka i završetka
DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Uvjeti ispunjenja predloška ugovora
,Delivered Items To Be Billed,Isporučeni proizvodi za naplatiti
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Otvoreno BOM {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Skladište se ne može promijeniti za serijskog broja
DocType: Authorization Rule,Average Discount,Prosječni popust
DocType: Pricing Rule,UOM,UOM
DocType: Employee Tax Exemption Declaration,Annual HRA Exemption,Godišnje izuzeće HRA-e
DocType: Rename Tool,Utilities,Komunalne usluge
DocType: POS Profile,Accounting,Knjigovodstvo
DocType: Asset,Purchase Receipt Amount,Iznos priznavanja kupnje
DocType: Employee Separation,Exit Interview Summary,Izlaz iz sažetka intervjua
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select batches for batched item ,Odaberite serije za umetnutu stavku
DocType: Asset,Depreciation Schedules,amortizacija Raspored
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Sales Invoice,Stvorite račun za prodaju
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Ineligible ITC,Neprihvatljiv ITC
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py,"Support for public app is deprecated. Please setup private app, for more details refer user manual","Podrška za javnu aplikaciju je obustavljena. Postavite privatnu aplikaciju, a više pojedinosti potražite u korisničkom priručniku"
DocType: Task,Dependent Tasks,Zavisni zadaci
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Following accounts might be selected in GST Settings:,Sljedeći računi mogu biti odabrani u GST postavkama:
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js,Quantity to Produce,Količina za proizvodnju
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Application period cannot be outside leave allocation period,Razdoblje prijava ne može biti izvan dopusta raspodjele
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,Neke e-poruke nisu važeće
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 možete promijeniti fiskalnu godinu datum početka i datum završetka fiskalne godine kada Fiskalna godina se sprema.
DocType: Quotation,Shopping Cart,Košarica
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Avg Daily Outgoing,Prosječni dnevni izlaz
DocType: POS Profile,Campaign,Kampanja
DocType: Supplier,Name and Type,Naziv i tip
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Item Reported,Stavka prijavljena
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Approval Status must be 'Approved' or 'Rejected',"Status Odobrenje mora biti ""Odobreno"" ili "" Odbijeno """
DocType: Healthcare Practitioner,Contacts and Address,Kontakti i adresa
DocType: Shift Type,Determine Check-in and Check-out,Odredite prijavu i odjavu
DocType: Salary Structure,Max Benefits (Amount),Maksimalna korist (iznos)
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Add notes,Dodajte bilješke
DocType: Purchase Invoice,Contact Person,Kontakt osoba
apps/erpnext/erpnext/projects/doctype/task/task.py,'Expected Start Date' can not be greater than 'Expected End Date',Očekivani datum početka ne može biti veći od očekivanog datuma završetka
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,No data for this period,Nema podataka za ovo razdoblje
DocType: Course Scheduling Tool,Course End Date,Naravno Datum završetka
DocType: Holiday List,Holidays,Praznici
DocType: Sales Order Item,Planned Quantity,Planirana količina
DocType: Water Analysis,Water Analysis Criteria,Kriteriji analize vode
DocType: Item,Maintain Stock,Upravljanje zalihama
DocType: Terms and Conditions,Applicable Modules,Primjenjivi moduli
DocType: Employee,Prefered Email,Poželjni Email
DocType: Student Admission,Eligibility and Details,Podobnost i pojedinosti
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Included in Gross Profit,Uključeno u bruto dobit
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Fixed Asset,Neto promjena u dugotrajne imovine
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,Punjenje tipa ' Stvarni ' u redu {0} ne mogu biti uključeni u točki Rate
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Max: {0},Maksimalno: {0}
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py,From Datetime,Od datetime
DocType: Shopify Settings,For Company,Za tvrtke
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.","Zahtjev za ponudu je onemogućen pristup sa portala, za više postavki provjere portal."
DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Dobavljačka tabela ocjena varijable
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Buying Amount,Iznos kupnje
DocType: POS Closing Voucher,Modes of Payment,Načini plaćanja
DocType: Sales Invoice,Shipping Address Name,Dostava Adresa Ime
apps/erpnext/erpnext/accounts/doctype/account/account.js,Chart of Accounts,Kontni plan
DocType: Material Request,Terms and Conditions Content,Uvjeti sadržaj
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,There were errors creating Course Schedule,Došlo je do pogrešaka prilikom izrade tečaja Raspored
DocType: Communication Medium,Timeslots,vremenskih isječaka
DocType: Department,The first Expense Approver in the list will be set as the default Expense Approver.,Prvi Odrednik odobrenja u popisu će biti postavljen kao zadani odobrenje troškova.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,cannot be greater than 100,ne može biti veće od 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.,Morate biti korisnik koji nije administrator s ulogama upravitelja sustava i upravitelja stavki da biste se registrirali na tržištu.
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is not a stock Item,Proizvod {0} nije skladišni proizvod
DocType: Packing Slip,MAT-PAC-.YYYY.-,MAT-PAC-.YYYY.-
DocType: Maintenance Visit,Unscheduled,Neplanski
DocType: Employee,Owned,U vlasništvu
DocType: Pricing Rule,"Higher the number, higher the priority","Veći broj, veći prioritet"
,Purchase Invoice Trends,Trendovi nabavnih računa
apps/erpnext/erpnext/www/all-products/not_found.html,No products found,Nije pronađen nijedan proizvod
DocType: Employee,Better Prospects,Bolji izgledi
DocType: Travel Itinerary,Gluten Free,Bez glutena
DocType: Loyalty Program Collection,Minimum Total Spent,Minimalno ukupno potrošeno
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","Red # {0}: Šarža {1} ima samo {2} qty. Odaberite drugu seriju koja ima {3} količinu dostupnu ili razdijelite red u više redaka, kako biste ih isporučili / izdali iz više šarži"
DocType: Loyalty Program,Expiry Duration (in days),Trajanje isteka (u danima)
DocType: Inpatient Record,Discharge Date,Datum izdavanja
DocType: Subscription Plan,Price Determination,Određivanje cijene
DocType: Vehicle,License Plate,registarska tablica
apps/erpnext/erpnext/hr/doctype/department/department_tree.js,New Department,Novi odjel
DocType: Compensatory Leave Request,Worked On Holiday,Radili na odmoru
DocType: Appraisal,Goals,Golovi
DocType: Support Settings,Allow Resetting Service Level Agreement,Dopustite resetiranje sporazuma o razini usluge
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Select POS Profile,Odaberite POS profil
DocType: Warranty Claim,Warranty / AMC Status,Jamstveni / AMC Status
,Accounts Browser,Preglednik računa
DocType: Procedure Prescription,Referral,upućivanje
DocType: Payment Entry Reference,Payment Entry Reference,Plaćanje Ulaz Referenca
DocType: GL Entry,GL Entry,GL ulaz
DocType: Support Search Source,Response Options,Opcije odgovora
DocType: Pricing Rule,Apply Multiple Pricing Rules,Primijenite više pravila o cijenama
DocType: HR Settings,Employee Settings,Postavke zaposlenih
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.html,Loading Payment System,Učitavanje sustava plaćanja
,Batch-Wise Balance History,Batch-Wise povijest bilance
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,Redak # {0}: Nije moguće postaviti stopu ako je iznos veći od naplaćenog iznosa za stavku {1}.
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Print settings updated in respective print format,Postavke ispisa ažurirana u odgovarajućem formatu za ispis
DocType: Package Code,Package Code,kod paketa
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Apprentice,šegrt
DocType: Purchase Invoice,Company GSTIN,Tvrtka GSTIN
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Negative Quantity is not allowed,Negativna količina nije dopuštena
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges","Porezna detalj Tablica preuzeta iz točke majstora kao string i pohranjeni u tom području.
 Koristi se za poreze i troškove"
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Employee cannot report to himself.,Zaposlenik se ne može prijaviti na sebe.
apps/erpnext/erpnext/templates/pages/order.html,Rate:,Stopa:
DocType: Bank Account,Change this date manually to setup the next synchronization start date,Ručno promijenite ovaj datum da biste postavili sljedeći datum početka sinkronizacije
DocType: Leave Type,Max Leaves Allowed,Maksimalno dopušteno lišće
DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Ako je račun zamrznut , unosi dopušteno ograničene korisnike ."
DocType: Email Digest,Bank Balance,Bankovni saldo
apps/erpnext/erpnext/controllers/accounts_controller.py,Accounting Entry for {0}: {1} can only be made in currency: {2},Računovodstvo Ulaz za {0}: {1} može biti samo u valuti: {2}
DocType: HR Settings,Leave Approver Mandatory In Leave Application,Odustani od odobrenja Obvezni zahtjev za napuštanje
DocType: Job Opening,"Job profile, qualifications required etc.","Profil posla, tražene kvalifikacije i sl."
DocType: Journal Entry Account,Account Balance,Bilanca računa
apps/erpnext/erpnext/config/accounting.py,Tax Rule for transactions.,Porezni Pravilo za transakcije.
DocType: Rename Tool,Type of document to rename.,Vrsta dokumenta za promjenu naziva.
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Resolve error and upload again.,Riješite pogrešku i prenesite ponovo.
DocType: Buying Settings,Over Transfer Allowance (%),Naknada za prebacivanje prijenosa (%)
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Customer is required against Receivable account {2},{0} {1}: potrebna je Kupac protiv Potraživanja računa {2}
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Ukupno Porezi i naknade (Društvo valuta)
DocType: Weather,Weather Parameter,Parametar vremena
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Show unclosed fiscal year's P&L balances,Prikaži nezatvorena fiskalne godine u P &amp; L stanja
DocType: Item,Asset Naming Series,Serija imenovanja imovine
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 iznajmljenih kuća trebaju biti najmanje 15 dana
DocType: Clinical Procedure Template,Collection Details,Detalji zbirke
DocType: POS Profile,Allow Print Before Pay,Dopusti ispis prije plaćanja
DocType: Linked Soil Texture,Linked Soil Texture,Povezana tekstura tla
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} nije aktivan
DocType: GSTR 3B Report,March,ožujak
DocType: Bank Statement Transaction Entry,Bank Transaction Entries,Unosi bankovnih transakcija
DocType: Quality Inspection,Readings,Očitanja
DocType: Stock Entry,Total Additional Costs,Ukupno Dodatni troškovi
DocType: Quality Action,Quality Action,Kvalitetna akcija
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,No of Interactions,Broj interakcija
DocType: BOM,Scrap Material Cost(Company Currency),Škarta Cijena (Društvo valuta)
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,"Set Start Time and End Time for  \
					Support Day {0} at index {1}.",Podesite vrijeme početka i završetka za \ Dan podrške {0} na indeksu {1}.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Sub Assemblies,pod skupštine
DocType: Asset,Asset Name,Naziv imovinom
DocType: Employee Boarding Activity,Task Weight,Zadatak Težina
DocType: Shipping Rule Condition,To Value,Za vrijednost
DocType: Accounts Settings,Automatically Add Taxes and Charges from Item Tax Template,Automatski dodajte poreze i pristojbe sa predloška poreza na stavke
DocType: Loyalty Program,Loyalty Program Type,Vrsta programa vjernosti
DocType: Asset Movement,Stock Manager,Stock Manager
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Source warehouse is mandatory for row {0},Izvor skladište je obvezno za redom {0}
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,The Payment Term at row {0} is possibly a duplicate.,Plaćanje u redu {0} vjerojatno je duplikat.
apps/erpnext/erpnext/public/js/setup_wizard.js,Agriculture (beta),Poljoprivreda (beta)
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Packing Slip,Odreskom
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Rent,Najam ureda
apps/erpnext/erpnext/config/settings.py,Setup SMS gateway settings,Postavke SMS pristupnika
DocType: Disease,Common Name,Uobičajeno ime
DocType: Customer Feedback Template Table,Customer Feedback Template Table,Tablica predloška za povratne informacije kupaca
DocType: Employee Boarding Activity,Employee Boarding Activity,Aktivnost ukrcavanja zaposlenika
apps/erpnext/erpnext/public/js/templates/address_list.html,No address added yet.,Adresa još nije dodana.
DocType: Workstation Working Hour,Workstation Working Hour,Workstation Radno vrijeme
DocType: Vital Signs,Blood Pressure,Krvni tlak
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Analyst,analitičar
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,{0} is not in a valid Payroll Period,{0} nije u važećem razdoblju obračuna plaća
DocType: Employee Benefit Application,Max Benefits (Yearly),Najveće pogodnosti (godišnje)
DocType: Item,Inventory,Inventar
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Preuzmi kao Json
DocType: Item,Sales Details,Prodajni detalji
DocType: Opportunity,With Items,S Stavke
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampanja &quot;{0}&quot; već postoji za {1} &quot;{2}&quot;
DocType: Asset Maintenance,Maintenance Team,Tim za održavanje
DocType: Homepage Section,"Order in which sections should appear. 0 is first, 1 is second and so on.","Redoslijed u kojim će se odjeljcima pojaviti. 0 je prvo, 1 je drugo i tako dalje."
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,In Qty,u kol
DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Validirati upisani tečaj za studente u studentskoj grupi
DocType: Item,Item Attribute,Stavka značajke
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,Rashodi Zatraži {0} već postoji za vozila Prijava
DocType: Asset Movement,Source Location,Izvor lokacije
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Name,Naziv Institut
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter repayment Amount,Unesite iznos otplate
DocType: Shift Type,Working Hours Threshold for Absent,Prag radnog vremena za odsutne
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.,Može postojati višestruki skupni faktor zbirke na temelju ukupnog utrošenog. Ali pretvorbeni faktor za iskupljenje uvijek će biti isti za cijelu razinu.
apps/erpnext/erpnext/config/help.py,Item Variants,Stavka Varijante
apps/erpnext/erpnext/public/js/setup_wizard.js,Services,Usluge
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,E-mail Plaća proklizavanja zaposlenog
DocType: Cost Center,Parent Cost Center,Nadređeni troškovni centar
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Create Invoices,Stvorite fakture
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Select Possible Supplier,Odaberite Mogući Dobavljač
DocType: Communication Medium,Communication Medium Type,Komunikacijski medij
DocType: Customer,"Select, to make the customer searchable with these fields","Odaberite, kako bi korisnik mogao pretraživati s tim poljima"
DocType: Shopify Settings,Import Delivery Notes from Shopify on Shipment,Uvoz isporuke o isporuci iz trgovine na pošiljci
apps/erpnext/erpnext/templates/pages/projects.html,Show closed,Prikaži zatvorene
DocType: Issue Priority,Issue Priority,Prioritet pitanja
DocType: Leave Ledger Entry,Is Leave Without Pay,Je Ostavite bez plaće
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,GSTIN,GSTIN
apps/erpnext/erpnext/stock/doctype/item/item.py,Asset Category is mandatory for Fixed Asset item,Asset Kategorija je obvezna za nepokretnu stavke imovine
DocType: Fee Validity,Fee Validity,Valjanost naknade
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,No records found in the Payment table,Nisu pronađeni zapisi u tablici plaćanja
apps/erpnext/erpnext/education/utils.py,This {0} conflicts with {1} for {2} {3},To {0} sukobi s {1} od {2} {3}
DocType: Student Attendance Tool,Students HTML,Studenti HTML
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,{0}: {1} must be less than {2},{0}: {1} mora biti manji od {2}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,"Select BOM, Qty and For Warehouse","Odaberite BOM, Qty i za skladište"
DocType: GST HSN Code,GST HSN Code,GST HSN kod
DocType: Employee External Work History,Total Experience,Ukupno Iskustvo
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Projects,Otvoreno Projekti
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Packing Slip(s) cancelled,Pakiranje proklizavanja ( s) otkazan
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Investing,Novčani tijek iz investicijskih
DocType: Program Course,Program Course,Program predmeta
DocType: Healthcare Service Unit,Allow Appointments,Omogući imenovanja
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Freight and Forwarding Charges,Teretni i Forwarding Optužbe
DocType: Homepage,Company Tagline for website homepage,Tvrtka Opisna oznaka za web stranici
DocType: Item Group,Item Group Name,Proizvod - naziv grupe
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,Taken,Taken
DocType: Invoice Discounting,Short Term Loan Account,Kratkoročni račun zajma
DocType: Student,Date of Leaving,Datum Napuštanje
DocType: Pricing Rule,For Price List,Za cjenik
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Executive Search,Executive Search
DocType: Employee Advance,HR-EAD-.YYYY.-,HR-EAD-.YYYY.-
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Setting defaults,Postavljanje zadanih postavki
DocType: Loyalty Program,Auto Opt In (For all customers),Automatsko uključivanje (za sve korisnike)
apps/erpnext/erpnext/utilities/activation.py,Create Leads,Stvaranje vodi
DocType: Maintenance Schedule,Schedules,Raspored
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,POS Profile is required to use Point-of-Sale,POS Profil je potreban za korištenje Point-of-Sale
DocType: Cashier Closing,Net Amount,Neto Iznos
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} has not been submitted so the action cannot be completed,{0} {1} nije poslano tako da se radnja ne može dovršiti
DocType: Purchase Order Item Supplied,BOM Detail No,BOM detalji - broj
DocType: Landed Cost Voucher,Additional Charges,Dodatni troškovi
DocType: Support Search Source,Result Route Field,Polje rute rezultata
DocType: Supplier,PAN,PAN
DocType: Employee Checkin,Log Type,Vrsta zapisa
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Dodatni popust Iznos (valuta Društvo)
DocType: Supplier Scorecard,Supplier Scorecard,Dobavljač ocjena
DocType: Plant Analysis,Result Datetime,Rezultat Datetime
,Support Hour Distribution,Distribucija rasporeda podrške
DocType: Maintenance Visit,Maintenance Visit,Održavanje Posjetite
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Close Loan,Zatvori zajam
DocType: Student,Leaving Certificate Number,Ostavljajući broj certifikata
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,"Appointment cancelled, Please review and cancel the invoice {0}","Imenovanje otkazano, pregledajte i otkazite fakturu {0}"
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Dostupno Batch Količina na skladištu
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Update Print Format,Ažuriranje Format ispisa
DocType: Bank Account,Is Company Account,Je li račun tvrtke
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,Leave Type {0} is not encashable,Vrsta napuštanja {0} nije moguće naplatiti
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Credit limit is already defined for the Company {0},Kreditni limit je već definiran za Društvo {0}
DocType: Landed Cost Voucher,Landed Cost Help,Zavisni troškovi - Pomoć
DocType: Vehicle Log,HR-VLOG-.YYYY.-,HR-Vlogu-.YYYY.-
DocType: Purchase Invoice,Select Shipping Address,Odaberite Adresa za dostavu
DocType: Timesheet Detail,Expected Hrs,Očekivani sati
apps/erpnext/erpnext/config/non_profit.py,Memebership Details,Pojedinosti o članstvu
DocType: Leave Block List,Block Holidays on important days.,Blok Odmor na važnim danima.
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Please input all required Result Value(s),Unesite sve potrebne vrijednosti rezultata
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Accounts Receivable Summary,Potraživanja Sažetak
DocType: POS Closing Voucher,Linked Invoices,Povezane fakture
DocType: Loan,Monthly Repayment Amount,Mjesečni iznos otplate
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices,Otvori računa
DocType: Contract,Contract Details,Pojedinosti ugovora
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please set User ID field in an Employee record to set Employee Role,Molimo postavite korisnički ID polje u zapisu zaposlenika za postavljanje uloga zaposlenika
DocType: UOM,UOM Name,UOM Ime
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 1,Adresa 1
DocType: GST HSN Code,HSN Code,HSN kod
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution Amount,Doprinos iznos
DocType: Homepage Section,Section Order,Redoslijed odjeljka
DocType: Inpatient Record,Patient Encounter,Pacijentni susret
DocType: Accounts Settings,Shipping Address,Dostava Adresa
DocType: Stock Reconciliation,This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,Ovaj alat pomaže vam da ažurirate ili popraviti količinu i vrijednost zaliha u sustavu. To se obično koristi za sinkronizaciju vrijednosti sustava i što se zapravo postoji u svojim skladištima.
DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,Riječima će biti vidljivo nakon što spremite otpremnicu.
apps/erpnext/erpnext/erpnext_integrations/utils.py,Unverified Webhook Data,Neprovjereni podaci webhook podataka
DocType: Water Analysis,Container,kontejner
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Please set valid GSTIN No. in Company Address,Molimo postavite važeći GSTIN broj na adresi tvrtke
apps/erpnext/erpnext/education/utils.py,Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} pojavljuje više puta u nizu {2} {3}
DocType: Item Alternative,Two-way,Dvosmjeran
DocType: Item,Manufacturers,Proizvođači
apps/erpnext/erpnext/accounts/deferred_revenue.py,Error while processing deferred accounting for {0},Pogreška tijekom obrade odgođenog računovodstva za {0}
,Employee Billing Summary,Sažetak naplate zaposlenika
DocType: Project,Day to Send,Dan za slanje
DocType: Healthcare Settings,Manage Sample Collection,Upravljanje uzorkovanjem
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set the series to be used.,Postavite seriju koja će se koristiti.
DocType: Patient,Tobacco Past Use,Doba korištenja
DocType: Travel Itinerary,Mode of Travel,Način putovanja
DocType: Sales Invoice Item,Brand Name,Naziv brenda
DocType: Purchase Receipt,Transporter Details,Transporter Detalji
DocType: Issue,Service Level Agreement Creation,Izrada sporazuma o razini usluge
apps/erpnext/erpnext/accounts/page/pos/pos.js,Default warehouse is required for selected item,Default skladište je potreban za odabranu stavku
DocType: Quiz,Passing Score,Prolazni rezultat
apps/erpnext/erpnext/utilities/user_progress.py,Box,kutija
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Possible Supplier,Mogući Dobavljač
DocType: Budget,Monthly Distribution,Mjesečna distribucija
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Receiver List is empty. Please create Receiver List,Receiver Lista je prazna . Molimo stvoriti Receiver Popis
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,Nevažeći GSTIN! Uneseni unos ne odgovara formatu GSTIN za vlasnike UIN-a ili nerezidentne davatelje usluga OIDAR-a
apps/erpnext/erpnext/public/js/setup_wizard.js,Healthcare (beta),Zdravstvo (beta)
DocType: Production Plan Sales Order,Production Plan Sales Order,Proizvodnja plan prodajnog naloga
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"No active BOM found for item {0}. Delivery by \
						Serial No cannot be ensured",Nije pronađena aktivna BOM za stavku {0}. Dostava po \ Serial No ne može se osigurati
DocType: Sales Partner,Sales Partner Target,Prodajni plan prodajnog partnera
DocType: Loan Type,Maximum Loan Amount,Maksimalni iznos kredita
DocType: Pricing Rule,Pricing Rule,Pravila cijena
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplikat broja valjaka za učenika {0}
apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Materijal Zahtjev za Narudžbenica
DocType: Company,Default Selling Terms,Zadani uvjeti prodaje
DocType: Shopping Cart Settings,Payment Success URL,Plaćanje Uspjeh URL
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Returned Item {1} does not exists in {2} {3},Red # {0}: Vraćeno Stavka {1} ne postoji u {2} {3}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Bank Accounts,Bankovni računi
,Bank Reconciliation Statement,Izjava banka pomirenja
DocType: Patient Encounter,Medical Coding,Medicinski kodiranje
DocType: Healthcare Settings,Reminder Message,Poruka podsjetnika
DocType: Call Log,Lead Name,Ime potencijalnog kupca
,POS,POS
DocType: C-Form,III,III
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Prospecting,Ležišta
apps/erpnext/erpnext/config/help.py,Opening Stock Balance,Otvaranje kataloški bilanca
DocType: Asset Category Account,Capital Work In Progress Account,Račun za kapitalni rad u tijeku
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Value Adjustment,Podešavanje vrijednosti imovine
DocType: Additional Salary,Payroll Date,Datum plaće
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,{0} must appear only once,{0} mora pojaviti samo jednom
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,Leaves Allocated Successfully for {0},Odsustvo uspješno dodijeljeno za {0}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,No Items to pack,Nema proizvoda 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 su podržane samo .csv i .xlsx datoteke
DocType: Shipping Rule Condition,From Value,Od Vrijednost
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Manufacturing Quantity is mandatory,Proizvedena količina je obvezna
DocType: Loan,Repayment Method,Način otplate
DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Ako je označeno, početna stranica će biti zadana točka Grupa za web stranicu"
DocType: Quality Inspection Reading,Reading 4,Čitanje 4
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Pending Quantity,Količina na čekanju
apps/erpnext/erpnext/utilities/activation.py,"Students are at the heart of the system, add all your students","Studenti se u središtu sustava, dodati sve svoje studente"
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Member ID,članska iskaznica
DocType: Employee Tax Exemption Proof Submission,Monthly Eligible Amount,Mjesečni prihvatljivi iznos
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Red # {0}: Datum Razmak {1} ne može biti prije Ček Datum {2}
DocType: Asset Maintenance Task,Certificate Required,Potvrda je potrebna
DocType: Company,Default Holiday List,Default odmor List
DocType: Pricing Rule,Supplier Group,Grupa dobavljača
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,{0} Digest,{0} Digest
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0}: From Time and To Time of {1} is overlapping with {2},Red {0}: S vremena i na vrijeme od {1} je preklapanje s {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Liabilities,Stock Obveze
DocType: Purchase Invoice,Supplier Warehouse,Dobavljač galerija
DocType: Opportunity,Contact Mobile No,Kontak GSM
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Select Company,Odaberite tvrtku
,Material Requests for which Supplier Quotations are not created,Zahtjevi za robom za koje dobavljačeve ponude nisu stvorene
apps/erpnext/erpnext/config/crm.py,"Helps you keep tracks of Contracts based on Supplier, Customer and Employee","Pomaže vam pratiti ugovore na temelju dobavljača, kupca i zaposlenika"
DocType: Company,Discount Received Account,Račun primljen na popust
DocType: Student Report Generation Tool,Print Section,Ispiši odjeljak
DocType: Staffing Plan Detail,Estimated Cost Per Position,Procjena troškova po položaju
DocType: Employee,HR-EMP-,HR-Poslodavci
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.,Korisnik {0} nema zadani POS profil. Provjerite zadani redak {1} za ovog korisnika.
DocType: Quality Meeting Minutes,Quality Meeting Minutes,Zapisnici sa kvalitetnim sastankom
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dobavljač&gt; vrsta dobavljača
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Employee Referral,Upućivanje zaposlenika
DocType: Student Group,Set 0 for no limit,Postavite 0 bez granica
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 (e) na koje se prijavljuje za odmor su praznici. Ne morate se prijaviti za dopust.
DocType: Customer,Primary Address and Contact Detail,Primarna adresa i kontakt detalja
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Resend Payment Email,Ponovno slanje plaćanja Email
apps/erpnext/erpnext/templates/pages/projects.html,New task,Novi zadatak
DocType: Clinical Procedure,Appointment,Imenovanje
apps/erpnext/erpnext/config/buying.py,Other Reports,Ostala izvješća
apps/erpnext/erpnext/public/js/setup_wizard.js,Please select at least one domain.,Odaberite barem jednu domenu.
DocType: Dependent Task,Dependent Task,Ovisno zadatak
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to UIN holders,Nabave za držače UIN-a
DocType: Shopify Settings,Shopify Tax Account,Kupnja poreznog 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 zadani jedinica mjere mora biti jedan u nizu {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave of type {0} cannot be longer than {1},Odsustvo tipa {0} ne može biti duže od {1}
DocType: Delivery Trip,Optimize Route,Optimizirajte rutu
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Pokušajte planirati poslovanje za X dana unaprijed.
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} slobodna radna mjesta i {1} proračun za {2} već planirani za podružnice od {3}. \ Možete planirati do {4} slobodna mjesta i proračun {5} prema planu za osoblje {6} za matičnu tvrtku {3}.
DocType: HR Settings,Stop Birthday Reminders,Zaustavi Rođendan Podsjetnici
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set Default Payroll Payable Account in Company {0},Molimo postavite zadanog Platne naplativo račun u Društvu {0}
DocType: Pricing Rule Brand,Pricing Rule Brand,Marka pravila o cijenama
DocType: Amazon MWS Settings,Get financial breakup of Taxes and charges data by Amazon ,Preuzmite financijsku raspad poreznih i administrativnih podataka Amazon
DocType: SMS Center,Receiver List,Prijemnik Popis
DocType: Pricing Rule,Rule Description,Opis pravila
apps/erpnext/erpnext/accounts/page/pos/pos.js,Search Item,Traži Stavka
DocType: Program,Allow Self Enroll,Dopusti samoprijavljivanje
DocType: Payment Schedule,Payment Amount,Iznos za plaćanje
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,Poludnevni datum bi trebao biti između rada od datuma i datuma završetka radnog vremena
DocType: Healthcare Settings,Healthcare Service Items,Zdravstvene usluge
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Konzumira Iznos
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Neto promjena u gotovini
DocType: Assessment Plan,Grading Scale,ljestvici
apps/erpnext/erpnext/stock/doctype/item/item.py,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Jedinica mjere {0} je ušao više od jednom u konverzije Factor tablici
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock In Hand,Stock u ruci
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",Dodajte preostale pogodnosti {0} u aplikaciju kao \ pro-rata komponentu
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the public administration '%s',Molimo postavite Fiskalni kodeks za javnu upravu &#39;% s&#39;
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Issued Items,Trošak izdanih stavki
DocType: Healthcare Practitioner,Hospital,Bolnica
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Quantity must not be more than {0},Količina ne smije biti veća od {0}
DocType: Travel Request Costing,Funded Amount,Financirani iznos
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Previous Financial Year is not closed,Prethodne financijske godine nije zatvoren
DocType: Practitioner Schedule,Practitioner Schedule,Raspored praktičara
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Age (Days),Starost (dani)
DocType: Instructor,EDU-INS-.YYYY.-,EDU-INS-.YYYY.-
DocType: Additional Salary,Additional Salary,Dodatna plaća
DocType: Quotation Item,Quotation Item,Proizvod iz ponude
DocType: Customer,Customer POS Id,ID klijenta POS
apps/erpnext/erpnext/education/utils.py,Student with email {0} does not exist,Student s adresom e-pošte {0} ne postoji
DocType: Account,Account Name,Naziv računa
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,From Date cannot be greater than To Date,Od datuma ne može biti veća od To Date
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} quantity {1} cannot be a fraction,Serijski Ne {0} {1} količina ne može bitidio
DocType: Pricing Rule,Apply Discount on Rate,Primijenite popust na rate
DocType: Tally Migration,Tally Debtors Account,Račun dužnika
DocType: Pricing Rule,Promotional Scheme,Promotivna shema
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter Woocommerce Server URL,Unesite Woocommerce URL poslužitelja
DocType: GSTR 3B Report,September,rujan
DocType: Purchase Order Item,Supplier Part Number,Dobavljač Broj dijela
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Conversion rate cannot be 0 or 1,Stopa pretvorbe ne može biti 0 ili 1
apps/erpnext/erpnext/accounts/page/bank_reconciliation/linked_payment_header.html,Payment Name,Naziv plaćanja
DocType: Share Balance,To No,Za br
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,All the mandatory Task for employee creation hasn't been done yet.,Sve obvezne zadaće za stvaranje zaposlenika još nisu učinjene.
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled or stopped,{0} {1} otkazan ili zaustavljen
DocType: Accounts Settings,Credit Controller,Kreditne kontroler
DocType: Loan,Applicant Type,Vrsta podnositelja zahtjeva
DocType: Purchase Invoice,03-Deficiency in services,03 - Nedostatak usluga
DocType: Healthcare Settings,Default Medical Code Standard,Zadani standard medicinskog koda
DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
DocType: Project Template Task,Project Template Task,Zadatak predloška projekta
DocType: Accounts Settings,Over Billing Allowance (%),Preko dopunske naplate (%)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Purchase Receipt {0} is not submitted,Primka {0} nije potvrđena
DocType: Company,Default Payable Account,Zadana Plaća račun
apps/erpnext/erpnext/config/website.py,"Settings for online shopping cart such as shipping rules, price list etc.","Postavke za online košarici, kao što su utovar pravila, cjenika i sl"
DocType: Purchase Receipt,MAT-PRE-.YYYY.-,MAT-PRE-.YYYY.-
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Billed,{0}% Naplaćeno
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Reserved Qty,Rezervirano Kol
DocType: Party Account,Party Account,Račun stranke
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,Please select Company and Designation,Odaberite Tvrtka i Oznaka
apps/erpnext/erpnext/config/settings.py,Human Resources,Ljudski resursi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Upper Income,Gornja Prihodi
DocType: Item Manufacturer,Item Manufacturer,stavka Proizvođač
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Create New Lead,Stvorite novi potencijal
DocType: BOM Operation,Batch Size,Veličina serije
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Reject,Odbiti
DocType: Journal Entry Account,Debit in Company Currency,Zaduženja tvrtke valuti
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Import Successfull,Uvoz uspješno
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Material Request not created, as quantity for Raw Materials already available.","Zahtjev za materijal nije kreiran, jer je količina za sirovine već dostupna."
DocType: BOM Item,BOM Item,BOM proizvod
DocType: Appraisal,For Employee,Za zaposlenom
DocType: Leave Control Panel,Designation (optional),Oznaka (izborno)
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.","Nije pronađena stopa vrednovanja za stavku {0} koja je potrebna za unos računovodstvenih stavki za {1} {2}. Ako stavka djeluje kao stavka nulte vrijednosti u {1}, navedite to u {1} tablici predmeta. U suprotnom, napravite dolaznu transakciju dionica za stavku ili navedite stopu procjene u zapisu stavke, a zatim pokušajte predati / poništiti taj unos."
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Supplier must be debit,Red {0}: Advance protiv Dobavljač mora teretiti
DocType: Company,Default Values,Zadane vrijednosti
DocType: Certification Application,INR,INR
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Party Addresses,Obrada stranačkih adresa
DocType: Woocommerce Settings,Creation User,Stvaranje korisnika
DocType: Quality Procedure,Quality Procedure,Postupak kvalitete
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Please check the error log for details about the import errors,Provjerite dnevnik pogrešaka za detalje o uvoznim pogreškama
DocType: Bank Transaction,Reconciled,pomiren
DocType: Expense Claim,Total Amount Reimbursed,Ukupno Iznos nadoknađeni
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py,This is based on logs against this Vehicle. See timeline below for details,To se temelji na zapisima protiv tog vozila. Pogledajte vremensku crtu ispod za detalje
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Payroll date can not be less than employee's joining date,Datum plaćanja ne može biti manji od datuma pridruživanja zaposlenika
DocType: Pick List,Item Locations,Lokacije predmeta
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.py,{0} {1} created,{0} {1} stvorio
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}",Otvoreni poslovi za oznaku {0} već su otvoreni ili zapošljavanje završeno prema planu osoblja {1}
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,You can publish upto 200 items.,Možete objaviti do 200 predmeta.
DocType: Vital Signs,Constipated,konstipovan
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Against Supplier Invoice {0} dated {1},Protiv dobavljača Račun {0} datira {1}
DocType: Customer,Default Price List,Zadani cjenik
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Asset Movement record {0} created,Unos imovine Pokret {0} stvorio
apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js,No items found.,Nijedna stavka nije pronađena.
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 možete izbrisati Fiskalnu godinu {0}. Fiskalna godina {0} je postavljena kao zadana u Globalnim postavkama
DocType: Share Transfer,Equity/Liability Account,Račun vlasničke i odgovornosti
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py,A customer with the same name already exists,Kupac s istim imenom već postoji
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 će poslati Plaće Slips i stvoriti obračunski dnevnik unos. Želiš li nastaviti?
DocType: Purchase Invoice,Total Net Weight,Ukupna neto težina
DocType: Purchase Order,Order Confirmation No,Potvrda narudžbe br
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Net Profit,Neto dobit
DocType: Purchase Invoice,Eligibility For ITC,Podobnost za ITC
DocType: Student Applicant,EDU-APP-.YYYY.-,EDU-APP-.YYYY.-
DocType: Journal Entry,Entry Type,Ulaz Tip
,Customer Credit Balance,Kupac saldo
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Accounts Payable,Neto promjena u obveze prema dobavljačima
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Credit limit has been crossed for customer {0} ({1}/{2}),Kreditna je ograničenja prekinuta za kupca {0} ({1} / {2})
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Customer required for 'Customerwise Discount',Kupac je potrebno za ' Customerwise Popust '
apps/erpnext/erpnext/config/accounting.py,Update bank payment dates with journals.,Update banka datum plaćanja s časopisima.
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Pricing,Cijena
DocType: Employee,Attendance Device ID (Biometric/RF tag ID),ID uređaja za posjećenost (ID biometrijske / RF oznake)
DocType: Quotation,Term Details,Oročeni Detalji
DocType: Item,Over Delivery/Receipt Allowance (%),Naknada za dostavu / primanje (%)
DocType: Employee Incentive,Employee Incentive,Poticaj zaposlenika
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Cannot enroll more than {0} students for this student group.,Ne može se prijaviti više od {0} studenata za ovaj grupe studenata.
apps/erpnext/erpnext/templates/print_formats/includes/total.html,Total (Without Tax),Ukupno (Bez poreza)
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Lead Count,Olovni broj
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Stock Available,Dostupno
DocType: Manufacturing Settings,Capacity Planning For (Days),Planiranje kapaciteta za (dani)
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py,Procurement,nabavka
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,None of the items have any change in quantity or value.,Nitko od stavki ima bilo kakve promjene u količini ili vrijednosti.
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Program,Obvezno polje - Program
DocType: Special Test Template,Result Component,Rezultat Komponenta
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js,Warranty Claim,Jamstvo Zatraži
,Lead Details,Detalji potenciajalnog kupca
DocType: Volunteer,Availability and Skills,Dostupnost i vještine
DocType: Salary Slip,Loan repayment,otplata kredita
DocType: Share Transfer,Asset Account,Asset Account
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Novi datum izlaska trebao bi biti u budućnosti
DocType: Purchase Invoice,End date of current invoice's period,Kraj datum tekućeg razdoblja dostavnice
DocType: Lab Test,Technician Name,Naziv tehničara
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
					Item {0} is added with and without Ensure Delivery by \
					Serial No.",Ne može se osigurati isporuka prema serijskoj broju kao što je \ Stavka {0} dodana sa i bez osiguranja isporuke od strane \ Serial No.
DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Prekini vezu Plaćanje o otkazu fakture
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},Trenutno stanje kilometraže ušao bi trebala biti veća od početne vozila kilometraže {0}
DocType: Restaurant Reservation,No Show,Nema prikazivanja
apps/erpnext/erpnext/regional/india/utils.py,You must be a registered supplier to generate e-Way Bill,Za generiranje računa za e-put morate biti registrirani dobavljač
DocType: Shipping Rule Country,Shipping Rule Country,Pravilo dostava Država
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Leave and Attendance,Ostavi i posjećenost
DocType: Asset,Comprehensive Insurance,Sveobuhvatno osiguranje
DocType: Maintenance Visit,Partially Completed,Djelomično završeni
apps/erpnext/erpnext/public/js/event.js,Add Leads,Dodaj vodi
apps/erpnext/erpnext/healthcare/setup.py,Moderate Sensitivity,Umjerena osjetljivost
DocType: Leave Type,Include holidays within leaves as leaves,Uključi odmor u lišće što lišće
DocType: Loyalty Program,Redemption,otkup
DocType: Sales Invoice,Packed Items,Pakirani proizvodi
DocType: Tally Migration,Vouchers,bonovi
DocType: Tax Withholding Category,Tax Withholding Rates,Stope zadržavanja poreza
DocType: Contract,Contract Period,Trajanje ugovora
apps/erpnext/erpnext/config/support.py,Warranty Claim against Serial No.,Jamstvo tužbu protiv Serial No.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,'Total','Ukupno'
DocType: Shopping Cart Settings,Enable Shopping Cart,Omogućite Košarica
DocType: Employee,Permanent Address,Stalna adresa
DocType: Loyalty Program,Collection Tier,Zbirka Tier
apps/erpnext/erpnext/hr/utils.py,From date can not be less than employee's joining date,Od datuma ne može biti manji od datuma pridruživanja zaposlenika
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}",Unaprijed plaćeni od {0} {1} ne može biti veća \ nego SVEUKUPNO {2}
DocType: Patient,Medication,liječenje
DocType: Production Plan,Include Non Stock Items,Uključi ostale artikle
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select item code,Odaberite Šifra
DocType: Student Sibling,Studying in Same Institute,Studiranje u istom institutu
DocType: Leave Type,Earned Leave,Zaradeno odsustvo
apps/erpnext/erpnext/erpnext_integrations/connectors/shopify_connection.py,Tax Account not specified for Shopify Tax {0},Porezni račun nije naveden za Shopify Tax {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,The following serial numbers were created: <br> {0},Napravljeni su sljedeći serijski brojevi: <br> {0}
DocType: Employee,Salary Details,Detalji plaće
DocType: Territory,Territory Manager,Upravitelj teritorija
DocType: Packed Item,To Warehouse (Optional),Za Warehouse (po izboru)
DocType: GST Settings,GST Accounts,GST računi
DocType: Payment Entry,Paid Amount (Company Currency),Plaćeni iznos (Društvo valuta)
DocType: Purchase Invoice,Additional Discount,Dodatni popust
DocType: Selling Settings,Selling Settings,Postavke prodaje
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Online Auctions,Online aukcije
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please specify either Quantity or Valuation Rate or both,Navedite ili količini ili vrednovanja Ocijenite ili oboje
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py,Fulfillment,Ispunjenje
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,View in Cart,Pogledaj u košaricu
DocType: Employee Checkin,Shift Actual Start,Stvarni početak promjene
DocType: Tally Migration,Is Day Book Data Imported,Uvoze li se podaci dnevnih knjiga
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Marketing Expenses,Troškovi marketinga
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.py,{0} units of {1} is not available.,{0} jedinice od {1} nisu dostupne.
,Item Shortage Report,Nedostatak izvješća za proizvod
DocType: Bank Transaction Payments,Bank Transaction Payments,Plaćanja putem bankovnih transakcija
apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py,Can't create standard criteria. Please rename the criteria,Nije moguće stvoriti standardne kriterije. Preimenujte kriterije
apps/erpnext/erpnext/stock/doctype/item/item.js,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Težina se spomenuto, \n Molimo spomenuti ""težinu UOM"" previše"
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Zahtjev za robom korišten za izradu ovog ulaza robe
DocType: Hub User,Hub Password,Zaporka huba
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Odvojena grupa za tečajeve za svaku seriju
,Sales Partner Target Variance based on Item Group,Ciljna varijanta prodajnog partnera na temelju grupe proizvoda
apps/erpnext/erpnext/config/support.py,Single unit of an Item.,Jedna jedinica stavku.
DocType: Fee Category,Fee Category,Naknada Kategorija
DocType: Agriculture Task,Next Business Day,Sljedeći radni dan
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Allocated Leaves,Dodijeljene lišće
DocType: Drug Prescription,Dosage by time interval,Doziranje po vremenskom intervalu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Total Taxable Value,Ukupna oporeziva vrijednost
DocType: Cash Flow Mapper,Section Header,Header odjeljka
,Student Fee Collection,Studentski Naknada Collection
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Appointment Duration (mins),Trajanje sastanka (min)
DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Provjerite knjiženje za svaki burzi pokreta
DocType: Leave Allocation,Total Leaves Allocated,Ukupno Lišće Dodijeljeni
apps/erpnext/erpnext/public/js/setup_wizard.js,Please enter valid Financial Year Start and End Dates,Unesite valjani financijske godine datum početka i kraja
DocType: Employee,Date Of Retirement,Datum odlaska u mirovinu
DocType: Upload Attendance,Get Template,Kreiraj predložak
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Pick List,Popis popisa
,Sales Person Commission Summary,Sažetak Povjerenstva za prodaju
DocType: Material Request,Transferred,prebačen
DocType: Vehicle,Doors,vrata
DocType: Healthcare Settings,Collect Fee for Patient Registration,Prikupiti naknadu za registraciju pacijenata
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,Nije moguće promijeniti atribute nakon transakcije zaliha. Napravite novu stavku i prenesite dionicu novoj stavci
DocType: Course Assessment Criteria,Weightage,Weightage
DocType: Purchase Invoice,Tax Breakup,Porezna prekid
DocType: Employee,Joining Details,Pridruživanje pojedinosti
DocType: Member,Non Profit Member,Neprofitna članica
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}: Troškovno mjesto potrebno je za račun dobiti i gubitka {2}. Molimo postaviti zadano mjesto troška.
DocType: Payment Schedule,Payment Term,Rok plaćanja
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,Postoji grupa kupaca sa istim imenom. Promijenite naziv kupca ili naziv grupe kupaca.
DocType: Location,Area,područje
apps/erpnext/erpnext/public/js/templates/contact_list.html,New Contact,Novi Kontakt
DocType: Company,Company Description,Opis Tvrtke
DocType: Territory,Parent Territory,Nadređena teritorija
DocType: Purchase Invoice,Place of Supply,Mjesto isporuke
DocType: Quality Inspection Reading,Reading 2,Čitanje 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},Zaposlenik {0} već je poslao apllicaciju {1} za razdoblje plaće {2}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Material Receipt,Potvrda primitka robe
DocType: Bank Statement Transaction Entry,Submit/Reconcile Payments,Pošaljite / Uskladite plaćanja
DocType: Campaign,SAL-CAM-.YYYY.-,SAL-CAM-.YYYY.-
DocType: Homepage,Products,Proizvodi
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invoices based on Filters,Nabavite fakture na temelju Filtri
DocType: Announcement,Instructor,Instruktor
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Select Item (optional),Odaberite stavku (nije obavezno)
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,The Loyalty Program isn't valid for the selected company,Program lojalnosti ne vrijedi za odabranu tvrtku
DocType: Fee Schedule Student Group,Fee Schedule Student Group,Fee raspored skupinu studenata
DocType: Student,AB+,AB +
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Ako ova stavka ima varijante, onda to ne može biti izabran u prodajnim nalozima itd"
DocType: Products Settings,Hide Variants,Sakrij varijante
DocType: Lead,Next Contact By,Sljedeći kontakt od
DocType: Compensatory Leave Request,Compensatory Leave Request,Zahtjev za kompenzacijski dopust
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Količina potrebna za proizvod {0} u redku {1}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Skladište {0} ne može biti izbrisano ako na njemu ima proizvod {1}
DocType: Blanket Order,Order Type,Vrsta narudžbe
,Item-wise Sales Register,Stavka-mudri prodaja registar
DocType: Asset,Gross Purchase Amount,Bruto Iznos narudžbe
apps/erpnext/erpnext/utilities/user_progress.py,Opening Balances,Početna salda
DocType: Asset,Depreciation Method,Metoda amortizacije
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Je li ovo pristojba uključena u osnovne stope?
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Total Target,Ukupno 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 porez
DocType: Soil Texture,Sand Composition (%),Sastav pijeska (%)
DocType: Job Applicant,Applicant for a Job,Podnositelj zahtjeva za posao
DocType: Production Plan Material Request,Production Plan Material Request,Izrada plana materijala Zahtjev
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Automatic Reconciliation,Automatsko pomirenje
DocType: Purchase Invoice,Release Date,Datum izlaska
DocType: Stock Reconciliation,Reconciliation JSON,Pomirenje JSON
apps/erpnext/erpnext/accounts/report/financial_statements.html,Too many columns. Export the report and print it using a spreadsheet application.,Previše stupovi. Izvesti izvješće i ispisati pomoću aplikacije za proračunske tablice.
DocType: Purchase Invoice Item,Batch No,Broj serije
DocType: Marketplace Settings,Hub Seller Name,Naziv prodavača u centru
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Employee Advances,Predujmovi zaposlenika
DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Dopusti višestruke prodajne naloge protiv kupca narudžbenice
DocType: Student Group Instructor,Student Group Instructor,Instruktor grupe studenata
DocType: Grant Application,Assessment  Mark (Out of 10),Ocjena ocjenjivanja (od 10)
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Mobile No,Guardian2 Mobile Ne
apps/erpnext/erpnext/setup/doctype/company/company.py,Main,Glavni
DocType: GSTR 3B Report,July,srpanj
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,Sljedeća stavka {0} nije označena kao {1} stavka. Možete ih omogućiti kao {1} stavku iz svog master stavke
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant,Varijanta
apps/erpnext/erpnext/controllers/status_updater.py,"For an item {0}, quantity must be negative number","Za stavku {0}, količina mora biti negativni broj"
DocType: Naming Series,Set prefix for numbering series on your transactions,Postavite prefiks za numeriranje niza na svoje transakcije
DocType: Employee Attendance Tool,Employees HTML,Zaposlenici HTML
apps/erpnext/erpnext/stock/doctype/item/item.py,Default BOM ({0}) must be active for this item or its template,Zadana BOM ({0}) mora biti aktivan za tu stavku ili njegov predložak
DocType: Employee,Leave Encashed?,Odsustvo naplaćeno?
DocType: Email Digest,Annual Expenses,Godišnji troškovi
DocType: Item,Variants,Varijante
DocType: SMS Center,Send To,Pošalji
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,There is not enough leave balance for Leave Type {0},Nema dovoljno ravnotežu dopust za dozvolu tipa {0}
DocType: Payment Reconciliation Payment,Allocated amount,Dodijeljeni iznos
DocType: Sales Team,Contribution to Net Total,Doprinos neto Ukupno
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Manufactured,Proizveden
DocType: Sales Invoice Item,Customer's Item Code,Kupca Stavka Šifra
DocType: Stock Reconciliation,Stock Reconciliation,Kataloški pomirenje
DocType: Territory,Territory Name,Naziv teritorija
DocType: Email Digest,Purchase Orders to Receive,Narudžbenice za primanje
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work-in-Progress Warehouse is required before Submit,Rad u tijeku Warehouse je potrebno prije Podnijeti
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,You can only have Plans with the same billing cycle in a Subscription,U pretplati možete imati samo planove s istim ciklusom naplate
DocType: Bank Statement Transaction Settings Item,Mapped Data,Prijenos podataka
DocType: Purchase Order Item,Warehouse and Reference,Skladište i reference
DocType: Payroll Period Date,Payroll Period Date,Datum razdoblja obračuna plaće
DocType: Supplier,Statutory info and other general information about your Supplier,Zakonska info i druge opće informacije o vašem Dobavljaču
DocType: Item,Serial Nos and Batches,Serijski brojevi i serije
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Student Group Strength,Snaga grupe učenika
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Against Journal Entry {0} does not have any unmatched {1} entry,Protiv Temeljnica {0} nema premca {1} unos
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",Podružnice već su planirale {1} slobodna radna mjesta s proračunom od {2}. \ Plan osoblja za {0} treba dodijeliti više slobodnih radnih mjesta i proračun za {3} nego što je planirano za svoje podružnice
apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py,Training Events,Događaji treninga
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Duplicate Serial No entered for Item {0},Dupli serijski broj unešen za proizvod {0}
DocType: Quality Review Objective,Quality Review Objective,Cilj pregleda kvalitete
apps/erpnext/erpnext/config/crm.py,Track Leads by Lead Source.,Prati vodio izvorom olova.
DocType: Shipping Rule Condition,A condition for a Shipping Rule,Uvjet za Pravilo isporuke
DocType: Sales Invoice,e-Way Bill No.,račun za e-put br.
DocType: GSTR 3B Report,JSON Output,Izlaz JSON-a
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please enter ,Molim uđite
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Maintenance Log,Zapisnik održavanja
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Please set filter based on Item or Warehouse,Molimo postavite filter na temelju stavka ili skladište
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Neto težina tog paketa. (Automatski izračunava kao zbroj neto težini predmeta)
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Discount amount cannot be greater than 100%,Iznos popusta ne može biti veći 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","Broj novog mjesta troška, bit će uključen u naziv mjesta troška kao prefiks"
DocType: Sales Order,To Deliver and Bill,Za isporuku i Bill
DocType: Student Group,Instructors,Instruktori
DocType: GL Entry,Credit Amount in Account Currency,Kreditna Iznos u valuti računa
DocType: Stock Entry,Receive at Warehouse,Primanje u skladište
DocType: Communication Medium,Voice,Glas
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} must be submitted,BOM {0} mora biti podnesen
apps/erpnext/erpnext/config/accounting.py,Share Management,Upravljanje dijeljenjem
DocType: Authorization Control,Authorization Control,Kontrola autorizacije
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Red # {0}: Odbijen Skladište je obvezna protiv odbijena točka {1}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Received Stock Entries,Primljene prijave na dionice
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Payment,Uplata
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šte {0} nije povezano s bilo kojim računom, navedite račun u skladištu ili postavite zadani račun zaliha u tvrtki {1}."
apps/erpnext/erpnext/utilities/activation.py,Manage your orders,Upravljanje narudžbe
DocType: Work Order Operation,Actual Time and Cost,Stvarnog vremena i troškova
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},Zahtjev za robom od maksimalnih {0} može biti napravljen za proizvod {1} od narudžbe kupca {2}
DocType: Amazon MWS Settings,DE,DE
DocType: Crop,Crop Spacing,Razmak bjelančevina
DocType: Budget,Action if Annual Budget Exceeded on PO,Postupak ako je godišnji proračun prekoračen na PO
DocType: Issue,Service Level,Razina usluge
DocType: Student Leave Application,Student Leave Application,Studentski Ostavite aplikacija
DocType: Item,Will also apply for variants,Također će podnijeti zahtjev za varijante
apps/erpnext/erpnext/assets/doctype/asset/asset.py,"Asset cannot be cancelled, as it is already {0}","Imovina se ne može otkazati, jer je već {0}"
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} on Half day on {1},Zaposlenik {0} na pola dana na {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Total working hours should not be greater than max working hours {0},Ukupno radno vrijeme ne smije biti veći od max radnog vremena {0}
DocType: Asset Settings,Disable CWIP Accounting,Onemoguć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.,Hrpa proizvoda u vrijeme prodaje.
DocType: Products Settings,Product Page,Stranica proizvoda
DocType: Delivery Settings,Dispatch Settings,Postavke za slanje
DocType: Material Request Plan Item,Actual Qty,Stvarna kol
DocType: Sales Invoice Item,References,Reference
DocType: Quality Inspection Reading,Reading 10,Čitanje 10
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Serial nos {0} does not belongs to the location {1},Serijski broj {0} ne pripada mjestu {1}
DocType: Item,Barcodes,Bar kodovi
DocType: Hub Tracked Item,Hub Node,Hub Node
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,You have entered duplicate items. Please rectify and try again.,Unijeli ste dupli proizvod. Ispravite i pokušajte ponovno.
DocType: Tally Migration,Is Master Data Imported,Uvezu se glavni podaci
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Associate,pomoćnik
DocType: Asset Movement,Asset Movement,imovina pokret
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0} must be submitted,Mora se poslati radni nalog {0}
apps/erpnext/erpnext/accounts/page/pos/pos.js,New Cart,Novi Košarica
DocType: Taxable Salary Slab,From Amount,Iz Iznos
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Item {0} is not a serialized Item,Proizvod {0} nije serijalizirani proizvod
DocType: Leave Type,Encashment,naplate
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.js,Select a company,Odaberite tvrtku
DocType: Delivery Settings,Delivery Settings,Postavke isporuke
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Fetch Data,Dohvatite podatke
apps/erpnext/erpnext/hr/doctype/leave_policy/leave_policy.py,Maximum leave allowed in the leave type {0} is {1},Maksimalni dopust dopušten u dopuštenoj vrsti {0} je {1}
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Publish 1 Item,Objavite 1 predmet
DocType: SMS Center,Create Receiver List,Stvaranje Receiver popis
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 dostupan za upotrebu trebao bi biti nakon datuma kupnje
DocType: Vehicle,Wheels,kotači
DocType: Packing Slip,To Package No.,Za Paket br
DocType: Patient Relation,Family,Obitelj
DocType: Invoice Discounting,Invoice Discounting,Popust na fakturama
DocType: Sales Invoice Item,Deferred Revenue Account,Odgođeni račun prihoda
DocType: Production Plan,Material Requests,Materijal Zahtjevi
DocType: Warranty Claim,Issue Date,Datum Izazova
DocType: Activity Cost,Activity Cost,Aktivnost troškova
DocType: Sales Invoice Timesheet,Timesheet Detail,timesheet Detalj
DocType: Purchase Receipt Item Supplied,Consumed Qty,Potrošeno 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: {},Nijedan račun ne odgovara tim filterima: {}
apps/erpnext/erpnext/accounts/party.py,Billing currency must be equal to either default company's currency or party account currency,Valuta naplate mora biti jednaka valutnoj valuti ili valuti stranke računa tvrtke
DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),Ukazuje da je paket je dio ove isporuke (samo nacrti)
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,Closing Balance,Završna ravnoteža
DocType: Soil Texture,Loam,Ilovača
apps/erpnext/erpnext/controllers/accounts_controller.py,Row {0}: Due Date cannot be before posting date,Redak {0}: Datum dospijeća ne može biti prije objavljivanja datuma
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Quantity for Item {0} must be less than {1},Količina za proizvod {0} mora biti manja od {1}
,Sales Invoice Trends,Trendovi prodajnih računa
DocType: Leave Application,Apply / Approve Leaves,Nanesite / Odobri Lišće
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',"Može se odnositi red samo akotip zadužen je "" Na prethodni red Iznos 'ili' prethodnog retka Total '"
DocType: Sales Order Item,Delivery Warehouse,Isporuka Skladište
DocType: Leave Type,Earned Leave Frequency,Učestalost dobivenih odmora
apps/erpnext/erpnext/config/accounting.py,Tree of financial Cost Centers.,Drvo centara financijski trošak.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Sub Type,Sub Type
DocType: Serial No,Delivery Document No,Dokument isporuke br
DocType: Sales Order Item,Ensure Delivery Based on Produced Serial No,Osigurajte dostavu na temelju proizvedenog serijskog br
DocType: Vital Signs,Furry,Krznen
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Molimo postavite &quot;dobici / gubici računa na sredstva Odlaganje &#39;u Društvu {0}
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Add to Featured Item,Dodajte u istaknuti predmet
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Se predmeti od kupnje primitke
DocType: Serial No,Creation Date,Datum stvaranja
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Target Location is required for the asset {0},Ciljana lokacija potrebna je za element {0}
DocType: GSTR 3B Report,November,studeni
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,"Selling must be checked, if Applicable For is selected as {0}","Prodaje se mora provjeriti, ako je primjenjivo za odabrano kao {0}"
DocType: Production Plan Material Request,Material Request Date,Materijal Zahtjev Datum
DocType: Purchase Order Item,Supplier Quotation Item,Dobavljač ponudu artikla
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Material Consumption is not set in Manufacturing Settings.,Potrošnja materijala nije postavljena u Postavkama za proizvodnju.
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,View all issues from {0},Pregled svih izdanja od {0}
DocType: Quality Inspection,MAT-QA-.YYYY.-,MAT-QA-.YYYY.-
DocType: Quality Meeting Table,Quality Meeting Table,Stol za sastanke o kvaliteti
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Postavite Nameing Series za {0} putem Postavke&gt; Postavke&gt; Imenovanje serija
apps/erpnext/erpnext/templates/pages/help.html,Visit the forums,Posjetite forume
DocType: Student,Student Mobile Number,Studentski broj mobitela
DocType: Item,Has Variants,Je Varijante
DocType: Employee Benefit Claim,Claim Benefit For,Zatražite korist od
apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Ne može se overbill za stavku {0} u retku {1} više od {2}. Da biste dopustili prekoračenje, postavite Postavke zaliha"
apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Ažurirajte odgovor
apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Već ste odabrali stavke iz {0} {1}
DocType: Monthly Distribution,Name of the Monthly Distribution,Naziv mjesečne distribucije
DocType: Quality Procedure Process,Quality Procedure Process,Postupak postupka kvalitete
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Batch ID is mandatory,ID serije obvezan je
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.js,Please select Customer first,Prvo odaberite kupca
DocType: Sales Person,Parent Sales Person,Nadređeni prodavač
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,No items to be received are overdue,Nijedna stavka koju treba primiti nije kasna
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The seller and the buyer cannot be the same,Prodavatelj i kupac ne mogu biti isti
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,No views yet,Još nema prikaza
DocType: Project,Collect Progress,Prikupiti napredak
DocType: Delivery Note,MAT-DN-.YYYY.-,MAT-DN-.YYYY.-
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Select the program first,Najprije odaberite program
DocType: Patient Appointment,Patient Age,Pacijentovo doba
apps/erpnext/erpnext/config/help.py,Managing Projects,Upravljanje projektima
DocType: Quiz,Latest Highest Score,Najnoviji najviši rezultat
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial no {0} has been already returned,Serijski broj {0} već je vraćen
DocType: Supplier,Supplier of Goods or Services.,Dobavljač dobara ili usluga.
DocType: Budget,Fiscal Year,Fiskalna godina
DocType: Asset Maintenance Log,Planned,Planirani
apps/erpnext/erpnext/hr/utils.py,A {0} exists between {1} and {2} (,A {0} postoji između {1} i {2} (
DocType: Vehicle Log,Fuel Price,Cijena goriva
DocType: BOM Explosion Item,Include Item In Manufacturing,Uključi predmet u proizvodnju
DocType: Bank Guarantee,Margin Money,Margin Money
DocType: Budget,Budget,Budžet
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Set Open,Postavi Otvori
apps/erpnext/erpnext/stock/doctype/item/item.py,Fixed Asset Item must be a non-stock item.,Fiksni Asset Stavka mora biti ne-stock točka a.
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 se ne može dodijeliti protiv {0}, kao što je nije prihod ili rashod račun"
DocType: Quality Review Table,Achieved,Ostvareno
DocType: Student Admission,Application Form Route,Obrazac za prijavu Route
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,End Date of Agreement can't be less than today.,Datum završetka ugovora ne može biti manji od današnjeg.
apps/erpnext/erpnext/public/js/hub/components/CommentInput.vue,Ctrl + Enter to submit,Ctrl + Enter za slanje
DocType: Healthcare Settings,Patient Encounters in valid days,Pacijentni susreti u važećim danima
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leave Type {0} cannot be allocated since it is leave without pay,Ostavi Tip {0} nije moguće rasporediti jer se ostaviti bez plaće
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},Red {0}: Dodijeljeni iznos {1} mora biti manji od ili jednak fakturirati preostali iznos {2}
DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,U riječi će biti vidljiv nakon što spremite prodaje fakture.
DocType: Lead,Follow Up,Pratiti
apps/erpnext/erpnext/accounts/report/financial_statements.py,Cost Center: {0} does not exist,Centar troškova: {0} ne postoji
DocType: Item,Is Sales Item,Je proizvod namijenjen prodaji
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,Item Group Tree,Raspodjela grupa proizvoda
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item {0} is not setup for Serial Nos. Check Item master,"Stavka {0} nije dobro postavljen za gospodara , serijski brojevi Provjera"
DocType: Maintenance Visit,Maintenance Time,Vrijeme održavanja
,Amount to Deliver,Iznos za isporuku
DocType: Asset,Insurance Start Date,Datum početka osiguranja
DocType: Salary Component,Flexible Benefits,Fleksibilne prednosti
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Same item has been entered multiple times. {0},Ista stavka je unesena više puta. {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 Pojam početka ne može biti ranije od godine Datum početka akademske godine u kojoj je pojam vezan (Akademska godina {}). Ispravite datume i pokušajte ponovno.
apps/erpnext/erpnext/setup/doctype/company/company.js,There were errors.,Bilo je grešaka .
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Pin Code,PIN kod
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup defaults,Nije uspjelo postavljanje zadanih postavki
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Employee {0} has already applied for {1} between {2} and {3} : ,Zaposlenik {0} već je podnio zahtjev za {1} između {2} i {3}:
DocType: Guardian,Guardian Interests,Guardian Interesi
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Name / Number,Ažuriranje naziva / broja računa
DocType: Naming Series,Current Value,Trenutna vrijednost
apps/erpnext/erpnext/controllers/accounts_controller.py,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Više fiskalne godine postoji za sada {0}. Molimo postavite tvrtka u fiskalnoj godini
DocType: Education Settings,Instructor Records to be created by,Instruktorski zapisi moraju biti izrađeni od strane
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,{0} created,{0} stvorio
DocType: GST Account,GST Account,GST račun
DocType: Delivery Note Item,Against Sales Order,Protiv prodajnog naloga
,Serial No Status,Status serijskog broja
DocType: Payment Entry Reference,Outstanding,izvanredan
DocType: Supplier,Warn POs,Upozorite PO-ove
,Daily Timesheet Summary,Dnevni timesheet Sažetak
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}","Red {0}: Za postavljanje {1} periodičnost, razlika između od a do danas \
 mora biti veći ili jednak {2}"
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,This is based on stock movement. See {0} for details,To se temelji na dionicama kretanja. Vidi {0} za detalje
DocType: Pricing Rule,Selling,Prodaja
DocType: Payment Entry,Payment Order Status,Status naloga za plaćanje
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} deducted against {2},Iznos {0} {1} oduzimaju od {2}
DocType: Sales Person,Name and Employee ID,Ime i ID zaposlenika
DocType: Promotional Scheme,Promotional Scheme Product Discount,Popust na promotivne sheme
DocType: Website Item Group,Website Item Group,Grupa proizvoda web stranice
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,Nije pronađena plaća za podnošenje gore navedenih kriterija ili već dostavljen skraćeni prihod
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Duties and Taxes,Carine i porezi
DocType: Projects Settings,Projects Settings,Postavke projekata
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please enter Reference date,Unesite Referentni 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} unosa plaćanja ne može se filtrirati po {1}
DocType: Item Website Specification,Table for Item that will be shown in Web Site,Tablica za proizvode koji će biti prikazani na web stranici
DocType: Purchase Order Item Supplied,Supplied Qty,Isporučena količina
DocType: Clinical Procedure,HLC-CPR-.YYYY.-,FHP-CPR-.YYYY.-
DocType: Purchase Order Item,Material Request Item,Zahtjev za robom - proizvod
apps/erpnext/erpnext/config/buying.py,Tree of Item Groups.,Stablo grupe proizvoda.
DocType: Production Plan,Total Produced Qty,Ukupna proizvodna količina
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,No reviews yet,Još nema recenzija
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 mogu se odnositi broj retka veći ili jednak trenutnom broju red za ovu vrstu Charge
DocType: Asset,Sold,prodan
,Item-wise Purchase History,Povjest nabave po stavkama
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Molimo kliknite na ""Generiraj raspored ' dohvatiti Serial No dodao je za točku {0}"
DocType: Account,Frozen,Zaleđeni
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Vehicle Type,tip vozila
DocType: Sales Invoice Payment,Base Amount (Company Currency),Baza Iznos (Društvo valuta)
DocType: Purchase Invoice,Registered Regular,Registrirano redovito
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Raw Materials,Sirovine
DocType: Payment Reconciliation Payment,Reference Row,Referentni Row
DocType: Installation Note,Installation Time,Vrijeme instalacije
DocType: Sales Invoice,Accounting Details,Računovodstvo Detalji
DocType: Shopify Settings,status html,status html
apps/erpnext/erpnext/setup/doctype/company/company.js,Delete all the Transactions for this Company,Izbrišite sve transakcije za ovu Društvo
DocType: Designation,Required Skills,Potrebne vještine
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,Investicije
DocType: Issue,Resolution Details,Rezolucija o Brodu
DocType: Leave Ledger Entry,Transaction Type,vrsta transakcije
DocType: Item Quality Inspection Parameter,Acceptance Criteria,Kriterij prihvaćanja
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Material Requests in the above table,Unesite materijala zahtjeva u gornjoj tablici
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments available for Journal Entry,Nije dostupna otplata za unos dnevnika
DocType: Hub Tracked Item,Image List,Popis slika
DocType: Item Attribute,Attribute Name,Ime atributa
DocType: Subscription,Generate Invoice At Beginning Of Period,Generiranje fakture na početku razdoblja
DocType: BOM,Show In Website,Pokaži na web stranici
DocType: Loan Application,Total Payable Amount,Ukupno obveze prema dobavljačima iznos
DocType: Task,Expected Time (in hours),Očekivani vrijeme (u satima)
DocType: Item Reorder,Check in (group),Check in (grupa)
DocType: Soil Texture,Silt,Mulj
,Qty to Order,Količina za narudžbu
DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Glava račun pod odgovornosti ili glavnice, u kojem Dobit / gubitak će biti rezervirano"
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},Još jedan proračunski zapis &#39;{0}&#39; već postoji za {1} &#39;{2}&#39; i račun &#39;{3}&#39; za fiskalnu godinu {4}
apps/erpnext/erpnext/config/projects.py,Gantt chart of all tasks.,Gantogram svih zadataka.
DocType: Opportunity,Mins to First Response,Min do prvog odgovora
DocType: Pricing Rule,Margin Type,Margina Vrsta
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,{0} hours,{0} sata
DocType: Course,Default Grading Scale,Zadana ljestvici
DocType: Appraisal,For Employee Name,Za ime zaposlenika
DocType: Holiday List,Clear Table,Jasno Tablica
DocType: Woocommerce Settings,Tax Account,Porezni račun
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Available slots,Dostupni utori
DocType: C-Form Invoice Detail,Invoice No,Račun br
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Make Payment,Izvršiti plaćanje
DocType: Room,Room Name,Soba Naziv
DocType: Prescription Duration,Prescription Duration,Trajanje liječenja
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}","Ostavite se ne može primijeniti / otkazan prije {0}, kao dopust ravnoteža je već ručne proslijeđena u buduće dodjele dopusta rekord {1}"
DocType: Activity Cost,Costing Rate,Obračun troškova stopa
apps/erpnext/erpnext/config/selling.py,Customer Addresses And Contacts,Kupčeve adrese i kontakti
DocType: Homepage Section,Section Cards,Karte odsjeka
,Campaign Efficiency,Učinkovitost kampanje
DocType: Discussion,Discussion,Rasprava
DocType: Bank Transaction,Transaction ID,ID transakcije
DocType: Payroll Entry,Deduct Tax For Unsubmitted Tax Exemption Proof,Odbitak poreza za nepodoban dokaz o oslobođenju poreza
DocType: Volunteer,Anytime,Bilo kada
DocType: Bank Account,Bank Account No,Bankovni račun br
DocType: Employee Tax Exemption Proof Submission,Employee Tax Exemption Proof Submission,Podnošenje dokaza o izuzeću od izuzeća od zaposlenika
DocType: Patient,Surgical History,Kirurška povijest
DocType: Bank Statement Settings Item,Mapped Header,Mapped Header
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Postavite sustav imenovanja zaposlenika u Ljudski resursi&gt; HR postavke
DocType: Employee,Resignation Letter Date,Ostavka Pismo Datum
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Pricing Rules are further filtered based on quantity.,Pravilnik o određivanju cijena dodatno se filtrira na temelju količine.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Please set the Date Of Joining for employee {0},Postavite datum pridruživanja za zaposlenika {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Please enter Difference Account,Unesite račun razlika
DocType: Inpatient Record,Discharge,Pražnjenje
DocType: Task,Total Billing Amount (via Time Sheet),Ukupan iznos za naplatu (preko vremenska tablica)
apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js,Create Fee Schedule,Kreirajte raspored naknada
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customer Revenue,Ponovite kupaca prihoda
DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
DocType: Quiz,Enter 0 to waive limit,Unesite 0 za odricanje od ograničenja
DocType: Bank Statement Settings,Mapped Items,Mapped Items
DocType: Amazon MWS Settings,IT,TO
DocType: Chapter,Chapter,Poglavlje
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.,Zadani račun automatski će se ažurirati u POS fakturu kada je ovaj način odabran.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select BOM and Qty for Production,Odaberite BOM i Kol za proizvodnju
DocType: Asset,Depreciation Schedule,Amortizacija Raspored
DocType: Bank Reconciliation Detail,Against Account,Protiv računa
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Half Day Date should be between From Date and To Date,Poludnevni Datum treba biti između od datuma i datuma
DocType: Maintenance Schedule Detail,Actual Date,Stvarni datum
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please set the Default Cost Center in {0} company.,Postavite Zadani centar troškova u tvrtki {0}.
apps/erpnext/erpnext/projects/doctype/project/project.py,Daily Project Summary for {0},Dnevni sažetak projekta za {0}
DocType: Item,Has Batch No,Je Hrpa Ne
apps/erpnext/erpnext/public/js/utils.js,Annual Billing: {0},Godišnji naplatu: {0}
DocType: Shopify Webhook Detail,Shopify Webhook Detail,Detalj Shopify Webhook
apps/erpnext/erpnext/config/accounting.py,Goods and Services Tax (GST India),Porez na robu i usluge (GST India)
DocType: Delivery Note,Excise Page Number,Trošarina Broj stranice
DocType: Asset,Purchase Date,Datum kupnje
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Could not generate Secret,Nije uspjelo generirati tajnu
DocType: Volunteer,Volunteer Type,Volonterski tip
DocType: Payment Request,ACC-PRQ-.YYYY.-,ACC-PRQ-.YYYY.-
DocType: Shift Assignment,Shift Type,Vrsta Shift
DocType: Student,Personal Details,Osobni podaci
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,Export E-Invoices,Izvoz e-računa
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set 'Asset Depreciation Cost Center' in Company {0},Molimo postavite &quot;imovinom Centar Amortizacija troškova &#39;u Društvu {0}
,Maintenance Schedules,Održavanja rasporeda
DocType: Pricing Rule,Apply Rule On Brand,Primijeni pravilo na marku
DocType: Task,Actual End Date (via Time Sheet),Stvarni Datum završetka (putem vremenska tablica)
apps/erpnext/erpnext/projects/doctype/task/task.py,Cannot close task {0} as its dependant task {1} is not closed.,Zadatak se ne može zatvoriti {0} jer njegov ovisni zadatak {1} nije zatvoren.
DocType: Soil Texture,Soil Type,Vrsta tla
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} against {2} {3},Iznos {0} {1} od {2} {3}
,Quotation Trends,Trend ponuda
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Item Group not mentioned in item master for item {0},Stavka proizvoda se ne spominje u master artiklu za artikal {0}
DocType: GoCardless Mandate,GoCardless Mandate,Mandat za GoCardless
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To account must be a Receivable account,Zaduženja računa mora biti Potraživanja račun
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Select finance book for the item {0} at row {1},Odaberite knjigu financija za stavku {0} u retku {1}
DocType: Shipping Rule,Shipping Amount,Dostava Iznos
DocType: Supplier Scorecard Period,Period Score,Ocjena razdoblja
apps/erpnext/erpnext/public/js/event.js,Add Customers,Dodaj korisnike
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Pending Amount,Iznos na čekanju
DocType: Lab Test Template,Special,poseban
DocType: Loyalty Program,Conversion Factor,Konverzijski faktor
DocType: Purchase Order,Delivered,Isporučeno
,Vehicle Expenses,Troškovi vozila
DocType: Healthcare Settings,Create Lab Test(s) on Sales Invoice Submit,Napravite laboratorijske testove na prodajnoj dostavnici
DocType: Serial No,Invoice Details,Pojedinosti fakture
apps/erpnext/erpnext/regional/india/utils.py,Salary Structure must be submitted before submission of Tax Ememption Declaration,Struktura plaće mora se podnijeti prije podnošenja Izjave o porezu
DocType: Grant Application,Show on Website,Pokaži na web stranici
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Start on,Započnite
DocType: Hub Tracked Item,Hub Category,Kategorija hubova
DocType: Purchase Invoice,SEZ,SEZ
DocType: Purchase Receipt,Vehicle Number,Broj vozila
DocType: Loan,Loan Amount,Iznos pozajmice
DocType: Student Report Generation Tool,Add Letterhead,Dodaj pismo zaglavlja
DocType: Program Enrollment,Self-Driving Vehicle,Vozila samostojećih
DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Stalna ocjena dobavljača
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Row {0}: Bill of Materials not found for the Item {1},Redak {0}: broj materijala koji nije pronađen za stavku {1}
DocType: Contract Fulfilment Checklist,Requirement,Zahtjev
DocType: Journal Entry,Accounts Receivable,Potraživanja
DocType: Quality Goal,Objectives,Ciljevi
DocType: Travel Itinerary,Meal Preference,Preference obroka
,Supplier-Wise Sales Analytics,Supplier -mudar prodaje Analytics
apps/erpnext/erpnext/accounts/doctype/subscription_plan/subscription_plan.py,Billing Interval Count cannot be less than 1,Interval naplate ne može biti manji od 1
DocType: Purchase Invoice,Availed ITC Central Tax,Availed ITC Central Tax
DocType: Sales Invoice,Company Address Name,Naziv tvrtke
DocType: Work Order,Use Multi-Level BOM,Koristite multi-level BOM
DocType: Bank Reconciliation,Include Reconciled Entries,Uključi pomirio objave
apps/erpnext/erpnext/accounts/doctype/bank_transaction/bank_transaction.py,The total allocated amount ({0}) is greated than the paid amount ({1}).,Ukupni dodijeljeni iznos ({0}) namazan je od uplaćenog iznosa ({1}).
DocType: Landed Cost Voucher,Distribute Charges Based On,Distribuirati optužbi na temelju
DocType: Projects Settings,Timesheets,timesheets
DocType: HR Settings,HR Settings,HR postavke
apps/erpnext/erpnext/config/accounting.py,Accounting Masters,Majstori računovodstva
DocType: Salary Slip,net pay info,Neto info plaća
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CESS Amount,Iznos CESS
DocType: Woocommerce Settings,Enable Sync,Omogući sinkronizaciju
DocType: Tax Withholding Rate,Single Transaction Threshold,Prag pojedinačne transakcije
DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Ova je vrijednost ažurirana u zadanom cjeniku prodajnih cijena.
apps/erpnext/erpnext/templates/pages/cart.html,Your cart is Empty,Vaša je košarica prazna
DocType: Email Digest,New Expenses,Novi troškovi
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Cannot Optimize Route as Driver Address is Missing.,Ruta se ne može optimizirati jer nedostaje adresa vozača.
DocType: Shareholder,Shareholder,dioničar
DocType: Purchase Invoice,Additional Discount Amount,Dodatni popust Iznos
DocType: Cash Flow Mapper,Position,Položaj
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Get Items from Prescriptions,Preuzmite stavke iz recepata
DocType: Patient,Patient Details,Detalji pacijenta
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Nature Of Supplies,Priroda potrepština
DocType: Inpatient Record,B Positive,B Pozitivan
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",Maksimalna korist zaposlenika {0} premašuje {1} sumu {2} prethodnog zahtjeva \ iznosa
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.","Red # {0}: Količina mora biti jedan, jer predmet je fiksni kapital. Molimo koristite poseban red za više kom."
DocType: Leave Block List Allow,Leave Block List Allow,Odobrenje popisa neodobrenih odsustava
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbr can not be blank or space,Abbr ne može biti prazno ili razmak
DocType: Patient Medical Record,Patient Medical Record,Patient Medical Record
DocType: Quality Meeting Agenda,Quality Meeting Agenda,Kvalitetni dnevni sastanak
apps/erpnext/erpnext/accounts/doctype/account/account.js,Group to Non-Group,Grupa ne-Group
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Sports,sportovi
DocType: Leave Control Panel,Employee (optional),Zaposlenik (neobavezno)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Material Request {0} submitted.,Poslan je materijalni zahtjev {0}.
DocType: Loan Type,Loan Name,Naziv kredita
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Actual,Ukupno Stvarni
DocType: Chart of Accounts Importer,Chart Preview,Pregled grafikona
DocType: Attendance,Shift,smjena
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,Enter API key in Google Settings.,Unesite ključ API-a u Google postavke.
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Create Journal Entry,Stvorite unos u časopis
DocType: Student Siblings,Student Siblings,Studentski Braća i sestre
DocType: Subscription Plan Detail,Subscription Plan Detail,Detalji o planu pretplate
DocType: Quality Objective,Unit,jedinica
apps/erpnext/erpnext/stock/get_item_details.py,Please specify Company,Navedite tvrtke
,Customer Acquisition and Loyalty,Stjecanje kupaca i lojalnost
DocType: Issue,Response By Variance,Odgovor prema varijanci
DocType: Asset Maintenance Task,Maintenance Task,Zadatak održavanja
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Please set B2C Limit in GST Settings.,Postavite ograničenje B2C u GST postavkama.
DocType: Marketplace Settings,Marketplace Settings,Postavke tržnice
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,Skladište na kojem držite zalihe odbijenih proizvoda
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Publish {0} Items,Objavite {0} stavke
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,Nije moguće pronaći kurs za {0} do {1} za ključni datum {2}. Ručno stvorite zapis za mjenjačnicu
DocType: POS Profile,Price List,Cjenik
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 sada zadana fiskalna godina. Osvježi preglednik kako bi se promjene aktualizirale.
apps/erpnext/erpnext/projects/doctype/task/task.js,Expense Claims,Rashodi Potraživanja
DocType: Issue,Support,Podrška
DocType: Employee Tax Exemption Declaration,Total Exemption Amount,Iznos ukupno oslobođenja
DocType: Content Question,Question Link,Link pitanja
,BOM Search,BOM Pretraživanje
DocType: Accounting Dimension Detail,Mandatory For Balance Sheet,Obavezno za bilancu
DocType: Project,Total Consumed Material Cost  (via Stock Entry),Ukupni trošak potrošenog materijala (putem stanja na burzi)
DocType: Subscription,Subscription Period,Razdoblje pretplate
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js,To Date cannot be less than From Date,Do datuma ne može biti manji od datuma
,Delayed Order Report,Izvješće o odgođenom nalogu
DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Objavite &quot;na zalihi&quot; ili &quot;nije na zalihi&quot; na hubu na temelju dostupnih dionica u ovom skladištu.
DocType: Vehicle,Fuel Type,Vrsta goriva
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Navedite valutu u Društvu
DocType: Workstation,Wages per hour,Satnice
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfigurirajte {0}
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Stock ravnoteža u batch {0} postat negativna {1} za točku {2} na skladištu {3}
apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Sljedeći materijal Zahtjevi su automatski podigli na temelju stavke razini ponovno narudžbi
apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Račun {0} je nevažeći. 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 može biti nakon datuma olakšavanja zaposlenika {1}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Debit Note {0} has been created automatically,Bilješka o zaduženju {0} stvorena je automatski
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Create Payment Entries,Stvorite uplate za plaćanje
DocType: Supplier,Is Internal Supplier,Je li unutarnji dobavljač
DocType: Employee,Create User Permission,Izradi User Permission
DocType: Employee Benefit Claim,Employee Benefit Claim,Zahtjev za naknadu zaposlenika
DocType: Healthcare Settings,Remind Before,Podsjetite prije
apps/erpnext/erpnext/buying/utils.py,UOM Conversion factor is required in row {0},Faktor UOM pretvorbe je potrebno u redu {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","Red # {0}: Referenca Tip dokumenta mora biti jedan od prodajnog naloga, prodaja fakture ili Journal Entry"
DocType: Loyalty Program,1 Loyalty Points = How much base currency?,1 lojalnost bodova = kolika bazna valuta?
DocType: Salary Component,Deduction,Odbitak
DocType: Item,Retain Sample,Zadrži uzorak
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: From Time and To Time is mandatory.,Red {0}: Od vremena i vremena je obavezno.
DocType: Stock Reconciliation Item,Amount Difference,iznos razlika
apps/erpnext/erpnext/public/js/hub/pages/Buying.vue,This page keeps track of items you want to buy from sellers.,Ova stranica prati stvari koje želite kupiti od prodavača.
apps/erpnext/erpnext/stock/get_item_details.py,Item Price added for {0} in Price List {1},Cijena dodana za {0} u cjeniku {1}
DocType: Delivery Stop,Order Information,Informacije o narudžbi
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js,Please enter Employee Id of this sales person,Unesite ID zaposlenika ove prodaje osobi
DocType: Territory,Classification of Customers by region,Klasifikacija korisnika po regiji
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,In Production,U proizvodnji
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Difference Amount must be zero,Razlika Iznos mora biti jednak nuli
DocType: Project,Gross Margin,Bruto marža
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} applicable after {1} working days,{0} primjenjivo nakon {1} radnih dana
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Please enter Production Item first,Unesite Proizvodnja predmeta prvi
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Calculated Bank Statement balance,Izračunato banka Izjava stanje
DocType: Normal Test Template,Normal Test Template,Predložak za normalan test
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,disabled user,onemogućen korisnika
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Quotation,Ponuda
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Cannot set a received RFQ to No Quote,Nije moguće postaviti primljeni RFQ na nijedan citat
DocType: Salary Slip,Total Deduction,Ukupno Odbitak
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Select an account to print in account currency,Odaberite račun za ispis u valuti računa
DocType: BOM,Transfer Material Against,Prijenos materijala protiv
,Production Analytics,Proizvodnja Analytics
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py,This is based on transactions against this Patient. See timeline below for details,To se temelji na transakcijama protiv ovog pacijenta. Pojedinosti potražite u nastavku
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.py,Loan Start Date and Loan Period are mandatory to save the Invoice Discounting,Datum početka i razdoblje zajma obvezni su za spremanje popusta na fakture
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Cost Updated,Trošak Ažurirano
apps/erpnext/erpnext/regional/india/utils.py,Vehicle Type is required if Mode of Transport is Road,Vrsta vozila potrebna je ako je način prijevoza cestovni
DocType: Inpatient Record,Date of Birth,Datum rođenja
DocType: Quality Action,Resolutions,rezolucije
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Item {0} has already been returned,Proizvod {0} je već vraćen
DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,**Fiskalna godina** predstavlja poslovnu godinu. Svi računovodstvene stavke i druge glavne transakcije su praćene od **Fiskalne godine**.
DocType: Opportunity,Customer / Lead Address,Kupac / Olovo Adresa
DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Postavljanje tablice dobavljača
DocType: Customer Credit Limit,Customer Credit Limit,Kreditni limit klijenta
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Assessment Plan Name,Naziv plana procjene
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Target Details,Pojedinosti cilja
apps/erpnext/erpnext/regional/italy/setup.py,"Applicable if the company is SpA, SApA or SRL","Primjenjivo ako je tvrtka SpA, SApA ili SRL"
DocType: Work Order Operation,Work Order Operation,Radni nalog
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid SSL certificate on attachment {0},Upozorenje: Invalid SSL potvrda o vezanosti {0}
apps/erpnext/erpnext/regional/italy/setup.py,Set this if the customer is a Public Administration company.,To postavite ako je kupac tvrtka za javnu upravu.
apps/erpnext/erpnext/utilities/activation.py,"Leads help you get business, add all your contacts and more as your leads","Potencijalni kupci će vam pomoći u posao, dodati sve svoje kontakte, a više kao svoje potencijalne klijente"
DocType: Work Order Operation,Actual Operation Time,Stvarni Operacija vrijeme
DocType: Authorization Rule,Applicable To (User),Odnosi se na (Upute)
DocType: Purchase Taxes and Charges,Deduct,Odbiti
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Job Description,Opis Posla
DocType: Student Applicant,Applied,primijenjen
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Details of Outward Supplies and inward supplies liable to reverse charge,Pojedinosti o vanjskim potrepštinama i unutarnjim zalihama koje mogu podnijeti povratno punjenje
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Re-open,Ponovno otvorena
DocType: Sales Invoice Item,Qty as per Stock UOM,Količina po skladišnom UOM-u
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Name,Ime Guardian2
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Root Company,Root Company
DocType: Attendance,Attendance Request,Zahtjev za sudjelovanjem
DocType: Purchase Invoice,02-Post Sale Discount,02-Popust na prodaju
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Pratite podatke o prodajnim kampanjama. Vodite zapise o potencijalima, ponudama, narudžbama itd kako bi ste procijenili povrat ulaganje ROI."
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,You can't redeem Loyalty Points having more value than the Grand Total.,Ne možete iskoristiti bodove lojalnosti koji imaju više vrijednosti od ukupnog iznosa.
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 Dioničar ne može biti prazno
DocType: Guardian,Work Address,Adresa na poslu
DocType: Appraisal,Calculate Total Score,Izračunajte ukupni rezultat
DocType: Employee,Health Insurance,Zdravstveno osiguranje
DocType: Asset Repair,Manufacturing Manager,Upravitelj proizvodnje
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} is under warranty upto {1},Serijski Ne {0} je pod jamstvom upto {1}
DocType: Plant Analysis Criteria,Minimum Permissible Value,Minimalna dopuštena vrijednost
apps/erpnext/erpnext/education/doctype/guardian/guardian.py,User {0} already exists,Korisnik {0} već postoji
apps/erpnext/erpnext/hooks.py,Shipments,Pošiljke
DocType: Payment Entry,Total Allocated Amount (Company Currency),Ukupno Dodijeljeni iznos (Društvo valuta)
DocType: Purchase Order Item,To be delivered to customer,Da biste se dostaviti kupcu
DocType: BOM,Scrap Material Cost,Otpaci materijalni troškovi
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to any Warehouse,Serijski broj {0} ne pripada bilo Skladište
DocType: Grant Application,Email Notification Sent,Poslana obavijest e-pošte
DocType: Purchase Invoice,In Words (Company Currency),Riječima (valuta tvrtke)
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py,Company is manadatory for company account,Tvrtka je racionalna za račun tvrtke
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,"Item Code, warehouse, quantity are required on row","Šifra stavke, skladište, količina potrebna su u retku"
DocType: Bank Guarantee,Supplier,Dobavljač
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Get From,Dobiti Iz
apps/erpnext/erpnext/hr/doctype/department/department.js,This is a root department and cannot be edited.,Ovo je korijenski odjel i ne može se uređivati.
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show Payment Details,Prikaži pojedinosti o plaćanju
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Duration in Days,Trajanje u danima
DocType: C-Form,Quarter,Četvrtina
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Miscellaneous Expenses,Razni troškovi
DocType: Global Defaults,Default Company,Zadana tvrtka
DocType: Company,Transactions Annual History,Transakcije Godišnja povijest
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Bank account '{0}' has been synchronized,Bankovni račun &quot;{0}&quot; sinkroniziran je
apps/erpnext/erpnext/controllers/stock_controller.py,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Rashodi ili razlika račun je obvezna za točke {0} jer utječe na ukupnu vrijednost dionica
DocType: Bank,Bank Name,Naziv banke
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Leave the field empty to make purchase orders for all suppliers,Ostavite prazno polje za narudžbenice za sve dobavljače
DocType: Healthcare Practitioner,Inpatient Visit Charge Item,Naknada za naplatu bolničkog posjeta
DocType: Vital Signs,Fluid,tekućina
DocType: Leave Application,Total Leave Days,Ukupno Ostavite Dani
DocType: Email Digest,Note: Email will not be sent to disabled users,Napomena: E-mail neće biti poslan nepostojećim korisnicima
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Number of Interaction,Broj interakcija
DocType: GSTR 3B Report,February,veljača
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant Settings,Postavke varijacije stavke
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Company...,Odaberite tvrtku ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} is mandatory for Item {1},{0} je obavezno za točku {1}
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Item {0}: {1} qty produced, ","Stavka {0}: {1} qty proizvedena,"
DocType: Payroll Entry,Fortnightly,četrnaestodnevni
DocType: Currency Exchange,From Currency,Od novca
DocType: Vital Signs,Weight (In Kilogram),Težina (u kilogramu)
DocType: Chapter,"chapters/chapter_name
leave blank automatically set after saving chapter.",poglavlja / naziv poglavlja ostavite prazno automatski postavljeno nakon spremanja poglavlja.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Please set GST Accounts in GST Settings,Postavite GST račune u GST postavkama
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Type of Business,Vrsta poslovanja
DocType: Sales Invoice,Consumer,Potrošač
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Odaberite Dodijeljeni iznos, Vrsta računa i broj računa u atleast jednom redu"
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of New Purchase,Trošak kupnje novog
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Sales Order required for Item {0},Prodajnog naloga potrebna za točke {0}
DocType: Grant Application,Grant Description,Opis potpore
DocType: Purchase Invoice Item,Rate (Company Currency),Ocijeni (Društvo valuta)
DocType: Student Guardian,Others,Ostali
DocType: Subscription,Discounts,Popusti
DocType: Bank Transaction,Unallocated Amount,Nealocirano Količina
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,Omogući primjenjivo na narudžbenicu i odnosi se na aktualne troškove rezervacije
apps/erpnext/erpnext/templates/includes/product_page.js,Cannot find a matching Item. Please select some other value for {0}.,Ne možete pronaći odgovarajući stavku. Odaberite neku drugu vrijednost za {0}.
DocType: POS Profile,Taxes and Charges,Porezi i naknade
DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Proizvod ili usluga koja je kupljena, prodana ili zadržana na lageru."
apps/erpnext/erpnext/hr/page/team_updates/team_updates.js,No more updates,Nema više ažuriranja
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 možete odabrati vrstu naboja kao ' na prethodnim Row Iznos ""ili"" u odnosu na prethodnu Row Ukupno ""za prvi red"
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 obuhvaća sve bodove vezane uz ovu postavku
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Dijete Stavka ne bi trebao biti proizvod Bundle. Uklonite stavku &#39;{0}&#39; i spremanje
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Banking,Bankarstvo
apps/erpnext/erpnext/utilities/activation.py,Add Timesheets,Dodaj timesheets
DocType: Vehicle Service,Service Item,usluga predmeta
DocType: Bank Guarantee,Bank Guarantee,Jamstvo banke
DocType: Payment Request,Transaction Details,detalji transakcije
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule' to get schedule,"Molimo kliknite na ""Generiraj raspored ' kako bi dobili raspored"
DocType: Item,"Purchase, Replenishment Details","Pojedinosti o kupnji, dopuni"
DocType: Products Settings,Enable Field Filters,Omogući filtre polja
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot be Purchase Item also",&quot;Kupčev predmet&quot; također ne može biti predmet kupnje
DocType: Blanket Order Item,Ordered Quantity,Naručena količina
apps/erpnext/erpnext/public/js/setup_wizard.js,"e.g. ""Build tools for builders""","na primjer ""Alati za graditelje"""
DocType: Grading Scale,Grading Scale Intervals,Ljestvici Intervali
apps/erpnext/erpnext/regional/india/utils.py,Invalid {0}! The check digit validation has failed. ,Nevažeći {0}! Provjera kontrolne znamenke nije uspjela.
DocType: Item Default,Purchase Defaults,Zadane postavke kupnje
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Automatski se ne može izraditi Credit Note, poništite potvrdni okvir &#39;Issue Credit Note&#39; i ponovno pošaljite"
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Added to Featured Items,Dodano u istaknute stavke
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py,Profit for the year,Dobit za godinu
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}: knjiženje za {2} je moguće izvesti samo u valuti: {3}
DocType: Fee Schedule,In Process,U procesu
DocType: Authorization Rule,Itemwise Discount,Itemwise popust
apps/erpnext/erpnext/config/accounting.py,Tree of financial accounts.,Drvo financijske račune.
DocType: Cash Flow Mapping,Cash Flow Mapping,Mapiranje novčanog toka
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Order {1},{0} u odnosu na prodajni nalog {1}
DocType: Account,Fixed Asset,Dugotrajna imovina
DocType: Amazon MWS Settings,After Date,Nakon datuma
apps/erpnext/erpnext/config/help.py,Serialized Inventory,Serijaliziranom Inventar
,Department Analytics,Analytics odjela
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Email not found in default contact,Email nije pronađen u zadanom kontaktu
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Generate Secret,Generirajte tajnu
DocType: Question,Question,Pitanje
DocType: Loan,Account Info,Informacije računa
DocType: Activity Type,Default Billing Rate,Zadana naplate stopa
DocType: Fees,Include Payment,Uključi plaćanje
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,{0} Student Groups created.,Stvorena je {0} studentska grupa.
DocType: Sales Invoice,Total Billing Amount,Ukupno naplate Iznos
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py,Program in the Fee Structure and Student Group {0} are different.,Program u strukturi naknada i studentskoj grupi {0} razlikuju se.
DocType: Bank Statement Transaction Entry,Receivable Account,Potraživanja račun
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Valid From Date must be lesser than Valid Upto Date.,Vrijedi od datuma mora biti manji od Valid Upto Date.
DocType: Employee Skill,Evaluation Date,Datum evaluacije
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} is already {2},Red # {0}: Imovina {1} Već {2}
DocType: Quotation Item,Stock Balance,Skladišna bilanca
apps/erpnext/erpnext/config/help.py,Sales Order to Payment,Prodajnog naloga za plaćanje
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,CEO,CEO
DocType: Purchase Invoice,With Payment of Tax,Uz plaćanje poreza
DocType: Expense Claim Detail,Expense Claim Detail,Rashodi Zahtjev Detalj
apps/erpnext/erpnext/education/utils.py,You are not allowed to enroll for this course,Nije vam dopušteno upisati se na ovaj tečaj
DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,TRIPLICATE ZA DOBAVLJAČ
DocType: Exchange Rate Revaluation Account,New Balance In Base Currency,Novi saldo u osnovnoj valuti
DocType: Location,Is Container,Je li kontejner
DocType: Crop Cycle,This will be day 1 of the crop cycle,Ovo će biti prvi dan ciklusa usjeva
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please select correct account,Molimo odaberite ispravnu račun
DocType: Salary Structure Assignment,Salary Structure Assignment,Dodjela strukture plaća
DocType: Purchase Invoice Item,Weight UOM,Težina UOM
apps/erpnext/erpnext/config/accounting.py,List of available Shareholders with folio numbers,Popis dostupnih dioničara s folijskim brojevima
DocType: Salary Structure Employee,Salary Structure Employee,Struktura plaća zaposlenika
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Show Variant Attributes,Prikaži svojstva varijacije
DocType: Student,Blood Group,Krvna grupa
DocType: Purchase Invoice Item,Page Break,Prijelom stranice
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 za gateway plaćanja u planu {0} se razlikuje od računa za pristupnik plaćanja u ovom zahtjevu za plaćanje
DocType: Course,Course Name,Naziv predmeta
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py,No Tax Withholding data found for the current Fiscal Year.,Nema podataka o zadržavanju poreza za aktualnu fiskalnu godinu.
DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,Korisnici koji može odobriti dopust aplikacije neke specifične zaposlenika
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Equipments,Uredska oprema
DocType: Pricing Rule,Qty,Kol
DocType: Fiscal Year,Companies,Tvrtke
DocType: Supplier Scorecard,Scoring Setup,Bodovanje postavki
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Electronics,Elektronika
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Debit ({0}),Debit ({0})
DocType: BOM,Allow Same Item Multiple Times,Omogući istu stavku više puta
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Podignite Materijal Zahtjev kad dionica dosegne ponovno poredak razinu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Full-time,Puno radno vrijeme
DocType: Payroll Entry,Employees,zaposlenici
DocType: Question,Single Correct Answer,Jedan točan odgovor
DocType: C-Form,Received Date,Datum pozicija
DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Ako ste stvorili standardni predložak u prodaji poreze i troškove predložak, odaberite jednu i kliknite na gumb ispod."
DocType: BOM Scrap Item,Basic Amount (Company Currency),Osnovni Iznos (Društvo valuta)
DocType: Student,Guardians,čuvari
apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html,Payment Confirmation,Potvrda uplate
apps/erpnext/erpnext/regional/india/utils.py,Unsupported GST Category for e-Way Bill JSON generation,Nepodržana GST kategorija za e-Way Bill JSON generacije
DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,Cijene neće biti prikazana ako Cjenik nije postavljena
DocType: Material Request Item,Received Quantity,Primljena 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ći od Od datuma
DocType: Stock Entry,Total Incoming Value,Ukupno Dolazni vrijednost
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To is required,Zaduženja je potrebno
DocType: Clinical Procedure,Inpatient Record,Popis bolesnika
apps/erpnext/erpnext/utilities/activation.py,"Timesheets help keep track of time, cost and billing for activites done by your team","Timesheets pomoći pratiti vrijeme, troškove i naplatu za aktivnostima obavljaju unutar vašeg tima"
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,Purchase Price List,Kupovni cjenik
DocType: Communication Medium Timeslot,Employee Group,Grupa zaposlenika
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.,Predlošci varijabli s rezultatima dobavljača.
DocType: Job Offer Term,Offer Term,Ponuda Pojam
DocType: Asset,Quality Manager,Upravitelj kvalitete
DocType: Job Applicant,Job Opening,Posao Otvaranje
DocType: Employee,Default Shift,Zadana smjena
DocType: Payment Reconciliation,Payment Reconciliation,Pomirenje plaćanja
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select Incharge Person's name,Odaberite incharge ime osobe
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Technology,tehnologija
apps/erpnext/erpnext/public/js/utils.js,Total Unpaid: {0},Ukupno Neplaćeni: {0}
DocType: BOM Website Operation,BOM Website Operation,BOM Web Rad
DocType: Bank Statement Transaction Payment Item,outstanding_amount,preostali iznos
DocType: Supplier Scorecard,Supplier Score,Ocjena dobavljača
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Admission,Raspored prijama
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Total Payment Request amount cannot be greater than {0} amount,Ukupni iznos zahtjeva za plaćanje ne može biti veći od {0}
DocType: Tax Withholding Rate,Cumulative Transaction Threshold,Kumulativni Prag transakcije
DocType: Promotional Scheme Price Discount,Discount Type,Vrsta popusta
DocType: Purchase Invoice Item,Is Free Item,Je besplatna stavka
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.,"Postotak koji vam dopušta prijenos više u odnosu na naručenu količinu. Na primjer: Ako ste naručili 100 jedinica. a vaš dodatak iznosi 10%, tada vam je omogućen prijenos 110 jedinica."
DocType: Supplier,Warn RFQs,Upozorite RFQ-ove
apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Explore,Istražiti
DocType: BOM,Conversion Rate,Stopa pretvorbe
apps/erpnext/erpnext/www/all-products/index.html,Product Search,Pretraga proizvoda
,Bank Remittance,Doznaka banke
DocType: Cashier Closing,To Time,Za vrijeme
DocType: Invoice Discounting,Loan End Date,Datum završetka zajma
apps/erpnext/erpnext/hr/utils.py,) for {0},) za {0}
DocType: Authorization Rule,Approving Role (above authorized value),Odobravanje ulogu (iznad ovlaštenog vrijednosti)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Payable account,Kredit računa mora biti naplativo račun
DocType: Loan,Total Amount Paid,Plaćeni ukupni iznos
DocType: Asset,Insurance End Date,Završni datum osiguranja
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Please select Student Admission which is mandatory for the paid student applicant,Molimo odaberite Studentski ulaz koji je obvezan za plaćenog studenta
DocType: Pick List,STO-PICK-.YYYY.-,STO-PICK-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,Budget List,Popis proračuna
DocType: Campaign,Campaign Schedules,Rasporedi kampanje
DocType: Job Card Time Log,Completed Qty,Završen Kol
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"For {0}, only debit accounts can be linked against another credit entry","Za {0}, samo debitne računi se mogu povezati protiv druge kreditne stupanja"
DocType: Manufacturing Settings,Allow Overtime,Dopusti Prekovremeni
DocType: Training Event Employee,Training Event Employee,Trening utrka zaposlenika
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Maksimalni uzorci - {0} mogu se zadržati za šaržu {1} i stavku {2}.
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Time Slots,Dodaj vrijeme
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} serijski brojevi potrebni za Artikl {1}. Ti su dali {2}.
DocType: Stock Reconciliation Item,Current Valuation Rate,Trenutno Vrednovanje Ocijenite
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Number of root accounts cannot be less than 4,Broj korijenskih računa ne može biti manji od 4
DocType: Training Event,Advance,napredovati
apps/erpnext/erpnext/config/integrations.py,GoCardless payment gateway settings,Postavke GoCardless gateway plaćanja
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Exchange Gain/Loss,Razmjena Dobit / gubitak
DocType: Opportunity,Lost Reason,Razlog gubitka
DocType: Amazon MWS Settings,Enable Amazon,Omogućite Amazon
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Account {1} does not belong to company {2},Red # {0}: Račun {1} ne pripada tvrtki {2}
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Unable to find DocType {0},Nije moguće pronaći DocType {0}
apps/erpnext/erpnext/public/js/templates/address_list.html,New Address,Nova adresa
DocType: Quality Inspection,Sample Size,Veličina uzorka
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Please enter Receipt Document,Unesite primitka dokumenta
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,All items have already been invoiced,Svi proizvodi su već fakturirani
apps/erpnext/erpnext/hr/report/employee_leave_balance_summary/employee_leave_balance_summary.py,Leaves Taken,Lišće uzeto
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Please specify a valid 'From Case No.',Navedite važeću &#39;iz Predmet br&#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,"Daljnje troška mogu biti u skupinama, ali unose se može podnijeti protiv nesrpskog Groups"
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,Ukupni dodijeljeni listovi su više dana od maksimalne raspodjele {0} vrste dopusta za zaposlenika {1} u razdoblju
DocType: Branch,Branch,Grana
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Other outward supplies(Nil rated,Exempted)","Ostale vanjske zalihe (ocjenjivano bez vrijednosti, izuzeće)"
DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
DocType: Delivery Trip,Fulfillment User,Korisnik ispunjavanja
apps/erpnext/erpnext/config/settings.py,Printing and Branding,Tiskanje i brendiranje
DocType: Company,Total Monthly Sales,Ukupna mjesečna prodaja
DocType: Course Activity,Enrollment,Upis
DocType: Payment Request,Subscription Plans,Planovi pretplate
DocType: Agriculture Analysis Criteria,Weather,Vrijeme
DocType: Bin,Actual Quantity,Stvarna količina
DocType: Shipping Rule,example: Next Day Shipping,Primjer: Sljedeći dan Dostava
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} not found,Serijski broj {0} nije pronađen
DocType: Fee Schedule Program,Fee Schedule Program,Program rasporeda naknada
DocType: Fee Schedule Program,Student Batch,Student serije
DocType: Pricing Rule,Advanced Settings,Napredne postavke
DocType: Supplier Scorecard Scoring Standing,Min Grade,Min Grade
DocType: Healthcare Service Unit Type,Healthcare Service Unit Type,Vrsta jedinice za pružanje zdravstvene zaštite
DocType: Training Event Employee,Feedback Submitted,povratne informacije Prijavljen
apps/erpnext/erpnext/projects/doctype/project/project.py,You have been invited to collaborate on the project: {0},Pozvani ste za suradnju na projektu: {0}
DocType: Supplier Group,Parent Supplier Group,Grupa dobavljača roditelja
DocType: Email Digest,Purchase Orders to Bill,Nalozi za kupnju
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Accumulated Values in Group Company,Akumulirane vrijednosti u grupi tvrtke
DocType: Leave Block List Date,Block Date,Datum bloka
DocType: Item,You can use any valid Bootstrap 4 markup in this field. It will be shown on your Item Page.,U ovom polju možete koristiti bilo koje važeće oznake Bootstrap 4. To će se prikazati na vašoj stranici predmeta.
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Outward taxable supplies(other than zero rated, nil rated and exempted","Porezni porezi (osim nule, nula i izuzeti)"
DocType: Crop,Crop,Usjev
DocType: Purchase Receipt,Supplier Delivery Note,Isporuka isporuke dobavljača
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Apply Now,Primijeni sada
DocType: Employee Tax Exemption Proof Submission Detail,Type of Proof,Vrsta dokaza
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html,Actual Qty {0} / Waiting Qty {1},Stvarna kol {0} / Na čekanju kol {1}
DocType: Purchase Invoice,E-commerce GSTIN,E-trgovina GSTIN
DocType: Sales Order,Not Delivered,Ne isporučeno
,Bank Clearance Summary,Razmak banka Sažetak
apps/erpnext/erpnext/config/settings.py,"Create and manage daily, weekly and monthly email digests.","Stvaranje i upravljanje automatskih mailova na dnevnoj, tjednoj i mjesečnoj bazi."
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 se temelji na transakcijama protiv ove prodajne osobe. Pojedinosti potražite u nastavku
DocType: Appraisal Goal,Appraisal Goal,Procjena gol
DocType: Stock Reconciliation Item,Current Amount,Trenutni iznos
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Buildings,Građevine
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Leaves has been granted sucessfully,Lišće je dobilo uspješno
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Invoice,Nova faktura
DocType: Products Settings,Enable Attribute Filters,Omogući filtre atributa
DocType: Fee Schedule,Fee Structure,Struktura naknade
DocType: Timesheet Detail,Costing Amount,Obračun troškova Iznos
DocType: Student Admission Program,Application Fee,Naknada Primjena
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Slanje plaće Slip
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Na čekanju
apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Q qurance mora imati barem jednu ispravnu mogućnost
DocType: Account,Inter Company Account,Inter račun tvrtke
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Uvoz u rasutom stanju
DocType: Sales Partner,Address & Contacts,Adresa i kontakti
DocType: SMS Log,Sender Name,Pošiljatelj Ime
DocType: Vital Signs,Very Hyper,Vrlo hiper
DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Kriteriji analize poljoprivrede
DocType: HR Settings,Leave Approval Notification Template,Ostavite predložak za obavijesti o odobrenju
DocType: POS Profile,[Select],[Odaberi]
DocType: Staffing Plan Detail,Number Of Positions,Broj mjesta
DocType: Vital Signs,Blood Pressure (diastolic),Krvni tlak (dijastolički)
DocType: SMS Log,Sent To,Poslano Da
DocType: Agriculture Task,Holiday Management,Upravljanje odmorom
DocType: Payment Request,Make Sales Invoice,Napravi prodajni račun
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Softwares,Software
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Next Contact Date cannot be in the past,Sljedeća Kontakt Datum ne može biti u prošlosti
DocType: Company,For Reference Only.,Za samo kao referenca.
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select Batch No,Odaberite šifra serije
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Invalid {0}: {1},Pogrešna {0}: {1}
,GSTR-1,GSTR-1
DocType: Fee Validity,Reference Inv,Referenca Inv
DocType: Sales Invoice Advance,Advance Amount,Iznos predujma
DocType: Manufacturing Settings,Capacity Planning,Planiranje kapaciteta
DocType: Supplier Quotation,Rounding Adjustment (Company Currency,Podešavanje zaokruživanja (valuta tvrtke
DocType: Asset,Policy number,Broj osiguranja
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,'From Date' is required,'Od datuma' je potrebno
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign to Employees,Dodijeliti zaposlenicima
DocType: Bank Transaction,Reference Number,Referentni broj
DocType: Employee,New Workplace,Novo radno mjesto
DocType: Retention Bonus,Retention Bonus,Bonus zadržavanja
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Material Consumption,Potrošnja materijala
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Closed,Postavi kao zatvoreno
apps/erpnext/erpnext/stock/get_item_details.py,No Item with Barcode {0},Nema proizvoda sa barkodom {0}
DocType: Normal Test Items,Require Result Value,Zahtijevati vrijednost rezultata
DocType: Purchase Invoice,Pricing Rules,Pravila cijena
DocType: Item,Show a slideshow at the top of the page,Prikaži slideshow na vrhu stranice
DocType: Tax Withholding Rate,Tax Withholding Rate,Stopa zadržavanja poreza
DocType: Pricing Rule,Max Amt,Max Amt
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Boms,Sastavnice
apps/erpnext/erpnext/stock/doctype/item/item.py,Stores,prodavaonice
DocType: Project Type,Projects Manager,Projekti Manager
DocType: Serial No,Delivery Time,Vrijeme isporuke
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Based On,Starenje temelju On
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Appointment cancelled,Imenovanje je otkazano
DocType: Item,End of Life,Kraj života
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Travel,putovanje
DocType: Student Report Generation Tool,Include All Assessment Group,Uključi sve grupe za procjenu
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,No active or default Salary Structure found for employee {0} for the given dates,Ne aktivni ili zadani Struktura plaća pronađeno za zaposlenika {0} za navedene datume
DocType: Leave Block List,Allow Users,Omogućiti korisnicima
DocType: Purchase Order,Customer Mobile No,Kupac mobilne Ne
DocType: Leave Type,Calculated in days,Izračunato u danima
DocType: Call Log,Received By,Primljeno od
DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Pojedinosti o predlošku mapiranja novčanog toka
apps/erpnext/erpnext/config/non_profit.py,Loan Management,Upravljanje zajmom
DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Pratite poseban prihodi i rashodi za vertikala proizvoda ili podjele.
DocType: Rename Tool,Rename Tool,Preimenovanje
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Update Cost,Update cost
DocType: Item Reorder,Item Reorder,Ponovna narudžba proizvoda
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,GSTR3B-Form,GSTR3B-Oblik
DocType: Sales Invoice,Mode of Transport,Način prijevoza
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Show Salary Slip,Prikaži Plaća proklizavanja
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Transfer Material,Prijenos materijala
DocType: Fees,Send Payment Request,Pošalji zahtjev za plaćanje
DocType: Travel Request,Any other details,Sve ostale pojedinosti
DocType: Water Analysis,Origin,Podrijetlo
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}?,Ovaj dokument je preko granice po {0} {1} za stavku {4}. Jeste li što drugo {3} protiv iste {2}?
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set recurring after saving,Molimo postavite ponavljajući nakon spremanja
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Select change amount account,Iznos računa Odaberi promjene
DocType: Purchase Invoice,Price List Currency,Valuta cjenika
DocType: Naming Series,User must always select,Korisničko uvijek mora odabrati
DocType: Stock Settings,Allow Negative Stock,Dopustite negativnu zalihu
DocType: Installation Note,Installation Note,Napomena instalacije
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.js,Show Warehouse-wise Stock,Pokažite zalihe pametne
DocType: Soil Texture,Clay,Glina
DocType: Course Topic,Topic,Tema
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Financing,Novčani tijek iz financijskih
DocType: Budget Account,Budget Account,proračun računa
DocType: Quality Inspection,Verified By,Ovjeren od strane
DocType: Travel Request,Name of Organizer,Naziv Organizatora
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 mogu promijeniti tvrtke zadanu valutu , jer postoje neki poslovi . Transakcije mora biti otkazana promijeniti zadanu valutu ."
DocType: Cash Flow Mapping,Is Income Tax Liability,Je li obveza poreza na dobit
DocType: Grading Scale Interval,Grade Description,Razred Opis
DocType: Clinical Procedure,Is Invoiced,Je li fakturiran
apps/erpnext/erpnext/setup/doctype/company/company.js,Create Tax Template,Kreirajte predložak poreza
DocType: Stock Entry,Purchase Receipt No,Primka br.
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,Brodski broj za dostavu
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Salary Slip,Stvaranje plaće Slip
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Traceability,Sljedivost
DocType: Asset Maintenance Log,Actions performed,Radnje izvršene
DocType: Cash Flow Mapper,Section Leader,Voditelj odsjeka
DocType: Sales Invoice,Transport Receipt No,Prijevoz br
DocType: Quiz Activity,Pass,Proći
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Please add the account to root level Company - ,Dodajte račun u korijensku razinu Tvrtka -
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Source of Funds (Liabilities),Izvor sredstava ( pasiva)
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Source and Target Location cannot be same,Izvor i ciljna lokacija ne mogu biti isti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Količina u redku {0} ({1}) mora biti ista kao 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 razlike mora biti račun vrste imovine / odgovornosti, jer je ovaj unos dionica uvodni unos"
DocType: Supplier Scorecard Scoring Standing,Employee,Zaposlenik
DocType: Bank Guarantee,Fixed Deposit Number,Fiksni broj pologa
DocType: Asset Repair,Failure Date,Datum neuspjeha
DocType: Support Search Source,Result Title Field,Polje naslova rezultata
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Summary,Sažetak poziva
DocType: Sample Collection,Collected Time,Prikupljeno vrijeme
DocType: Employee Skill Map,Employee Skills,Vještine zaposlenika
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,Fuel Expense,Rashodi goriva
DocType: Company,Sales Monthly History,Mjesečna povijest prodaje
apps/erpnext/erpnext/regional/italy/utils.py,Please set at least one row in the Taxes and Charges Table,Molimo postavite najmanje jedan redak u tablici poreza i nameta
DocType: Asset Maintenance Task,Next Due Date,Sljedeći datum dospijeća
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch,Odaberite Batch
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is fully billed,{0} {1} je naplaćen u cijelosti
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Vital Signs,Vitalni znakovi
DocType: Payment Entry,Payment Deductions or Loss,Odbici plaćanja ili gubitak
DocType: Soil Analysis,Soil Analysis Criterias,Kriteriji analize tla
apps/erpnext/erpnext/config/settings.py,Standard contract terms for Sales or Purchase.,Standardni uvjeti ugovora za prodaju ili kupnju.
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Rows Removed in {0},Redovi su uklonjeni za {0}
DocType: Shift Type,Begin check-in before shift start time (in minutes),Započnite prijavu prije vremena početka smjene (u minutama)
DocType: BOM Item,Item operation,Radnja stavke
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Voucher,Grupa po jamcu
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Are you sure you want to cancel this appointment?,Jeste li sigurni da želite otkazati ovaj termin?
DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Hotelski paket cijene za sobu
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Sales Pipeline,Prodaja cjevovoda
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set default account in Salary Component {0},Molimo postavite zadani račun plaće komponente {0}
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html,Required On,Potrebna On
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},Odaberite BOM za točku u nizu {0}
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Fetch Subscription Updates,Dohvati ažuriranja pretplate
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 odgovara tvrtki {1} u načinu računa: {2}
apps/erpnext/erpnext/controllers/buying_controller.py,Specified BOM {0} does not exist for Item {1},Određena BOM {0} ne postoji za točku {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,Stavka održavanja {0} mora biti otkazana prije poništenja ove narudžbe kupca
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py,Student LMS Activity,LMS aktivnost učenika
DocType: POS Profile,Applicable for Users,Primjenjivo za korisnike
DocType: Supplier Quotation,PUR-SQTN-.YYYY.-,PUR-SQTN-.YYYY.-
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Project and all Tasks to status {0}?,Postaviti Projekt i sve zadatke na status {0}?
DocType: Purchase Invoice,Set Advances and Allocate (FIFO),Postavi unaprijed i dodijeliti (FIFO)
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No Work Orders created,Nema stvorenih radnih naloga
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Slip of employee {0} already created for this period,Plaća proklizavanja zaposlenika {0} već stvorena za ovo razdoblje
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Pharmaceutical,Farmaceutski
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,You can only submit Leave Encashment for a valid encashment amount,Količinu napuštanja možete poslati samo za valjani iznos naplate
apps/erpnext/erpnext/public/js/hub/pages/SellerItems.vue,Items by ,Predmeti do
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Purchased Items,Troškovi kupljene predmete
DocType: Employee Separation,Employee Separation Template,Predložak za razdvajanje zaposlenika
DocType: Selling Settings,Sales Order Required,Prodajnog naloga Obvezno
apps/erpnext/erpnext/public/js/hub/marketplace.js,Become a Seller,Postanite prodavač
,Procurement Tracker,Tragač za nabavom
DocType: Purchase Invoice,Credit To,Kreditne Da
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Reversed,ITC preokrenut
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid authentication error,Greška provjere autentičnosti
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Active Leads / Customers,Aktivne ponude / kupce
DocType: Delivery Settings,Leave blank to use the standard Delivery Note format,Ostavite prazno da biste koristili standardni format isporuke Napomena
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year End Date should be one year after Fiscal Year Start Date,Datum završetka fiskalne godine trebao bi biti godinu dana nakon datuma početka fiskalne godine
DocType: Employee Education,Post Graduate,Post diplomski
DocType: Quality Meeting,Agenda,dnevni red
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Detalji rasporeda održavanja
DocType: Supplier Scorecard,Warn for new Purchase Orders,Upozorenje za nove narudžbenice
DocType: Quality Inspection Reading,Reading 9,Čitanje 9
apps/erpnext/erpnext/config/integrations.py,Connect your Exotel Account to ERPNext and track call logs,Povežite svoj Exotel račun na ERPNext i pratite zapise poziva
DocType: Supplier,Is Frozen,Je Frozen
DocType: Tally Migration,Processed Files,Obrađene datoteke
apps/erpnext/erpnext/stock/utils.py,Group node warehouse is not allowed to select for transactions,Čvor Grupa skladište ne smije odabrati za transakcije
DocType: Buying Settings,Buying Settings,Ppostavke nabave
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM broj za Gotovi Dobar točki
DocType: Upload Attendance,Attendance To Date,Gledanost do danas
DocType: Request for Quotation Supplier,No Quote,Nijedan citat
DocType: Support Search Source,Post Title Key,Ključ postaje naslova
DocType: Issue,Issue Split From,Izdanje Split From
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Job Card,Za Job Card
DocType: Warranty Claim,Raised By,Povišena Do
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Prescriptions,propisi
DocType: Payment Gateway Account,Payment Account,Račun za plaćanje
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Please specify Company to proceed,Navedite Tvrtka postupiti
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Accounts Receivable,Neto promjena u potraživanja
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Compensatory Off,kompenzacijski Off
DocType: Job Applicant,Accepted,Prihvaćeno
DocType: POS Closing Voucher,Sales Invoices Summary,Sažetak prodajnih računa
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Party Name,Za ime partije
DocType: Grant Application,Organization,Organizacija
DocType: BOM Update Tool,BOM Update Tool,Alat za ažuriranje BOM-a
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Party,Grupirajte po stranci
DocType: SG Creation Tool Course,Student Group Name,Naziv grupe studenata
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Show exploded view,Prikaži eksplodirao pogled
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Creating Fees,Stvaranje naknada
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.,Molimo provjerite da li stvarno želite izbrisati sve transakcije za ovu tvrtku. Vaši matični podaci će ostati kao što je to. Ova radnja se ne može poništiti.
apps/erpnext/erpnext/templates/pages/product_search.html,Search Results,Rezultati pretraživanja
DocType: Homepage Section,Number of Columns,Broj stupaca
DocType: Room,Room Number,Broj sobe
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Price not found for item {0} in price list {1},Cijena nije pronađena za artikl {0} u cjeniku {1}
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requestor,Podnositelj zahtjeva
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid reference {0} {1},Pogrešna referentni {0} {1}
apps/erpnext/erpnext/config/buying.py,Rules for applying different promotional schemes.,Pravila za primjenu različitih promotivnih shema.
DocType: Shipping Rule,Shipping Rule Label,Dostava Pravilo Label
DocType: Journal Entry Account,Payroll Entry,Ulazak plaće
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,View Fees Records,Prikaz zapisa o naknadama
apps/erpnext/erpnext/public/js/conf.js,User Forum,Forum za korisnike
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Raw Materials cannot be blank.,Sirovine ne može biti prazno.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0} (Payment Table): Amount must be negative,Redak # {0} (Tablica plaćanja): iznos mora biti negativan
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,"Could not update stock, invoice contains drop shipping item.","Ne može se ažurirati zaliha, fakture sadrži drop shipping stavke."
DocType: Contract,Fulfilment Status,Status ispunjenja
DocType: Lab Test Sample,Lab Test Sample,Uzorak laboratorija
DocType: Item Variant Settings,Allow Rename Attribute Value,Dopusti Preimenuj Vrijednost atributa
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Quick Journal Entry,Brzo Temeljnica
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Amount,Budući iznos plaćanja
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,You can not change rate if BOM mentioned agianst any item,Ne možete promijeniti cijenu ako je sastavnica spomenuta u bilo kojem proizvodu
DocType: Restaurant,Invoice Series Prefix,Prefiks serije fakture
DocType: Employee,Previous Work Experience,Radnog iskustva
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Number / Name,Ažuriranje broja i naziva računa
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign Salary Structure,Dodijeli Strukturu plaće
DocType: Support Settings,Response Key List,Popis ključeva za odgovor
DocType: Job Card,For Quantity,Za Količina
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Planned Qty for Item {0} at row {1},Unesite Planirano Qty za točku {0} na redu {1}
DocType: Support Search Source,API,API
DocType: Support Search Source,Result Preview Field,Polje pregleda rezultata
apps/erpnext/erpnext/templates/generators/item/item_configure.js,{0} items found.,{0} pronađenih predmeta.
DocType: Item Price,Packing Unit,Jedinica za pakiranje
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} nije podnesen
DocType: Subscription,Trialling,trialling
DocType: Sales Invoice Item,Deferred Revenue,Odgođeni prihod
DocType: Bank Account,GL Account,GL račun
DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Račun novca upotrebljavat će se za izradu fakture prodaje
DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Podkategorija izuzeća
DocType: Member,Membership Expiry Date,Datum isteka članstva
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,{0} must be negative in return document,{0} mora biti negativan u povratnom dokumentu
DocType: Employee Tax Exemption Proof Submission,Submission Date,Datum podnošenja
,Minutes to First Response for Issues,Minuta do prvog odgovora na pitanja
DocType: Purchase Invoice,Terms and Conditions1,Odredbe i Conditions1
apps/erpnext/erpnext/public/js/setup_wizard.js,The name of the institute for which you are setting up this system.,Ime instituta za koju postavljate ovaj sustav.
DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Knjiženje zamrznuta do tog datuma, nitko ne može učiniti / mijenjati ulazak, osim uloge naveden u nastavku."
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js,Latest price updated in all BOMs,Zadnja cijena ažurirana u svim BOM-ovima
DocType: Project User,Project Status,Status projekta
DocType: UOM,Check this to disallow fractions. (for Nos),Provjerite to da ne dopušta frakcija. (Za br)
DocType: Student Admission Program,Naming Series (for Student Applicant),Imenovanje serije (za studentske zahtjeva)
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Faktor konverzije UOM ({0} -&gt; {1}) nije pronađen za stavku: {2}
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py,Bonus Payment Date cannot be a past date,Datum plaćanja bonusa ne može biti posljednji datum
DocType: Travel Request,Copy of Invitation/Announcement,Kopija pozivnice / obavijesti
DocType: Practitioner Service Unit Schedule,Practitioner Service Unit Schedule,Raspored
DocType: Sales Invoice,Transporter Name,Transporter Ime
DocType: Authorization Rule,Authorized Value,Ovlaštena vrijednost
DocType: BOM,Show Operations,Pokaži operacije
,Minutes to First Response for Opportunity,Zapisnik na prvi odgovor za priliku
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Absent,Ukupno Odsutni
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item or Warehouse for row {0} does not match Material Request,Proizvod ili skladište za redak {0} ne odgovara Zahtjevu za materijalom
apps/erpnext/erpnext/hr/report/loan_repayment/loan_repayment.py,Payable Amount,Iznos koji se plaća
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Unit of Measure,Jedinica mjere
DocType: Fiscal Year,Year End Date,Završni datum godine
DocType: Task Depends On,Task Depends On,Zadatak ovisi o
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Opportunity,Prilika
DocType: Options,Option,Opcija
apps/erpnext/erpnext/accounts/general_ledger.py,You can't create accounting entries in the closed accounting period {0},Ne možete stvoriti knjigovodstvene unose u zatvorenom obračunskom razdoblju {0}
DocType: Operation,Default Workstation,Zadana Workstation
DocType: Payment Entry,Deductions or Loss,Odbitaka ili gubitak
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is closed,{0} {1} je zatvorena
DocType: Email Digest,How frequently?,Kako često?
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Collected: {0},Ukupno prikupljeno: {0}
DocType: Purchase Receipt,Get Current Stock,Kreiraj trenutne zalihe
DocType: Purchase Invoice,ineligible,bezvrijedan
apps/erpnext/erpnext/config/manufacturing.py,Tree of Bill of Materials,Drvo Bill materijala
DocType: BOM,Exploded Items,Eksplodirani predmeti
DocType: Student,Joining Date,Ulazak Datum
,Employees working on a holiday,Radnici koji rade na odmor
,TDS Computation Summary,TDS Computation Summary
DocType: Share Balance,Current State,Trenutna država
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Present,Mark Sadašnje
DocType: Share Transfer,From Shareholder,Od dioničara
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Greater Than Amount,Veća od iznosa
DocType: Project,% Complete Method,% Kompletan postupak
apps/erpnext/erpnext/healthcare/setup.py,Drug,Droga
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance start date can not be before delivery date for Serial No {0},Početni datum održavanja ne može biti stariji od datuma isporuke s rednim brojem {0}
DocType: Work Order,Actual End Date,Stvarni datum završetka
DocType: Cash Flow Mapping,Is Finance Cost Adjustment,Je li prilagodba troškova financija
DocType: BOM,Operating Cost (Company Currency),Operativni trošak (Društvo valuta)
DocType: Authorization Rule,Applicable To (Role),Odnosi se na (uloga)
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Pending Leaves,Na čekanju ostavlja
DocType: BOM Update Tool,Replace BOM,Zamijenite BOM
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Code {0} already exist,Kod {0} već postoji
DocType: Patient Encounter,Procedures,Postupci
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Sales orders are not available for production,Narudžbe za prodaju nisu dostupne za proizvodnju
DocType: Asset Movement,Purpose,Svrha
DocType: Company,Fixed Asset Depreciation Settings,Postavke Amortizacija osnovnog sredstva
DocType: Item,Will also apply for variants unless overrridden,Također će zatražiti varijante osim overrridden
DocType: Purchase Invoice,Advances,Predujmovi
DocType: HR Settings,Hiring Settings,Postavke zapošljavanja
DocType: Work Order,Manufacture against Material Request,Proizvodnja od materijala dogovoru
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Group: ,Grupa za procjenu:
DocType: Item Reorder,Request for,Zahtjev za
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Approving User cannot be same as user the rule is Applicable To,Odobravanje korisnik ne može biti isto kao korisnikapravilo odnosi se na
DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Osnovna stopa (po burzi UOM)
DocType: SMS Log,No of Requested SMS,Nema traženih SMS-a
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Leave Without Pay does not match with approved Leave Application records,Ostavite bez plaće ne odgovara odobrenog odsustva primjene zapisa
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Next Steps,Sljedeći koraci
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Saved Items,Spremljene stavke
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,Molimo dostaviti navedene stavke po najboljim mogućim cijenama
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Employee Transfer cannot be submitted before Transfer Date ,Prijenos zaposlenika ne može se poslati prije datuma prijenosa
DocType: Certification Application,USD,USD
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Remaining Balance,Preostali saldo
DocType: Selling Settings,Auto close Opportunity after 15 days,Automatski zatvori Priliku nakon 15 dana
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Narudžbenice za zabavu nisu dozvoljene za {0} zbog položaja ocjene bodova {1}.
apps/erpnext/erpnext/stock/doctype/item/item.py,Barcode {0} is not a valid {1} code,Barcode {0} nije važeći kôd {1}
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,End Year,Godina završetka
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot/Lead %,Kvota / olovo%
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Contract End Date must be greater than Date of Joining,Ugovor Datum završetka mora biti veći od dana ulaska u
DocType: Sales Invoice,Driver,Vozač
DocType: Vital Signs,Nutrition Values,Nutricionističke vrijednosti
DocType: Lab Test Template,Is billable,Je naplativo
DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Vanjski distributer / trgovac / trgovački zastupnik / suradnik / prodavač koji prodaje proizvode tvrtke za proviziju.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Purchase Order {1},{0} u odnosu na narudžbu {1}
DocType: Patient,Patient Demographics,Demografska pacijentica
DocType: Task,Actual Start Date (via Time Sheet),Stvarni datum početka (putem vremenska tablica)
apps/erpnext/erpnext/portal/doctype/homepage/homepage.py,This is an example website auto-generated from ERPNext,Ovo je primjer web stranica automatski generira iz ERPNext
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 1,Starenje Raspon 1
DocType: Shopify Settings,Enable Shopify,Omogući Shopify
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total claimed amount,Ukupni iznos predujma ne može biti veći od ukupnog iznosa potraživanja
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.","Standardni porez predložak koji se može primijeniti na sve kupovnih transakcija. Ovaj predložak može sadržavati popis poreznih glava, a također ostalih rashoda glave poput ""brodova"", ""osiguranje"", ""Rukovanje"" itd 

 #### Napomena 

 porezna stopa ste odredili ovdje će biti standardna stopa poreza za sve ** Opcije **. Ako postoje ** Predmeti ** koji imaju različite cijene, one moraju biti dodan u ** točke poreza ** stol u ** točke ** majstora.

 #### Opis Kolumne 

 1. Vrsta Proračun: 
 - To može biti na ** Neto Ukupno ** (to je zbroj osnovnog iznosa).
 - ** U odnosu na prethodnu Row ukupno / Iznos ** (za kumulativne poreza ili troškova). Ako odaberete ovu opciju, porez će se primjenjivati postotak prethodnog reda (u poreznom sustavu) iznos ili ukupno.
 - ** Stvarni ** (kao što je navedeno).
 2. Voditelj račun: knjiga računa pod kojima se ovaj porez će biti rezervirano 
 3. Trošak Centar: Ako porezni / naboj je prihod (kao što su utovar) i rashoda treba biti rezervirano protiv troška.
 4. Opis: Opis poreza (koji će se tiskati u račune / citati).
 5. Rate: Porezna stopa.
 6. Iznos: Iznos poreza.
 7. Ukupno: Kumulativna ukupno do ove točke.
 8. Unesite Row: Ako na temelju ""prethodnog retka Ukupno"" možete odabrati broj retka koji će se uzeti kao osnova za ovaj izračun (zadana je prethodni redak).
 9. Razmislite poreza ili naplatiti za: U ovom dijelu možete odrediti ako porezni / zadužen samo za vrednovanje (nije dio ukupno), ili samo za ukupno (ne dodaju vrijednost predmeta), ili za oboje.
 10. Dodavanje ili oduzimamo: Bilo da želite dodati ili oduzeti porez."
DocType: Homepage,Homepage,Početna
DocType: Grant Application,Grant Application Details ,Pojedinosti o podnošenju zahtjeva
DocType: Employee Separation,Employee Separation,Razdvajanje zaposlenika
DocType: BOM Item,Original Item,Izvorna stavka
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Date,Datum dokumenta
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py,Fee Records Created - {0},Naknada zapisa nastalih - {0}
DocType: Asset Category Account,Asset Category Account,Imovina Kategorija račun
apps/erpnext/erpnext/controllers/item_variant.py,The value {0} is already assigned to an exisiting Item {2}.,Vrijednost {0} je već dodijeljena postojećoj stavci {2}.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0} (Payment Table): Amount must be positive,Red # {0} (Tablica plaćanja): iznos mora biti pozitivan
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Cannot produce more Item {0} than Sales Order quantity {1},Ne može proizvesti više predmeta {0} od prodajnog naloga količina {1}
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Nothing is included in gross,Ništa nije uključeno u bruto
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill already exists for this document,Za ovaj dokument već postoji e-Way Bill
apps/erpnext/erpnext/stock/doctype/item/item.js,Select Attribute Values,Odaberite Vrijednosti atributa
DocType: Purchase Invoice,Reason For Issuing document,Razlog za izdavanje dokumenta
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Stock Entry {0} is not submitted,Međuskladišnica {0} nije potvrđena
DocType: Payment Reconciliation,Bank / Cash Account,Banka / Cash 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,Sljedeća Kontakt Po ne može biti ista kao što je vodeći e-mail adresa
DocType: Tax Rule,Billing City,Naplata Grad
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is an Individual or a Proprietorship,Primjenjivo ako je tvrtka fizička osoba ili vlasništvo
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,Log Type is required for check-ins falling in the shift: {0}.,Zapisnik je potreban za prijave u padu: {0}.
DocType: Asset,Manual,Priručnik
DocType: Tally Migration,Is Master Data Processed,Obrađuju li se glavni podaci
DocType: Salary Component Account,Salary Component Account,Račun plaća Komponenta
DocType: Global Defaults,Hide Currency Symbol,Sakrij simbol valute
apps/erpnext/erpnext/config/non_profit.py,Donor information.,Informacije o donatorima.
apps/erpnext/erpnext/config/accounting.py,"e.g. Bank, Cash, Credit Card","npr. banka, gotovina, kreditne kartice"
DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Uobičajeni krvni tlak odrasle osobe u odrasloj dobi iznosi približno 120 mmHg sistolički i dijastolički od 80 mmHg, skraćeno &quot;120/80 mmHg&quot;"
DocType: Journal Entry,Credit Note,Odobrenje kupcu
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Finished Good Item Code,Gotov kod dobra stavka
apps/erpnext/erpnext/config/desktop.py,Quality,Kvaliteta
DocType: Projects Settings,Ignore Employee Time Overlap,Zanemari vrijeme preklapanja zaposlenika
DocType: Warranty Claim,Service Address,Usluga Adresa
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Master Data,Uvoz glavnih podataka
DocType: Asset Maintenance Task,Calibration,Kalibriranje
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} is a company holiday,{0} je praznik tvrtke
apps/erpnext/erpnext/projects/report/billing_summary.py,Billable Hours,Sati naplate
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Status Notification,Pusti status obavijesti
DocType: Patient Appointment,Procedure Prescription,Postupak na recept
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Furnitures and Fixtures,Namještaja i rasvjete
DocType: Travel Request,Travel Type,Vrsta putovanja
DocType: Purchase Invoice Item,Manufacture,Proizvodnja
DocType: Blanket Order,MFG-BLR-.YYYY.-,MFG-BLR-.YYYY.-
apps/erpnext/erpnext/utilities/user_progress.py,Setup Company,Tvrtka za postavljanje
,Lab Test Report,Izvješće testiranja laboratorija
DocType: Employee Benefit Application,Employee Benefit Application,Primjena zaposlenika
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Additional Salary Component Exists.,Postoje dodatne komponente plaće.
DocType: Purchase Invoice,Unregistered,neregistrovan
DocType: Student Applicant,Application Date,Datum Primjena
DocType: Salary Component,Amount based on formula,Iznos se temelji na formuli
DocType: Purchase Invoice,Currency and Price List,Valuta i cjenik
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Create Maintenance Visit,Stvorite posjetu održavanju
DocType: Opportunity,Customer / Lead Name,Kupac / Potencijalni kupac
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date not mentioned,Razmak Datum nije spomenuo
DocType: Payroll Period,Taxable Salary Slabs,Oporezive plaće
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.,Nevažeći GSTIN! Uneseni unos ne odgovara formatu GSTIN-a.
DocType: Guardian,Occupation,Okupacija
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Quantity must be less than quantity {0},Količina mora biti manja od količine {0}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Row {0}:Start Date must be before End Date,Red {0} : Datum početka mora biti prije datuma završetka
DocType: Salary Component,Max Benefit Amount (Yearly),Iznos maksimalne isplate (godišnje)
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,TDS Rate %,TDS stopa%
DocType: Crop,Planting Area,Područje sadnje
apps/erpnext/erpnext/controllers/trends.py,Total(Qty),Ukupno (Kol)
DocType: Installation Note Item,Installed Qty,Instalirana kol
apps/erpnext/erpnext/utilities/user_progress.py,You added ,Dodali ste
,Product Bundle Balance,Bilanca paketa proizvoda
DocType: Purchase Taxes and Charges,Parenttype,Nadređeni tip
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Central Tax,Središnji porez
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Result,Rezultat trening
DocType: Purchase Invoice,Is Paid,je plaćen
DocType: Salary Structure,Total Earning,Ukupna zarada
DocType: Purchase Receipt,Time at which materials were received,Vrijeme u kojem su materijali primili
DocType: Products Settings,Products per Page,Proizvodi po stranici
DocType: Stock Ledger Entry,Outgoing Rate,Odlazni Ocijenite
apps/erpnext/erpnext/controllers/accounts_controller.py, or ,ili
apps/erpnext/erpnext/public/js/purchase_trends_filters.js,Billing Date,Datum naplate
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be negative,Dodijeljeni iznos ne može biti negativan
DocType: Sales Order,Billing Status,Status naplate
apps/erpnext/erpnext/public/js/conf.js,Report an Issue,Prijavi problem
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.","Ako {0} {1} količine predmeta <b>{2}</b> , na predmet će se primijeniti shema <b>{3}</b> ."
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Utility Expenses,komunalna Troškovi
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,90-Above,Iznad 90
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,Red # {0}: časopis za ulazak {1} nema računa {2} ili već usklađeni protiv drugog bona
DocType: Supplier Scorecard Criteria,Criteria Weight,Težina kriterija
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Account: {0} is not permitted under Payment Entry,Račun: {0} nije dopušten unosom plaćanja
DocType: Production Plan,Ignore Existing Projected Quantity,Zanemarite postojeću projiciranu količinu
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Approval Notification,Odustani od obavijesti o odobrenju
DocType: Buying Settings,Default Buying Price List,Zadani kupovni cjenik
DocType: Payroll Entry,Salary Slip Based on Timesheet,Plaća proklizavanja temelju timesheet
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Rate,Stopa kupnje
apps/erpnext/erpnext/controllers/buying_controller.py,Row {0}: Enter location for the asset item {1},Redak {0}: unesite mjesto stavke stavke {1}
DocType: Employee Checkin,Attendance Marked,Sudjelovanje je označeno
DocType: Request for Quotation,PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-
apps/erpnext/erpnext/public/js/hub/pages/Seller.vue,About the Company,O tvrtki
apps/erpnext/erpnext/config/settings.py,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Postavi zadane vrijednosti kao što su tvrtka, valuta, tekuća fiskalna godina, itd."
DocType: Payment Entry,Payment Type,Vrsta plaćanja
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,Odaberite Batch for Item {0}. Nije moguće pronaći jednu seriju koja ispunjava taj uvjet
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,Nema dobitka ili gubitka tečaja
DocType: Leave Control Panel,Select Employees,Odaberite Zaposlenici
DocType: Shopify Settings,Sales Invoice Series,Serija prodajnih faktura
DocType: Bank Reconciliation,To Date,Za datum
DocType: Opportunity,Potential Sales Deal,Potencijalni Prodaja Deal
DocType: Complaint,Complaints,pritužbe
DocType: Employee Tax Exemption Declaration,Employee Tax Exemption Declaration,Deklaracija o izuzeću od plaćanja radnika
DocType: Payment Entry,Cheque/Reference Date,Ček / Referentni datum
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials.,Nema predmeta s računom materijala.
apps/erpnext/erpnext/portal/doctype/homepage/homepage.js,Customize Homepage Sections,Prilagodite odjeljke početne stranice
DocType: Purchase Invoice,Total Taxes and Charges,Ukupno Porezi i naknade
DocType: Payment Entry,Company Bank Account,Bankovni račun tvrtke
DocType: Employee,Emergency Contact,Kontakt hitne službe
DocType: Bank Reconciliation Detail,Payment Entry,Ulaz za plaćanje
,sales-browser,prodaja-preglednik
apps/erpnext/erpnext/accounts/doctype/account/account.js,Ledger,Glavna knjiga
DocType: Drug Prescription,Drug Code,Kodeks droga
DocType: Target Detail,Target  Amount,Ciljani iznos
apps/erpnext/erpnext/education/utils.py,Quiz {0} does not exist,Kviz {0} ne postoji
DocType: POS Profile,Print Format for Online,Oblik ispisa za online
DocType: Shopping Cart Settings,Shopping Cart Settings,Košarica Postavke
DocType: Journal Entry,Accounting Entries,Računovodstvenih unosa
DocType: Job Card Time Log,Job Card Time Log,Evidencija vremena radne 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.","Ako je odabrano Pravilo o cijenama za &quot;Razina&quot;, ona će prebrisati Cjenik. Cijena cijene je konačna stopa, tako da nema dodatnog popusta. Dakle, u transakcijama kao što su prodajni nalog, narudžbena narudžba i sl., To će biti dohvaćeno u polju &quot;Cijena&quot;, a ne polje &quot;Cjenovna lista&quot;."
apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Postavite sustav imenovanja instruktora u Obrazovanje&gt; Postavke obrazovanja
DocType: Journal Entry,Paid Loan,Plaćeni zajam
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Duplicate Entry. Please check Authorization Rule {0},Dupli unos. Provjerite pravila za autorizaciju {0}
DocType: Journal Entry Account,Reference Due Date,Referentni datum dospijeća
DocType: Purchase Order,Ref SQ,Ref. SQ
DocType: Issue,Resolution By,Rezolucija po
DocType: Leave Type,Applicable After (Working Days),Primjenjivi nakon (radni dani)
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Receipt document must be submitted,Prijem dokumenata moraju biti dostavljeni
DocType: Purchase Invoice Item,Received Qty,Pozicija Kol
DocType: Stock Entry Detail,Serial No / Batch,Serijski Ne / Batch
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Not Paid and Not Delivered,Ne plaća i ne Isporučeno
DocType: Product Bundle,Parent Item,Nadređeni proizvod
DocType: Account,Account Type,Vrsta računa
DocType: Shopify Settings,Webhooks Details,Webhooks Detalji
apps/erpnext/erpnext/templates/pages/projects.html,No time sheets,Nema vremenske tablice
DocType: GoCardless Mandate,GoCardless Customer,GoCardless Customer
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leave Type {0} cannot be carry-forwarded,Ostavite Tip {0} ne može nositi-proslijeđen
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kod artikla&gt; Grupa artikala&gt; Marka
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Raspored održavanja nije generiran za sve proizvode. Molimo kliknite na 'Generiraj raspored'
,To Produce,proizvoditi
DocType: Leave Encashment,Payroll,Platni spisak
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 red {0} {1}. Da su {2} u stopu točke, redovi {3} također moraju biti uključeni"
DocType: Healthcare Service Unit,Parent Service Unit,Roditeljska jedinica
DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikacija paketa za dostavu (za tisak)
apps/erpnext/erpnext/support/doctype/issue/issue.js,Service Level Agreement was reset.,Ugovor o razini usluge vraćen je na zadano.
DocType: Bin,Reserved Quantity,Rezervirano Količina
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Please enter valid email address,Unesite valjanu e-adresu
DocType: Volunteer Skill,Volunteer Skill,Volonterska vještina
DocType: Bank Reconciliation,Include POS Transactions,Uključi POS transakcije
DocType: Quality Action,Corrective/Preventive,Korektivna / Preventivna
DocType: Purchase Invoice,Inter Company Invoice Reference,Referentna faktura tvrtke Inter Company
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select an item in the cart,Odaberite stavku u košarici
DocType: Landed Cost Voucher,Purchase Receipt Items,Primka proizvoda
apps/erpnext/erpnext/regional/italy/utils.py,Please set Tax ID for the customer '%s',Molim da postavite porezni broj za kupca &#39;% s&#39;
apps/erpnext/erpnext/config/help.py,Customizing Forms,Prilagodba Obrasci
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Arrear,zaostatak
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Amount during the period,Amortizacija Iznos u razdoblju
DocType: Sales Invoice,Is Return (Credit Note),Je li povrat (kreditna bilješka)
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Start Job,Započni posao
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Serial no is required for the asset {0},Serijski broj nije potreban za imovinu {0}
DocType: Leave Control Panel,Allocate Leaves,Rasporedite lišće
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py,Disabled template must not be default template,Onemogućeno predložak ne smije biti zadani predložak
DocType: Pricing Rule,Price or Product Discount,Popust na cijenu ili proizvod
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,For row {0}: Enter planned qty,Za redak {0}: unesite planirani iznos
DocType: Account,Income Account,Račun prihoda
DocType: Payment Request,Amount in customer's currency,Iznos u valuti kupca
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Delivery,Isporuka
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Assigning Structures...,Dodjeljivanje struktura ...
DocType: Stock Reconciliation Item,Current Qty,Trenutno Kom
DocType: Restaurant Menu,Restaurant Menu,Izbornik restorana
apps/erpnext/erpnext/public/js/event.js,Add Suppliers,Dodajte dobavljače
DocType: Sales Invoice,ACC-SINV-.YYYY.-,ACC-SINV-.YYYY.-
DocType: Loyalty Program,Help Section,Odjeljak za pomoć
apps/erpnext/erpnext/www/all-products/index.html,Prev,Prethodna
DocType: Appraisal Goal,Key Responsibility Area,Zona ključnih odgovornosti
DocType: Delivery Trip,Distance UOM,Udaljenost UOM
apps/erpnext/erpnext/utilities/activation.py,"Student Batches help you track attendance, assessments and fees for students","Studentski Serije vam pomoći pratiti posjećenost, procjene i naknade za učenike"
DocType: Payment Entry,Total Allocated Amount,Ukupni raspoređeni iznos
apps/erpnext/erpnext/setup/doctype/company/company.py,Set default inventory account for perpetual inventory,Postavite zadani oglasni prostor za trajni oglasni prostor
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}",Nije moguće prikazati serijski broj {0} stavke {1} jer je rezervirano za \ fullfill prodajni nalog {2}
DocType: Material Request Plan Item,Material Request Type,Tip zahtjeva za robom
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js,Send Grant Review Email,Slanje e-pošte za evaluaciju potpore
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full, did not save","LocalStorage puna, nije štedjelo"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}: UOM Conversion Factor is mandatory,Red {0}: UOM pretvorbe faktor je obavezno
DocType: Employee Benefit Claim,Claim Date,Datum zahtjeva
apps/erpnext/erpnext/utilities/user_progress.py,Room Capacity,Kapacitet sobe
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field Asset Account cannot be blank,Polje Račun imovine ne može biti prazno
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Already record exists for the item {0},Već postoji zapis za stavku {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?,Izgubit ćete evidenciju prethodno generiranih faktura. Jeste li sigurni da želite ponovno pokrenuti ovu pretplatu?
DocType: Lab Test,LP-,LP-
DocType: Healthcare Settings,Registration Fee,Naknada za registraciju
DocType: Loyalty Program Collection,Loyalty Program Collection,Zbirka programa lojalnosti
DocType: Stock Entry Detail,Subcontracted Item,Podugovarana stavka
apps/erpnext/erpnext/education/__init__.py,Student {0} does not belong to group {1},Student {0} ne pripada skupini {1}
DocType: Budget,Cost Center,Troška
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Voucher #,bon #
DocType: Tax Rule,Shipping Country,Dostava Država
DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Sakrij Porezni Kupca od prodajnih transakcija
DocType: Upload Attendance,Upload HTML,Prenesi HTML
DocType: Employee,Relieving Date,Rasterećenje Datum
DocType: Purchase Invoice,Total Quantity,Ukupna 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.","Cijene Pravilo je napravljen prebrisati Cjenik / definirati postotak popusta, na temelju nekih kriterija."
apps/erpnext/erpnext/support/doctype/issue/issue.py,Service Level Agreement has been changed to {0}.,Ugovor o razini usluge promijenjen je u {0}.
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Skladište se može mijenjati samo preko Međuskladišnica / Otpremnica / Primka
DocType: Employee Education,Class / Percentage,Klasa / Postotak
DocType: Shopify Settings,Shopify Settings,Postavke trgovine
DocType: Amazon MWS Settings,Market Place ID,ID mjesta tržišta
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Head of Marketing and Sales,Voditelj marketinga i prodaje
DocType: Video,Vimeo,Vimeo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Income Tax,Porez na dohodak
DocType: HR Settings,Check Vacancies On Job Offer Creation,Provjerite slobodna radna mjesta na izradi ponude posla
apps/erpnext/erpnext/utilities/user_progress.py,Go to Letterheads,Idi na zaglavlje
DocType: Subscription,Cancel At End Of Period,Odustani na kraju razdoblja
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Property already added,Već je dodano svojstvo
DocType: Item Supplier,Item Supplier,Dobavljač proizvoda
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please enter Item Code to get batch no,Unesite kod Predmeta da se hrpa nema
apps/erpnext/erpnext/public/js/utils.js,Loyalty Points: {0},Bodovi vjernosti: {0}
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js,Please select a value for {0} quotation_to {1},Molimo odabir vrijednosti za {0} quotation_to {1}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,No Items selected for transfer,Nema odabranih stavki za prijenos
apps/erpnext/erpnext/config/buying.py,All Addresses.,Sve adrese.
DocType: Company,Stock Settings,Postavke skladišta
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 moguće samo ako sljedeća svojstva su isti u obje evidencije. Je Grupa, korijen Vrsta, Društvo"
DocType: Vehicle,Electric,električni
DocType: Task,% Progress,% Napredak
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Gain/Loss on Asset Disposal,Dobit / gubitak od imovine Odlaganje
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.",U sljedećoj tablici odabrat će se samo kandidatkinja za studente s statusom &quot;Odobreno&quot;.
DocType: Tax Withholding Category,Rates,Cijene
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.,Broj računa za račun {0} nije dostupan. <br> Pravilno postavite svoj računni prikaz.
DocType: Task,Depends on Tasks,Ovisi o poslovima
apps/erpnext/erpnext/config/crm.py,Manage Customer Group Tree.,Uredi hijerarhiju grupe kupaca.
DocType: Normal Test Items,Result Value,Vrijednost rezultata
DocType: Hotel Room,Hotels,Hoteli
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,New Cost Center Name,Novi naziv troškovnog centra
DocType: Leave Control Panel,Leave Control Panel,Upravljačka ploča odsustava
DocType: Project,Task Completion,Zadatak Završetak
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,Not in Stock,Ne u skladištu
DocType: Volunteer,Volunteer Skills,Volonterske vještine
DocType: Additional Salary,HR User,HR Korisnik
DocType: Bank Guarantee,Reference Document Name,Referentni naziv dokumenta
DocType: Purchase Invoice,Taxes and Charges Deducted,Porezi i naknade oduzeti
DocType: Support Settings,Issues,Pitanja
DocType: Loyalty Program,Loyalty Program Name,Ime programa za lojalnost
apps/erpnext/erpnext/controllers/status_updater.py,Status must be one of {0},Status mora biti jedan od {0}
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Reminder to update GSTIN Sent,Podsjetnik za ažuriranje GSTIN posla
DocType: Discounted Invoice,Debit To,Rashodi za
DocType: Restaurant Menu Item,Restaurant Menu Item,Stavka izbornika restorana
DocType: Delivery Note,Required only for sample item.,Potrebna je samo za primjer stavke.
DocType: Stock Ledger Entry,Actual Qty After Transaction,Stvarna količina nakon transakcije
,Pending SO Items For Purchase Request,Otvorene stavke narudžbe za zahtjev za kupnju
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Student Admissions,Studentski Upisi
apps/erpnext/erpnext/accounts/party.py,{0} {1} is disabled,{0} {1} je onemogućen
DocType: Supplier,Billing Currency,Naplata valuta
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Extra Large,Extra large
DocType: Loan,Loan Application,Primjena zajma
DocType: Crop,Scientific Name,Znanstveno ime
DocType: Healthcare Service Unit,Service Unit Type,Vrsta servisne jedinice
DocType: Bank Account,Branch Code,Kod podružnice
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Leaves,Ukupno Lišće
DocType: Customer,"Reselect, if the chosen contact is edited after save","Ponovno odaberite, ako je odabrani kontakt uređen nakon spremanja"
DocType: Quality Procedure,Parent Procedure,Postupak roditelja
DocType: Patient Encounter,In print,U tisku
DocType: Accounting Dimension,Accounting Dimension,Računovodstvena dimenzija
,Profit and Loss Statement,Račun dobiti i gubitka
DocType: Bank Reconciliation Detail,Cheque Number,Ček Broj
apps/erpnext/erpnext/healthcare/utils.py,The item referenced by {0} - {1} is already invoiced,Stavka upućena {0} - {1} već je fakturirana
,Sales Browser,prodaja preglednik
DocType: Journal Entry,Total Credit,Ukupna kreditna
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Warning: Another {0} # {1} exists against stock entry {2},Upozorenje: Još {0} # {1} postoji protiv ulaska dionicama {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),Zajmovi i predujmovi (aktiva)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Debtors,Dužnici
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Large,Veliki
DocType: Bank Statement Settings,Bank Statement Settings,Postavke bankovnog izvoda
DocType: Shopify Settings,Customer Settings,Postavke korisnika
DocType: Homepage Featured Product,Homepage Featured Product,Početna Istaknuti Proizvodi
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,View Orders,Prikaz narudžbi
DocType: Marketplace Settings,Marketplace URL (to hide and update label),URL tržišta (za sakrivanje i ažuriranje oznake)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Assessment Groups,Sve grupe za procjenu
apps/erpnext/erpnext/regional/india/utils.py,{} is required to generate e-Way Bill JSON,{} je potreban za generiranje e-Way Bill JSON
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,New Warehouse Name,Novo ime skladišta
DocType: Shopify Settings,App Type,Vrsta aplikacije
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py,Total {0} ({1}),Ukupno {0} ({1})
DocType: C-Form Invoice Detail,Territory,Teritorij
DocType: Pricing Rule,Apply Rule On Item Code,Primijenite pravilo na kod predmeta
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Molimo spomenuti nema posjeta potrebnih
DocType: Stock Settings,Default Valuation Method,Zadana metoda vrednovanja
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Pristojba
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Prikaži kumulativni iznos
apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Ažuriranje je u tijeku. Može potrajati neko vrijeme.
DocType: Production Plan Item,Produced Qty,Proizvedena količina
DocType: Vehicle Log,Fuel Qty,Gorivo Kol
DocType: Stock Entry,Target Warehouse Name,Naziv ciljnog skladišta
DocType: Work Order Operation,Planned Start Time,Planirani početak vremena
DocType: Course,Assessment,procjena
DocType: Payment Entry Reference,Allocated,Dodijeljeni
apps/erpnext/erpnext/config/accounting.py,Close Balance Sheet and book Profit or Loss.,Zatvori bilanca i knjiga dobit ili gubitak .
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,ERPNext could not find any matching payment entry,ERPNext nije mogao pronaći nijedan odgovarajući unos za plaćanje
DocType: Student Applicant,Application Status,Status aplikacije
DocType: Additional Salary,Salary Component Type,Vrsta komponente plaće
DocType: Sensitivity Test Items,Sensitivity Test Items,Ispitne stavke osjetljivosti
DocType: Website Attribute,Website Attribute,Atributi web mjesta
DocType: Project Update,Project Update,Ažuriranje projekta
DocType: Fees,Fees,naknade
DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Navedite Tečaj pretvoriti jedne valute u drugu
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Quotation {0} is cancelled,Ponuda {0} je otkazana
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Total Outstanding Amount,Ukupni iznos
DocType: Sales Partner,Targets,Ciljevi
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,Molimo registrirajte SIREN broj u informativnu datoteku tvrtke
DocType: Quality Action Table,Responsible,Odgovoran
DocType: Email Digest,Sales Orders to Bill,Narudžbe za prodaju Bill
DocType: Price List,Price List Master,Cjenik 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.,"Sve prodajnih transakcija može biti označene protiv više osoba ** prodaje **, tako da možete postaviti i pratiti ciljeve."
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Link to Material Request,Veza na zahtjev materijala
DocType: Quiz,Score out of 100,Rezultat od 100
apps/erpnext/erpnext/templates/pages/help.html,Forum Activity,Aktivnost na forumu
DocType: Quiz,Grading Basis,Osnove ocjenjivanja
apps/erpnext/erpnext/selling/report/pending_so_items_for_purchase_request/pending_so_items_for_purchase_request.py,S.O. No.,N.K.br.
DocType: Bank Statement Transaction Settings Item,Bank Statement Transaction Settings Item,Stavka o postavkama transakcije bankovne izjave
apps/erpnext/erpnext/hr/utils.py,To date can not greater than employee's relieving date,Do danas ne može biti veći od datuma oslobađanja zaposlenika
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Please create Customer from Lead {0},Molimo stvoriti kupac iz Olovo {0}
apps/erpnext/erpnext/healthcare/page/patient_history/patient_history.html,Select Patient,Odaberite Pacijent
DocType: Price List,Applicable for Countries,Primjenjivo za zemlje
DocType: Supplier Scorecard Scoring Variable,Parameter Name,Naziv parametra
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Ostavite samo one prijave sa statusom &quot;Odobreno&quot; i &quot;Odbijeno&quot; može se podnijeti
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py,Creating Dimensions...,Izrada dimenzija ...
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Student Group Name is mandatory in row {0},Student Grupa Ime obvezna je u redu {0}
DocType: Customer Credit Limit,Bypass credit limit_check,Zaobiđite ograničenje kredita
DocType: Homepage,Products to be shown on website homepage,Proizvodi koji će biti prikazan na web stranici početnu stranicu
DocType: HR Settings,Password Policy,Politika lozinke
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js,This is a root customer group and cannot be edited.,Ovo je glavna grupa kupaca i ne može se mijenjati.
DocType: Student,AB-,AB
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Total completed qty must be greater than zero,Ukupan broj ispunjenih količina mora biti veći od nule
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on PO,Ako je akumulirani mjesečni proračun premašen na PO
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Place,Mjesto
DocType: Stock Entry,Stock Entry (Outward GIT),Unos dionica (vanjski GIT)
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation,Revalorizacija tečaja
DocType: POS Profile,Ignore Pricing Rule,Ignorirajte Cijene pravilo
DocType: Employee Education,Graduate,Diplomski
DocType: Leave Block List,Block Days,Dani bloka
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,"Shipping Address does not have country, which is required for this Shipping Rule",Adresa za isporuku nema državu koja je potrebna za ovaj Pravilnik za isporuku
DocType: Journal Entry,Excise Entry,Trošarine Stupanje
DocType: Bank,Bank Transaction Mapping,Kartiranje bankovnih transakcija
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Upozorenje: Prodaja Naručite {0} već postoji protiv Kupca narudžbenice {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 uvjeti koji se mogu dodati prodaje i kupnje.

 Primjeri: 

 1. Valjanost ponude.
 1. Uvjeti plaćanja (unaprijed na kredit, dio unaprijed i sl).
 1. Što je extra (ili plaća Kupac).
 1. Sigurnost / upozorenje korištenja.
 1. Jamstvo ako ih ima.
 1. Vraća politike.
 1. Uvjeti dostave, ako je potrebno.
 1. Načini adresiranja sporova, naknade štete, odgovornosti, itd 
 1. Kontakt Vaše tvrtke."
DocType: Homepage Section,Section Based On,Odjeljak na temelju
DocType: Issue,Issue Type,Vrsta izdanja
DocType: Attendance,Leave Type,Vrsta odsustva
DocType: Purchase Invoice,Supplier Invoice Details,Dobavljač Detalji Račun
DocType: Agriculture Task,Ignore holidays,Zanemari blagdane
apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Rashodi / Razlika računa ({0}) mora biti račun 'dobit ili gubitak'
DocType: Stock Entry Detail,Stock Entry Child,Dijete za ulazak na zalihe
DocType: Project,Copied From,Kopiran iz
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Invoice already created for all billing hours,Račun je već izrađen za sva vremena naplate
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Name error: {0},greška Ime: {0}
DocType: Healthcare Service Unit Type,Item Details,Detalji artikla
DocType: Cash Flow Mapping,Is Finance Cost,Je li trošak financiranja
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance for employee {0} is already marked,Gledatelja za zaposlenika {0} već označen
DocType: Packing Slip,If more than one package of the same type (for print),Ako je više od jedan paket od iste vrste (za tisak)
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please set default customer in Restaurant Settings,Postavite zadani klijent u Postavkama restorana
,Salary Register,Plaća Registracija
DocType: Company,Default warehouse for Sales Return,Zadano skladište za povrat prodaje
DocType: Pick List,Parent Warehouse,Roditelj Skladište
DocType: Subscription,Net Total,Osnovica
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.",Postavite rok trajanja artikala u danima kako biste postavili rok upotrebe na temelju datuma proizvodnje plus rok trajanja.
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Default BOM not found for Item {0} and Project {1},Zadani BOM nije pronađen za stavku {0} i projekt {1}
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the Mode of Payment in Payment Schedule,Redak {0}: Postavite Način plaćanja u Raspored plaćanja
apps/erpnext/erpnext/config/non_profit.py,Define various loan types,Definirati različite vrste kredita
DocType: Bin,FCFS Rate,FCFS Stopa
DocType: Bank Statement Transaction Invoice Item,Outstanding Amount,Izvanredna Iznos
apps/erpnext/erpnext/templates/generators/bom.html,Time(in mins),Vrijeme (u minutama)
DocType: Task,Working,Radni
DocType: Stock Ledger Entry,Stock Queue (FIFO),Kataloški red (FIFO)
DocType: Homepage Section,Section HTML,Odjeljak HTML
apps/erpnext/erpnext/public/js/setup_wizard.js,Financial Year,Financijska godina
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,{0} does not belong to Company {1},{0} ne pripada Društvu {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.,Nije moguće riješiti funkciju bodova kriterija za {0}. Provjerite je li formula valjana.
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost as on,Trošak kao i na
DocType: Healthcare Settings,Out Patient Settings,Izvan pacijentskih postavki
DocType: Account,Round Off,Zaokružiti
DocType: Service Level Priority,Resolution Time,Vrijeme razlučivosti
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,Traženi Kol
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The fields From Shareholder and To Shareholder cannot be blank,Polja Od Dioničara i Dioničara ne mogu biti prazna
DocType: Cashier Closing,Cashier Closing,Zatvaranje blagajnika
DocType: Tax Rule,Use for Shopping Cart,Koristite za Košarica
DocType: Homepage,Homepage Slideshow,Prezentacija početne stranice
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Serial Numbers,Odaberite serijske brojeve
DocType: BOM Item,Scrap %,Otpad%
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","Troškovi će se distribuirati proporcionalno na temelju točke kom ili iznos, kao i po svom izboru"
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Create Supplier Quotation,Izradite ponudu ponude
DocType: Travel Request,Require Full Funding,Potražite punu financijsku potporu
DocType: Maintenance Visit,Purposes,Svrhe
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 jedan predmet treba upisati s negativnim količinama u povratnom dokumentu
DocType: Shift Type,Grace Period Settings For Auto Attendance,Postavke vremenskog perioda za automatsko prisustvo
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} više nego bilo raspoloživih radnih sati u radnom {1}, razbiti rad u više operacija"
DocType: Membership,Membership Status,Status članstva
DocType: Travel Itinerary,Lodging Required,Obavezan smještaj
DocType: Promotional Scheme,Price Discount Slabs,Ploče s popustom na cijene
DocType: Stock Reconciliation Item,Current Serial No,Trenutni serijski br
DocType: Employee,Attendance and Leave Details,Pojedinosti o posjetima i odlasci
,BOM Comparison Tool,Alat za usporedbu BOM-a
,Requested,Tražena
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,No Remarks,Nema primjedbi
DocType: Asset,In Maintenance,U Održavanju
DocType: Amazon MWS Settings,Click this button to pull your Sales Order data from Amazon MWS.,Kliknite ovaj gumb da biste povukli podatke o prodajnom nalogu tvrtke Amazon MWS.
DocType: Vital Signs,Abdomen,Trbuh
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,No outstanding invoices require exchange rate revaluation,Nijedna nepodmirena faktura ne zahtijeva revalorizaciju tečaja
DocType: Purchase Invoice,Overdue,Prezadužen
DocType: Account,Stock Received But Not Billed,Stock primljeni Ali ne Naplaćeno
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root Account must be a group,Korijen računa mora biti grupa
DocType: Drug Prescription,Drug Prescription,Lijek na recept
DocType: Service Level,Support and Resolution,Podrška i rezolucija
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Free item code is not selected,Besplatni kod predmeta nije odabran
DocType: Loan,Repaid/Closed,Otplaćuje / Zatvoreno
DocType: Amazon MWS Settings,CA,CA
DocType: Item,Total Projected Qty,Ukupni predviđeni Kol
DocType: Monthly Distribution,Distribution Name,Naziv distribucije
DocType: Chart of Accounts Importer,Chart Tree,Stablo grafikona
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Include UOM,Uključi UOM
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Material Request No,Zahtjev za robom br.
DocType: Service Level Agreement,Default Service Level Agreement,Zadani ugovor o razini usluge
DocType: SG Creation Tool Course,Course Code,kod predmeta
apps/erpnext/erpnext/hr/utils.py,More than one selection for {0} not allowed,Više od jednog izbora za {0} nije dopušteno
DocType: Pick List,Qty of raw materials will be decided based on the qty of the Finished Goods Item,Količina sirovina odlučivat će se na osnovu količine proizvoda Gotove robe
DocType: Location,Parent Location,Mjesto roditelja
DocType: POS Settings,Use POS in Offline Mode,Koristite POS u izvanmrežnom načinu rada
apps/erpnext/erpnext/support/doctype/issue/issue.py,Priority has been changed to {0}.,Prioritet je promijenjen u {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 obavezan. Možda se za {1} do {2}
DocType: Quotation,Rate at which customer's currency is converted to company's base currency,Stopa po kojoj se valuta klijenta se pretvaraju u tvrtke bazne valute
DocType: Purchase Invoice Item,Net Rate (Company Currency),Neto stopa (Društvo valuta)
DocType: Salary Detail,Condition and Formula Help,Stanje i Formula Pomoć
apps/erpnext/erpnext/config/crm.py,Manage Territory Tree.,Uredi teritorijalnu raspodjelu.
apps/erpnext/erpnext/config/getting_started.py,Import Chart Of Accounts from CSV / Excel files,Uvezi račun s računa iz CSV / Excel datoteka
DocType: Patient Service Unit,Patient Service Unit,Jedinica za pacijente
DocType: Bank Statement Transaction Invoice Item,Sales Invoice,Prodajni račun
DocType: Journal Entry Account,Party Balance,Bilanca stranke
DocType: Cash Flow Mapper,Section Subtotal,Podskupina odjeljka
apps/erpnext/erpnext/accounts/page/pos/pos.js,Please select Apply Discount On,Odaberite Primijeni popusta na
DocType: Stock Settings,Sample Retention Warehouse,Skladište za uzorkovanje uzoraka
DocType: Company,Default Receivable Account,Zadana Potraživanja račun
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Projected Quantity Formula,Projektirana količina količine
DocType: Sales Invoice,Deemed Export,Pretraženo izvoz
DocType: Pick List,Material Transfer for Manufacture,Prijenos materijala za izradu
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.,Postotak popusta se može neovisno primijeniti prema jednom ili za više cjenika.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Accounting Entry for Stock,Knjiženje na skladištu
DocType: Lab Test,LabTest Approver,LabTest odobrenje
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,You have already assessed for the assessment criteria {}.,Već ste ocijenili kriterije procjene {}.
DocType: Vehicle Service,Engine Oil,Motorno ulje
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Orders Created: {0},Kreirani radni nalozi: {0}
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,Please set an email id for the Lead {0},Molimo vas da odredite ID e-pošte za Lead {0}
DocType: Sales Invoice,Sales Team1,Prodaja Team1
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} does not exist,Proizvod {0} ne postoji
DocType: Sales Invoice,Customer Address,Kupac Adresa
DocType: Loan,Loan Details,zajam Detalji
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup post company fixtures,Postavljanje post-tvrtki nije uspjelo
DocType: Company,Default Inventory Account,Zadani račun oglasnog prostora
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The folio numbers are not matching,Folio brojevi se ne podudaraju
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Request for {0},Zahtjev za plaćanje {0}
DocType: Item Barcode,Barcode Type,Vrsta crtičnog koda
DocType: Antibiotic,Antibiotic Name,Ime antibiotika
apps/erpnext/erpnext/config/buying.py,Supplier Group master.,Majstor grupa dobavljača.
DocType: Healthcare Service Unit,Occupancy Status,Status posjeda
DocType: Purchase Invoice,Apply Additional Discount On,Nanesite dodatni popust na
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Type...,Odaberite vrstu ...
apps/erpnext/erpnext/templates/pages/help.html,Your tickets,Vaše ulaznice
DocType: Account,Root Type,korijen Tip
DocType: Item,FIFO,FIFO
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Close the POS,Zatvorite POS
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Cannot return more than {1} for Item {2},Red # {0}: Ne može se vratiti više od {1} za točku {2}
DocType: Item Group,Show this slideshow at the top of the page,Prikaži ovaj slideshow na vrhu stranice
DocType: BOM,Item UOM,Mjerna jedinica proizvoda
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Porezna Iznos Nakon Popust Iznos (Društvo valuta)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Target warehouse is mandatory for row {0},Target skladište je obvezno za redom {0}
apps/erpnext/erpnext/config/retail.py,Retail Operations,Trgovina na malo
DocType: Cheque Print Template,Primary Settings,Primarne postavke
DocType: Attendance Request,Work From Home,Rad od kuće
DocType: Purchase Invoice,Select Supplier Address,Odaberite Dobavljač adresa
apps/erpnext/erpnext/public/js/event.js,Add Employees,Dodavanje zaposlenika
DocType: Purchase Invoice Item,Quality Inspection,Provjera kvalitete
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Extra Small,Dodatni Mali
DocType: Company,Standard Template,standardni predložak
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,Upozorenje : Materijal Tražena količina manja nego minimalna narudžba kol
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Account {0} is frozen,Račun {0} je zamrznut
DocType: Quiz Question,Quiz Question,Pitanje za kviz
DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Pravna cjelina / Podružnica s odvojenim kontnim planom pripada Organizaciji.
DocType: Payment Request,Mute Email,Mute e
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,"Food, Beverage & Tobacco","Hrana , piće i duhan"
DocType: Account,Account Number,Broj računa
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Can only make payment against unbilled {0},Može napraviti samo plaćanje protiv Nenaplaćena {0}
DocType: Call Log,Missed,Propušteni
apps/erpnext/erpnext/controllers/selling_controller.py,Commission rate cannot be greater than 100,Proviziju ne može biti veća od 100
apps/erpnext/erpnext/stock/doctype/item_manufacturer/item_manufacturer.py,Duplicate entry against the item code {0} and manufacturer {1},Duplikat unosa sa šifrom artikla {0} i proizvođačem {1}
DocType: Sales Invoice,Allocate Advances Automatically (FIFO),Automatsko dodjeljivanje prednosti (FIFO)
DocType: Volunteer,Volunteer,dobrovoljac
DocType: Buying Settings,Subcontract,Podugovor
apps/erpnext/erpnext/public/js/utils/party.js,Please enter {0} first,Unesite {0} prvi
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,No replies from,Nema odgovora od
DocType: Work Order Operation,Actual End Time,Stvarni End Time
DocType: Production Plan,Download Materials Required,Preuzmite - Potrebni materijali
DocType: Purchase Invoice Item,Manufacturer Part Number,Proizvođačev broj dijela
DocType: Taxable Salary Slab,Taxable Salary Slab,Oporeziva plaća
DocType: Work Order Operation,Estimated Time and Cost,Procijenjeno vrijeme i trošak
apps/erpnext/erpnext/controllers/stock_controller.py,Quality Inspection: {0} is not submitted for the item: {1} in row {2},Provjera kvalitete: {0} ne podnosi se za stavku: {1} u retku {2}
DocType: Bin,Bin,Kanta
DocType: Bank Transaction,Bank Transaction,Bankovna transakcija
DocType: Crop,Crop Name,Naziv usjeva
apps/erpnext/erpnext/hub_node/api.py,Only users with {0} role can register on Marketplace,Samo korisnici s ulogom {0} mogu se registrirati na Marketplace
DocType: SMS Log,No of Sent SMS,Broj poslanih SMS-a
DocType: Leave Application,HR-LAP-.YYYY.-,HR-LAP-.YYYY.-
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py,Appointments and Encounters,Imenovanja i susreti
DocType: Antibiotic,Healthcare Administrator,Administrator zdravstva
apps/erpnext/erpnext/utilities/user_progress.py,Set a Target,Postavite cilj
DocType: Dosage Strength,Dosage Strength,Snaga doziranja
DocType: Healthcare Practitioner,Inpatient Visit Charge,Naknada za bolničko posjećivanje
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,Published Items,Objavljeni predmeti
DocType: Account,Expense Account,Rashodi račun
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Software,softver
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Colour,Boja
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Plan Procjena Kriteriji
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Transakcije
DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Spriječiti narudžbenice
apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Osjetljiv
DocType: Email Campaign,Scheduled,Planiran
DocType: Shift Type,Working Hours Calculation Based On,Proračun radnog vremena na temelju
apps/erpnext/erpnext/config/buying.py,Request for quotation.,Zahtjev za ponudu.
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","Molimo odaberite stavku u kojoj &quot;Je kataloški Stavka&quot; je &quot;Ne&quot; i &quot;Je Prodaja Stavka&quot; &quot;Da&quot;, a ne postoji drugi bala proizvoda"
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js,Select Customer,Odaberite klijenta
DocType: Student Log,Academic,Akademski
DocType: Patient,Personal and Social History,Osobna i društvena povijest
apps/erpnext/erpnext/education/doctype/guardian/guardian.py,User {0} created,Korisnik {0} je stvoren
DocType: Fee Schedule,Fee Breakup for each student,Otkazivanje naknade za svakog studenta
apps/erpnext/erpnext/controllers/accounts_controller.py,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Ukupno unaprijed ({0}) protiv Red {1} ne može biti veći od sveukupnog ({2})
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Code,Promijeni kod
DocType: Purchase Invoice Item,Valuation Rate,Stopa vrednovanja
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Napravite Varijante
DocType: Vehicle,Diesel,Dizel
apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Valuta cjenika nije odabrana
DocType: Purchase Invoice,Availed ITC Cess,Availed ITC Cess
,Student Monthly Attendance Sheet,Studentski mjesečna posjećenost list
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Pravilo o isporuci primjenjuje se samo za prodaju
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Row amortizacije {0}: Sljedeći datum amortizacije ne može biti prije datuma kupnje
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Start Date,Datum početka projekta
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Until,Do
DocType: Rename Tool,Rename Log,Preimenuj prijavu
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Student Group or Course Schedule is mandatory,Obvezna je grupacija studenata ili raspored predmeta
DocType: Maintenance Visit Purpose,Against Document No,Protiv dokumentu nema
DocType: BOM,Scrap,otpaci
apps/erpnext/erpnext/utilities/user_progress.py,Go to Instructors,Idite na instruktore
apps/erpnext/erpnext/config/selling.py,Manage Sales Partners.,Uredi prodajne partnere.
DocType: Quality Inspection,Inspection Type,Inspekcija Tip
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,All bank transactions have been created,Sve su bankovne transakcije stvorene
DocType: Fee Validity,Visited yet,Još posjetio
apps/erpnext/erpnext/public/js/hub/pages/FeaturedItems.vue,You can Feature upto 8 items.,Možete predstaviti do 8 predmeta.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to group.,Skladišta s postojećim transakcije se ne može pretvoriti u skupinu.
DocType: Assessment Result Tool,Result HTML,rezultat HTML
DocType: Selling Settings,How often should project and company be updated based on Sales Transactions.,Koliko često se projekt i tvrtka trebaju ažurirati na temelju prodajnih transakcija.
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expires On,istječe
apps/erpnext/erpnext/utilities/user_progress.py,Add Students,Dodaj studente
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js,Please select {0},Odaberite {0}
DocType: C-Form,C-Form No,C-obrazac br
DocType: Delivery Stop,Distance,Udaljenost
apps/erpnext/erpnext/utilities/user_progress.py,List your products or services that you buy or sell.,Navedite svoje proizvode ili usluge koje kupujete ili prodaju.
DocType: Water Analysis,Storage Temperature,Temperatura skladištenja
DocType: Sales Order,SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-
DocType: Employee Attendance Tool,Unmarked Attendance,Neoznačeno posjećenost
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Creating Payment Entries......,Izrada uplata ......
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Researcher,istraživač
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid public token error,Pogreška javnog tokena u obliku video zapisa
DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Program za alat Upis studenata
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py,Start date should be less than end date for task {0},Datum početka trebao bi biti manji od datuma završetka zadatka {0}
,Consolidated Financial Statement,Konsolidirano financijsko izvješće
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py,Name or Email is mandatory,Ime ili e-mail je obavezno
DocType: Instructor,Instructor Log,Zapisnik instruktora
DocType: Clinical Procedure,Clinical Procedure,Klinički postupak
DocType: Shopify Settings,Delivery Note Series,Serija s isporukom
DocType: Purchase Order Item,Returned Qty,Vraćeno Kom
DocType: Student,Exit,Izlaz
DocType: Communication Medium,Communication Medium,Komunikacijski medij
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root Type is mandatory,Korijen Tip je obvezno
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to install presets,Instalacija preseta nije uspjela
DocType: Healthcare Service Unit Type,UOM Conversion in Hours,UOM pretvorba u satima
DocType: Contract,Signee Details,Signee Detalji
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} trenutačno ima stajalište dobavljača rezultata {1}, a zahtjevi za odobrenje dobavljaču trebaju biti izdani s oprezom."
DocType: Certified Consultant,Non Profit Manager,Neprofitni menadžer
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} created,Serijski Ne {0} stvorio
DocType: Homepage,Company Description for website homepage,Opis tvrtke za web stranici
DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Za praktičnost kupaca, te kodovi mogu se koristiti u tiskanim formata kao što su fakture i otpremnice"
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py,Suplier Name,Naziv suplier
apps/erpnext/erpnext/accounts/report/financial_statements.py,Could not retrieve information for {0}.,Nije moguće dohvatiti podatke za {0}.
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py,Opening Entry Journal,Časopis za otvaranje
DocType: Contract,Fulfilment Terms,Uvjeti ispunjenja
DocType: Sales Invoice,Time Sheet List,Vrijeme Lista list
DocType: Employee,You can enter any date manually,Možete ručno unijeti bilo koji datum
DocType: Healthcare Settings,Result Printed,Rezultat je tiskan
DocType: Asset Category Account,Depreciation Expense Account,Amortizacija reprezentaciju
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Probationary Period,Probni
DocType: Purchase Taxes and Charges Template,Is Inter State,Je li Inter Država
apps/erpnext/erpnext/config/hr.py,Shift Management,Upravljanje pomakom
DocType: Customer Group,Only leaf nodes are allowed in transaction,Samo lisni čvorovi su dozvoljeni u transakciji
DocType: Project,Total Costing Amount (via Timesheets),Ukupni iznos troškova (putem vremenskih brojeva)
DocType: Department,Expense Approver,Rashodi Odobritelj
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Red {0}: Advance protiv Kupac mora biti kreditna
DocType: Quality Meeting,Quality Meeting,Sastanak kvalitete
apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-skupine do skupine
DocType: Employee,ERPNext User,ERPNext korisnik
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Šarža je obavezna u retku {0}
DocType: Company,Default Buying Terms,Zadani uvjeti kupnje
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Zaprimljena stavka iz primke
DocType: Amazon MWS Settings,Enable Scheduled Synch,Omogući zakazanu sinkronizaciju
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py,To Datetime,Za datetime
apps/erpnext/erpnext/config/crm.py,Logs for maintaining sms delivery status,Trupci za održavanje statusa isporuke sms
DocType: Accounts Settings,Make Payment via Journal Entry,Plaćanje putem Temeljnica
apps/erpnext/erpnext/controllers/item_variant.py,Please do not create more than 500 items at a time,Ne stvarajte više od 500 predmeta odjednom
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Printed On,tiskana na
DocType: Clinical Procedure Template,Clinical Procedure Template,Predložak kliničkog postupka
DocType: Item,Inspection Required before Delivery,Inspekcija potrebno prije isporuke
apps/erpnext/erpnext/config/education.py,Content Masters,Sadržaji
DocType: Item,Inspection Required before Purchase,Inspekcija Obavezno prije kupnje
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Pending Activities,Aktivnosti na čekanju
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Lab Test,Napravite laboratorijski test
DocType: Patient Appointment,Reminded,podsjetio
DocType: Homepage Section,Cards,Kartice
apps/erpnext/erpnext/public/js/setup_wizard.js,View Chart of Accounts,Prikaz sheme računa
DocType: Chapter Member,Chapter Member,Član poglavlja
DocType: Material Request Plan Item,Minimum Order Quantity,minimalna količina narudžbe
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}","Preskakanje dodjele odmora za sljedeće zaposlenike, kao što Dokumenti raspodjele odmora već postoje protiv njih. {0}"
DocType: Fee Component,Fees Category,naknade Kategorija
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please enter relieving date.,Unesite olakšavanja datum .
apps/erpnext/erpnext/controllers/trends.py,Amt,AMT
DocType: Travel Request,"Details of Sponsor (Name, Location)","Pojedinosti sponzora (ime, mjesto)"
DocType: Supplier Scorecard,Notify Employee,Obavijesti zaposlenika
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Enter value betweeen {0} and {1},Unesite vrijednost betweeen {0} i {1}
DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,"Unesite naziv kampanje, ako je izvor upit je kampanja"
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Newspaper Publishers,Novinski izdavači
apps/erpnext/erpnext/hr/utils.py,Future dates not allowed,Budući datumi nisu dopušteni
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Expected Delivery Date should be after Sales Order Date,Očekivani datum isporuke trebao bi biti nakon datuma prodaje
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Reorder Level,Poredaj Razina
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Chart Of Accounts Template,Kontni predložak
DocType: Attendance,Attendance Date,Gledatelja Datum
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Update stock must be enable for the purchase invoice {0},Ažuriranje zaliha mora biti omogućeno za fakturu kupnje {0}
apps/erpnext/erpnext/stock/get_item_details.py,Item Price updated for {0} in Price List {1},Artikl Cijena ažuriran za {0} u Cjeniku {1}
,DATEV,DATEV
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Plaća raspada temelju zarađivati i odbitka.
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with child nodes cannot be converted to ledger,Račun sa podređenim čvorom ne može se pretvoriti u glavnu knjigu
DocType: Purchase Invoice Item,Accepted Warehouse,Prihvaćeno skladište
DocType: Bank Reconciliation Detail,Posting Date,Datum objave
DocType: Item,Valuation Method,Metoda vrednovanja
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,One customer can be part of only single Loyalty Program.,Jedan klijent može biti dio samo jednog programa lojalnosti.
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Half Day,Mark Poludnevni
DocType: Sales Invoice,Sales Team,Prodajni tim
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Duplicate entry,Dupli unos
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the name of the Beneficiary before submittting.,Unesite ime Korisnika prije slanja.
DocType: Program Enrollment Tool,Get Students,dobiti studente
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Bank Data mapper doesn't exist,Karti za bankovne podatke ne postoje
DocType: Serial No,Under Warranty,Pod jamstvom
DocType: Homepage Section,Number of columns for this section. 3 cards will be shown per row if you select 3 columns.,Broj stupaca za ovaj odjeljak. Po 3 kartice prikazat će se po retku ako odaberete 3 stupca.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,[Error],[Greška]
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Reconcile Entries,Usklađivanje unosa
DocType: Sales Order,In Words will be visible once you save the Sales Order.,U riječi će biti vidljiv nakon što spremite prodajnog naloga.
,Employee Birthday,Rođendan zaposlenika
apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py,Please select Completion Date for Completed Repair,Odaberite Datum dovršetka za dovršen popravak
DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Studentski Batch Gledatelja alat
apps/erpnext/erpnext/controllers/status_updater.py,Limit Crossed,Ograničenje Crossed
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js,Scheduled Upto,Planirano upto
apps/erpnext/erpnext/hr/doctype/shift_type/shift_type.js,Attendance has been marked as per employee check-ins,Pohađanje je označeno prema prijavama zaposlenika
DocType: Woocommerce Settings,Secret,Tajna
DocType: Plaid Settings,Plaid Secret,Plaid Secret
DocType: Company,Date of Establishment,Datum osnivanja
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Venture Capital,venture Capital
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Akademska termina s ovim &#39;akademske godine&#39; {0} i &quot;Pojam Ime &#39;{1} već postoji. Molimo izmijeniti ove stavke i pokušati ponovno.
apps/erpnext/erpnext/stock/doctype/item/item.py,"As there are existing transactions against item {0}, you can not change the value of {1}","Kao što postoje neki poslovi protiv točki {0}, ne možete promijeniti vrijednost {1}"
DocType: UOM,Must be Whole Number,Mora biti cijeli broj
DocType: Campaign Email Schedule,Send After (days),Pošaljite nakon (dana)
DocType: Leave Control Panel,New Leaves Allocated (In Days),Novi Lišće alociran (u danima)
DocType: Purchase Invoice,Invoice Copy,Kopija fakture
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,Serial No {0} does not exist,Serijski Ne {0} ne postoji
DocType: Sales Invoice Item,Customer Warehouse (Optional),Kupac skladišta (po izboru)
DocType: Blanket Order Item,Blanket Order Item,Predmeti narudžbe
DocType: Pricing Rule,Discount Percentage,Postotak popusta
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sub contracting,Rezervirano za podugovaranje
DocType: Payment Reconciliation Invoice,Invoice Number,Račun broj
DocType: Shopping Cart Settings,Orders,Narudžbe
DocType: Travel Request,Event Details,Detalji događaja
DocType: Department,Leave Approver,Osoba ovlaštena za odobrenje odsustva
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select a batch,Odaberite grupu
DocType: Sales Invoice,Redemption Cost Center,Otvoreni troškovni centar
DocType: QuickBooks Migrator,Scope,djelokrug
DocType: Assessment Group,Assessment Group Name,Naziv grupe procjena
DocType: Manufacturing Settings,Material Transferred for Manufacture,Materijal prenose Proizvodnja
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Add to Details,Dodaj u pojedinosti
DocType: Travel Itinerary,Taxi,Taksi
DocType: Shopify Settings,Last Sync Datetime,Zadnji datum sinkronizacije
DocType: Landed Cost Item,Receipt Document Type,Potvrda Document Type
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal/Price Quote,Prijedlog / Citat
DocType: Antibiotic,Healthcare,Zdravstvo
DocType: Target Detail,Target Detail,Ciljana Detalj
apps/erpnext/erpnext/stock/doctype/item/item.js,Single Variant,Jedna varijanta
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,All Jobs,Svi poslovi
DocType: Sales Order,% of materials billed against this Sales Order,% robe od ove narudžbe je naplaćeno
DocType: Program Enrollment,Mode of Transportation,Način prijevoza
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"From a supplier under composition scheme, Exempt and Nil rated","Od dobavljača prema shemi sastava, Oslobođeno i Nil"
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Period Closing Entry,Zatvaranje razdoblja Stupanje
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Department...,Odaberite odjel ...
DocType: Pricing Rule,Free Item,Besplatna stavka
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Suppliies made to Composition Taxable Persons,Isporuke za porezne obveznike na sastav
apps/erpnext/erpnext/regional/india/utils.py,Distance cannot be greater than 4000 kms,Udaljenost ne može biti veća od 4000 km
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cost Center with existing transactions can not be converted to group,Troška s postojećim transakcija ne može se prevesti u skupini
DocType: QuickBooks Migrator,Authorization URL,URL za autorizaciju
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} {2} {3},Iznos {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,Broj dionica i brojeva udjela nedosljedni su
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Supplier(s),Dobavljač (s)
DocType: Employee Attendance Tool,Employee Attendance Tool,Sudjelovanje zaposlenika alat
DocType: Guardian Student,Guardian Student,Guardian Student
DocType: Supplier,Credit Limit,Kreditni limit
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Avg. Selling Price List Rate,Prosječni. Prodajni cjenovni popisi
DocType: Loyalty Program Collection,Collection Factor (=1 LP),Faktor zbirke (= 1 LP)
DocType: Additional Salary,Salary Component,Plaća Komponenta
apps/erpnext/erpnext/accounts/utils.py,Payment Entries {0} are un-linked,Prijave plaćanja {0} su UN-linked
DocType: GL Entry,Voucher No,Bon Ne
,Lead Owner Efficiency,Učinkovitost voditelja
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Workday {0} has been repeated.,Radni dan {0} je ponovljen.
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","Možete zatražiti samo iznos od {0}, iznos ostatka {1} trebao bi biti u aplikaciji \ pro-rata komponenta"
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Employee A/C Number,Broj zaposlenika
DocType: Amazon MWS Settings,Customer Type,Vrsta kupca
DocType: Compensatory Leave Request,Leave Allocation,Raspodjela odsustva
DocType: Payment Request,Recipient Message And Payment Details,Primatelj poruke i podatke o plaćanju
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Please select a Delivery Note,Odaberite bilješku o isporuci
DocType: Support Search Source,Source DocType,Izvor DocType
apps/erpnext/erpnext/templates/pages/help.html,Open a new ticket,Otvorite novu kartu
DocType: Training Event,Trainer Email,trener Email
DocType: Sales Invoice,Transporter,Transporter
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Day Book Data,Uvezi podatke knjige dana
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Priority {0} has been repeated.,Prioritet {0} je ponovljen.
DocType: Restaurant Reservation,No of People,Ne od ljudi
apps/erpnext/erpnext/config/buying.py,Template of terms or contract.,Predložak izraza ili ugovora.
DocType: Bank Account,Address and Contact,Kontakt
DocType: Vital Signs,Hyper,Hiper
DocType: Cheque Print Template,Is Account Payable,Je li račun naplativo
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Stock cannot be updated against Purchase Receipt {0},Stock ne može se ažurirati na potvrdi o kupnji {0}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Create Delivery Trip,Kreirajte putovanje isporukom
DocType: Support Settings,Auto close Issue after 7 days,Automatski zatvori Pitanje nakon 7 dana
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}","Ostavite se ne može dodijeliti prije {0}, kao dopust ravnoteža je već ručne proslijeđena u buduće dodjele dopusta rekord {1}"
apps/erpnext/erpnext/accounts/party.py,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Napomena: S obzirom / Referentni datum prelazi dopuštene kupca kreditne dana od {0} dana (s)
DocType: Program Enrollment Tool,Student Applicant,Studentski Podnositelj zahtjeva
DocType: Hub Tracked Item,Hub Tracked Item,Prikvačena stavka za središte
DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,IZVORNI ZA PRIMATELJ
DocType: Asset Category Account,Accumulated Depreciation Account,Akumulirana amortizacija računa
DocType: Certified Consultant,Discuss ID,Razgovarajte o ID-u
DocType: Stock Settings,Freeze Stock Entries,Zamrzavanje Stock Unosi
DocType: Program Enrollment,Boarding Student,Učenica za ukrcaj
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Booking Actual Expenses,Omogući primjenjivo na aktualne troškove rezervacije
DocType: Asset Finance Book,Expected Value After Useful Life,Očekivana vrijednost nakon korisnog vijeka trajanja
DocType: Item,Reorder level based on Warehouse,Razina redoslijeda na temelju Skladište
DocType: Activity Cost,Billing Rate,Ocijenite naplate
,Qty to Deliver,Količina za otpremu
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Disbursement Entry,Izradite unos isplate
DocType: Amazon MWS Settings,Amazon will synch data updated after this date,Amazon će sinkronizirati podatke ažurirane nakon tog datuma
,Stock Analytics,Analitika skladišta
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Operations cannot be left blank,Rad se ne može ostati prazno
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Select a Default Priority.,Odaberite zadani prioritet.
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,Lab Test(s) ,Lab test (e)
DocType: Maintenance Visit Purpose,Against Document Detail No,Protiv dokumenta Detalj No
apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Brisanje nije dopušteno za zemlju {0}
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Tip stranka je obvezna
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 radnu karticu {0} možete izvršiti samo unos vrste zaliha &quot;Prijenos materijala za proizvodnju&quot;
DocType: Quality Inspection,Outgoing,Odlazni
DocType: Customer Feedback Table,Customer Feedback Table,Tablica s povratnim informacijama kupaca
apps/erpnext/erpnext/config/support.py,Service Level Agreement.,Ugovor o razini usluge.
DocType: Material Request,Requested For,Traženi Za
DocType: Quotation Item,Against Doctype,Protiv DOCTYPE
apps/erpnext/erpnext/controllers/selling_controller.py,{0} {1} is cancelled or closed,{0} {1} je otkazan ili zatvoren
DocType: Asset,Calculate Depreciation,Izračunajte amortizaciju
DocType: Delivery Note,Track this Delivery Note against any Project,Prati ovu napomenu isporuke protiv bilo Projekta
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Investing,Neto novac od investicijskih
DocType: Purchase Invoice,Import Of Capital Goods,Uvoz kapitalnih dobara
DocType: Work Order,Work-in-Progress Warehouse,Rad u tijeku Warehouse
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset {0} must be submitted,Imovina {0} mora biti predana
DocType: Fee Schedule Program,Total Students,Ukupno studenata
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Attendance Record {0} exists against Student {1},Gledatelja Zapis {0} ne postoji protiv Student {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference #{0} dated {1},Reference # {0} od {1}
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Eliminated due to disposal of assets,Amortizacija Ispadanje zbog prodaje imovine
DocType: Employee Transfer,New Employee ID,Novi ID zaposlenika
DocType: Loan,Member,Član
DocType: Work Order Item,Work Order Item,Radni nalog
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js,Show Opening Entries,Prikaži unose otvaranja
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.js,Unlink external integrations,Prekini vezu s vanjskim integracijama
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Choose a corresponding payment,Odaberite odgovarajuće plaćanje
DocType: Pricing Rule,Item Code,Šifra proizvoda
DocType: Student,EDU-STU-.YYYY.-,EDU-STU-.YYYY.-
DocType: Serial No,Warranty / AMC Details,Jamstveni / AMC Brodu
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Select students manually for the Activity based Group,Ručno odaberite studente za Grupu temeljenu na aktivnostima
DocType: Journal Entry,User Remark,Upute Zabilješka
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 može se stvoriti bonus zadržavanja za lijeve zaposlenike
DocType: Lead,Market Segment,Tržišni segment
DocType: Agriculture Analysis Criteria,Agriculture Manager,Voditelj poljoprivrede
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Paid Amount cannot be greater than total negative outstanding amount {0},Uplaćeni iznos ne može biti veći od ukupnog negativnog preostali iznos {0}
DocType: Supplier Scorecard Period,Variables,Varijable
DocType: Employee Internal Work History,Employee Internal Work History,Zaposlenikova interna radna povijest
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Closing (Dr),Zatvaranje (DR)
DocType: Cheque Print Template,Cheque Size,Ček Veličina
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} not in stock,Serijski broj {0} nije na skladištu
apps/erpnext/erpnext/config/accounting.py,Tax template for selling transactions.,Porezni predložak za prodajne transakcije.
DocType: Sales Invoice,Write Off Outstanding Amount,Otpisati preostali iznos
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py,Account {0} does not match with Company {1},Račun {0} ne podudara se s tvrtkom {1}
DocType: Education Settings,Current Academic Year,Tekuća akademska godina
DocType: Stock Settings,Default Stock UOM,Zadana kataloška mjerna jedinica
DocType: Asset,Number of Depreciations Booked,Broj deprecijaciju Rezervirano
apps/erpnext/erpnext/public/js/pos/pos.html,Qty Total,Ukupni broj
DocType: Landed Cost Item,Receipt Document,Prijem dokumenata
DocType: Employee Education,School/University,Škola / Sveučilište
DocType: Sales Invoice Item,Available Qty at Warehouse,Dostupna količina na skladištu
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Billed Amount,Naplaćeni iznos
DocType: Share Transfer,(including),(uključujući)
DocType: Quality Review Table,Yes/No,Da ne
DocType: Asset,Double Declining Balance,Dvaput padu Stanje
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Closed order cannot be cancelled. Unclose to cancel.,Zatvorena redoslijed ne može se otkazati. Otvarati otkazati.
DocType: Amazon MWS Settings,Synch Products,Proizvodi za sinkronizaciju
DocType: Loyalty Point Entry,Loyalty Program,Program odanosti
DocType: Student Guardian,Father,Otac
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Support Tickets,Podržite ulaznice
apps/erpnext/erpnext/controllers/accounts_controller.py,'Update Stock' cannot be checked for fixed asset sale,'Ažuriraj zalihe' ne može se provesti na prodaju osnovnog sredstva
DocType: Bank Reconciliation,Bank Reconciliation,Banka pomirenje
DocType: Attendance,On Leave,Na odlasku
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Get Updates,Nabavite ažuriranja
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štvu {3}
apps/erpnext/erpnext/stock/doctype/item/item.js,Select at least one value from each of the attributes.,Odaberite barem jednu vrijednost iz svakog od atributa.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Material Request {0} is cancelled or stopped,Zahtjev za robom {0} je otkazan ili zaustavljen
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Dispatch State,Država slanja
apps/erpnext/erpnext/config/help.py,Leave Management,Ostavite upravljanje
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Groups,Grupe
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Account,Grupa po računu
DocType: Purchase Invoice,Hold Invoice,Držite fakturu
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Please select Employee,Odaberite zaposlenika
DocType: Sales Order,Fully Delivered,Potpuno Isporučeno
DocType: Promotional Scheme Price Discount,Min Amount,Min. Iznos
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Lower Income,Niža primanja
DocType: Restaurant Order Entry,Current Order,Trenutačna narudžba
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Number of serial nos and quantity must be the same,Broj serijskih brojeva i količine mora biti isti
DocType: Delivery Trip,Driver Address,Adresa vozača
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Source and target warehouse cannot be same for row {0},Izvor i ciljna skladište ne može biti isti za redom {0}
DocType: Account,Asset Received But Not Billed,Imovina primljena ali nije naplaćena
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 tipa imovine / obveza račun, jer to kataloški Pomirenje je otvaranje Stupanje"
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Disbursed Amount cannot be greater than Loan Amount {0},Isplaćeni Iznos ne može biti veća od iznos kredita {0}
apps/erpnext/erpnext/utilities/user_progress.py,Go to Programs,Idite na Programs (Programi)
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Red {0} # Dodijeljeni iznos {1} ne može biti veći od neimenovanog iznosa {2}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Purchase Order number required for Item {0},Broj narudžbenice kupnje je potreban za artikal {0}
DocType: Leave Allocation,Carry Forwarded Leaves,Nosi proslijeđen lišće
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 poslije 'Do datuma'
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.js,No Staffing Plans found for this Designation,Nisu pronađeni planovi za osoblje za ovu oznaku
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Batch {0} of Item {1} is disabled.,Šifra {0} stavke {1} onemogućena je.
DocType: Leave Policy Detail,Annual Allocation,Godišnja raspodjela sredstava
DocType: Travel Request,Address of Organizer,Adresa Organizatora
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Healthcare Practitioner...,Odaberite liječnika medicine ...
DocType: Employee Boarding Activity,Applicable in the case of Employee Onboarding,Primjenjivo u slučaju zaposlenika Onboarding
apps/erpnext/erpnext/config/accounting.py,Tax template for item tax rates.,Obrazac poreza za porezne stope na stavke.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods Transferred,Prenesena roba
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Cannot change status as student {0} is linked with student application {1},Ne može se promijeniti status studenta {0} je povezan sa studentskom primjene {1}
DocType: Asset,Fully Depreciated,potpuno amortizirana
DocType: Item Barcode,UPC-A,UPC-A
,Stock Projected Qty,Stanje skladišta
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Customer {0} does not belong to project {1},Korisnik {0} ne pripada projicirati {1}
DocType: Employee Attendance Tool,Marked Attendance HTML,Označena Gledatelja HTML
apps/erpnext/erpnext/utilities/activation.py,"Quotations are proposals, bids you have sent to your customers","Citati su prijedlozi, ponude koje ste poslali na svoje klijente"
DocType: Sales Invoice,Customer's Purchase Order,Kupca narudžbenice
DocType: Clinical Procedure,Patient,Pacijent
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Bypass credit check at Sales Order ,Zaobilaženje kreditne provjere na prodajnom nalogu
DocType: Employee Onboarding Activity,Employee Onboarding Activity,Djelatnost onboarding aktivnosti
DocType: Location,Check if it is a hydroponic unit,Provjerite je li to hidroponična jedinica
DocType: Pick List Item,Serial No and Batch,Serijski broj i serije
DocType: Warranty Claim,From Company,Iz Društva
DocType: GSTR 3B Report,January,siječanj
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,Sum of Scores of Assessment Criteria needs to be {0}.,Zbroj ocjene kriterija za ocjenjivanje treba biti {0}.
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please set Number of Depreciations Booked,Molimo postavite Broj deprecijaciju Rezervirano
DocType: Supplier Scorecard Period,Calculations,izračuni
apps/erpnext/erpnext/public/js/stock_analytics.js,Value or Qty,"Vrijednost, ili Kol"
DocType: Payment Terms Template,Payment Terms,Uvjeti plaćanja
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Productions Orders cannot be raised for:,Productions narudžbe se ne može podići za:
DocType: Quality Meeting Minutes,Minute,Minuta
DocType: Purchase Invoice,Purchase Taxes and Charges,Nabavni porezi i terećenja
DocType: Chapter,Meetup Embed HTML,Meetup Embed HTML
DocType: Asset,Insured value,Osigurana vrijednost
apps/erpnext/erpnext/utilities/user_progress.py,Go to Suppliers,Idite na Dobavljače
DocType: POS Closing Voucher Taxes,POS Closing Voucher Taxes,Porez na bon za zatvaranje POS-a
,Qty to Receive,Količina za primanje
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Datumi početka i završetka nisu u važećem razdoblju obračuna plaća, ne može se izračunati {0}."
DocType: Leave Block List,Leave Block List Allowed,Odobreni popis neodobrenih odsustava
DocType: Grading Scale Interval,Grading Scale Interval,Ocjenjivanje ljestvice
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Expense Claim for Vehicle Log {0},Rashodi Zahtjev za vozila Prijavite {0}
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Popust (%) na Cjeniku s marginom
DocType: Healthcare Service Unit Type,Rate / UOM,Ocijenite / UOM
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py,All Warehouses,Svi Skladišta
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,No {0} found for Inter Company Transactions.,Ne postoji {0} pronađen za transakcije tvrtke Inter.
DocType: Travel Itinerary,Rented Car,Najam automobila
apps/erpnext/erpnext/public/js/hub/components/profile_dialog.js,About your Company,O vašoj tvrtki
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Balance Sheet account,Kredit na računu mora biti bilanca račun
DocType: Donor,Donor,donator
DocType: Global Defaults,Disable In Words,Onemogućavanje riječima
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Quotation {0} not of type {1},Ponuda {0} nije tip {1}
DocType: Maintenance Schedule Item,Maintenance Schedule Item,Stavka rasporeda održavanja
DocType: Sales Order,%  Delivered,% Isporučeno
apps/erpnext/erpnext/education/doctype/fees/fees.js,Please set the Email ID for the Student to send the Payment Request,Postavite ID e-pošte za učenika da pošalje zahtjev za plaćanjem
DocType: Skill,Skill Name,Naziv vještine
DocType: Patient,Medical History,Povijest bolesti
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Bank Overdraft Account,Bank Prekoračenje računa
DocType: Patient,Patient ID,ID pacijenta
DocType: Practitioner Schedule,Schedule Name,Raspored imena
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.py,Please enter GSTIN and state for the Company Address {0},Unesite GSTIN i upišite adresu tvrtke {0}
DocType: Currency Exchange,For Buying,Za kupnju
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Dodaj sve dobavljače
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Red # {0}: dodijeljeni iznos ne može biti veći od nepodmirenog iznosa.
DocType: Tally Migration,Parties,Strane
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Pretraživanje BOM
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,osigurani krediti
DocType: Purchase Invoice,Edit Posting Date and Time,Uredi datum knjiženja i vrijeme
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Molimo postavite Amortizacija se odnose računi u imovini Kategorija {0} ili Društvo {1}
DocType: Lab Test Groups,Normal Range,Normalan raspon
DocType: Call Log,Call Duration in seconds,Trajanje poziva u sekundi
DocType: Academic Term,Academic Year,Akademska godina
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Available Selling,Dostupna prodaja
DocType: Loyalty Point Entry Redemption,Loyalty Point Entry Redemption,Otkup ulaska u Loyalty Point
apps/erpnext/erpnext/config/accounting.py,Cost Center and Budgeting,Troškovno središte i proračun
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Opening Balance Equity,Početno stanje kapital
DocType: Campaign Email Schedule,CRM,CRM
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Payment Schedule,Molimo postavite Raspored plaćanja
DocType: Pick List,Items under this warehouse will be suggested,Predlozi ispod ovog skladišta bit će predloženi
DocType: Purchase Invoice,N,N
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Remaining,ostali
DocType: Appraisal,Appraisal,Procjena
DocType: Loan,Loan Account,Račun zajma
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from and valid upto fields are mandatory for the cumulative,Vrijedna od i valjana upto polja obavezna su za kumulativ
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 stavku {0} u retku {1}, broj serijskih brojeva ne odgovara odabranoj količini"
DocType: Purchase Invoice,GST Details,Detalji GST-a
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,This is based on transactions against this Healthcare Practitioner.,To se temelji na transakcijama protiv ove zdravstvene prakse.
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Email sent to supplier {0},E-pošta dostavljati opskrbljivaču {0}
DocType: Item,Default Sales Unit of Measure,Zadana prodajna jedinica mjere
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Academic Year: ,Akademska godina:
DocType: Inpatient Record,Admission Schedule Date,Datum rasporeda za upis
DocType: Subscription,Past Due Date,Prošli rok dospijeća
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Ne dopusti postavljanje alternativne stavke za stavku {0}
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Datum se ponavlja
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Ovlašteni potpisnik
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Neto dostupan ITC (A) - (B)
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Napravite naknade
DocType: Project,Total Purchase Cost (via Purchase Invoice),Ukupno troškovi nabave (putem kupnje proizvoda)
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Select Quantity,Odaberite Količina
DocType: Loyalty Point Entry,Loyalty Points,Bodovi lojalnosti
DocType: Customs Tariff Number,Customs Tariff Number,Broj carinske tarife
DocType: Employee Tax Exemption Proof Submission Detail,Maximum Exemption Amount,Najveći iznos izuzeća
DocType: Products Settings,Item Fields,Polja predmeta
DocType: Patient Appointment,Patient Appointment,Imenovanje pacijenata
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Approving Role cannot be same as role the rule is Applicable To,Odobravanje ulogu ne mogu biti isti kao i ulogepravilo odnosi se na
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Unsubscribe from this Email Digest,Odjaviti s ovog Pošalji Digest
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Get Suppliers By,Nabavite dobavljače po
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,{0} not found for Item {1},{0} nije pronađen za stavku {1}
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Value must be between {0} and {1},Vrijednost mora biti između {0} i {1}
apps/erpnext/erpnext/utilities/user_progress.py,Go to Courses,Idite na Tečajeve
DocType: Accounts Settings,Show Inclusive Tax In Print,Pokaži porez na inkluziju u tisku
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,"Bank Account, From Date and To Date are Mandatory","Bankovni račun, od datuma i do datuma su obavezni"
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Message Sent,Poslana poruka
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with child nodes cannot be set as ledger,Račun s djetetom čvorovi se ne može postaviti kao knjiga
DocType: C-Form,II,II
DocType: Quiz Result,Wrong,pogrešno
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Stopa po kojoj Cjenik valute se pretvaraju u kupca osnovne valute
DocType: Purchase Invoice Item,Net Amount (Company Currency),Neto iznos (Društvo valuta)
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Ukupni iznos predujma ne može biti veći od ukupnog sankcioniranog iznosa
DocType: Salary Slip,Hour Rate,Cijena sata
apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Omogući automatsku ponovnu narudžbu
DocType: Stock Settings,Item Naming By,Proizvod imenovan po
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Another Period Closing Entry {0} has been made after {1},Drugi period Zatvaranje Stupanje {0} je postignut nakon {1}
DocType: Work Order,Material Transferred for Manufacturing,Materijal Preneseni za Manufacturing
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Account {0} does not exists,Račun {0} ne postoji
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Select Loyalty Program,Odaberite program lojalnosti
DocType: Project,Project Type,Vrsta projekta
apps/erpnext/erpnext/projects/doctype/task/task.py,Child Task exists for this Task. You can not delete this Task.,Dijete Zadatak postoji za ovu Zadatak. Ne možete izbrisati ovu Zadatak.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,Either target qty or target amount is mandatory.,Ili meta Količina ili ciljani iznos je obavezna .
apps/erpnext/erpnext/config/projects.py,Cost of various activities,Troškovi raznih aktivnosti
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}","Postavljanje Događaji na {0}, budući da je zaposlenik u prilogu niže prodaje osoba nema ID korisnika {1}"
DocType: Timesheet,Billing Details,Detalji o naplati
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Source and target warehouse must be different,Izvorna i odredišna skladište mora biti drugačiji
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Failed. Please check your GoCardless Account for more details,Plaćanje neuspjelo. Više pojedinosti potražite u svojem računu za GoCardless
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Not allowed to update stock transactions older than {0},Nije dopušteno ažuriranje skladišnih transakcija starijih od {0}
DocType: BOM,Inspection Required,Inspekcija Obvezno
DocType: Purchase Invoice Item,PR Detail,PR Detalj
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the Bank Guarantee Number before submittting.,Unesite broj bankarske garancije prije slanja.
DocType: Driving License Category,Class,klasa
DocType: Sales Order,Fully Billed,Potpuno Naplaćeno
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work Order cannot be raised against a Item Template,Radni nalog ne može se podići na predložak stavke
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Buying,Pravilo isporuke primjenjivo je samo za kupnju
DocType: Vital Signs,BMI,BMI
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Cash In Hand,Novac u blagajni
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Delivery warehouse required for stock item {0},Isporuka skladište potrebno za dionicama stavku {0}
DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Bruto težina paketa. Obično neto težina + ambalaža težina. (Za tisak)
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,Korisnici s ovom ulogom smiju postaviti zamrznute račune i izradu / izmjenu računovodstvenih unosa protiv zamrznutih računa
DocType: Plaid Settings,Plaid Environment,Plaid okoliš
,Project Billing Summary,Sažetak naplate projekta
DocType: Vital Signs,Cuts,rezovi
DocType: Serial No,Is Cancelled,Je otkazan
DocType: Student Group,Group Based On,Skupina temeljena na
DocType: Journal Entry,Bill Date,Bill Datum
DocType: Healthcare Settings,Laboratory SMS Alerts,Laboratorijske SMS upozorenja
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,"Service Item,Type,frequency and expense amount are required","Usluga predmeta, vrsta, učestalost i rashodi količina potrebne su"
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:","Čak i ako postoji više Cijene pravila s najvišim prioritetom, onda sljedeći interni prioriteti primjenjuje se:"
DocType: Plant Analysis Criteria,Plant Analysis Criteria,Kriteriji analize biljaka
DocType: Cheque Print Template,Cheque Height,Ček Visina
DocType: Supplier,Supplier Details,Dobavljač Detalji
DocType: Setup Progress,Setup Progress,Postavi napredak
DocType: Expense Claim,Approval Status,Status odobrenja
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,From value must be less than to value in row {0},Od vrijednosti mora biti manje nego vrijednosti u redu {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 prije do danas
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Check all,Provjeri sve
,Issued Items Against Work Order,Izdane stavke protiv radnog naloga
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.js,Vacancies cannot be lower than the current openings,Slobodna radna mjesta ne mogu biti niža od trenutačnih
,BOM Stock Calculated,BOM zaliha izračunata
DocType: Vehicle Log,Invoice Ref,fakture Ref
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non-GST outward supplies,Vanjske zalihe bez GST-a
DocType: Company,Default Income Account,Zadani račun prihoda
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Patient History,Povijest bolesnika
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Unclosed Fiscal Years Profit / Loss (Credit),Nezatvorena Fiskalna godina Dobit / gubitak (Credit)
DocType: Sales Invoice,Time Sheets,vremenske tablice
DocType: Healthcare Service Unit Type,Change In Item,Promijeni stavku
DocType: Payment Gateway Account,Default Payment Request Message,Zadana Zahtjev Plaćanje poruku
DocType: Retention Bonus,Bonus Amount,Iznos bonusa
DocType: Item Group,Check this if you want to show in website,Označi ovo ako želiš prikazati na webu
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Balance ({0}),Stanje ({0})
DocType: Loyalty Point Entry,Redeem Against,Otkupiti protiv
apps/erpnext/erpnext/config/accounting.py,Banking and Payments,Bankarstvo i plaćanje
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Key,Unesite API ključ korisnika
DocType: Issue,Service Level Agreement Fulfilled,Izvršen ugovor o razini usluge
,Welcome to ERPNext,Dobrodošli u ERPNext
apps/erpnext/erpnext/config/crm.py,Lead to Quotation,Dovesti do kotaciju
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Email Reminders will be sent to all parties with email contacts,Podsjetnici e-pošte bit će poslani svim stranama s kontaktima e-pošte
DocType: Project,Twice Daily,Dvaput dnevno
DocType: Inpatient Record,A Negative,Negativan
apps/erpnext/erpnext/templates/includes/product_list.js,Nothing more to show.,Ništa više za pokazati.
DocType: Lead,From Customer,Od kupca
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Calls,Pozivi
apps/erpnext/erpnext/utilities/user_progress.py,A Product,Proizvod
DocType: Employee Tax Exemption Declaration,Declarations,izjave
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batches,serije
DocType: Article,LMS User,Korisnik LMS-a
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Place Of Supply (State/UT),Mjesto opskrbe (država / UT)
DocType: Purchase Order Item Supplied,Stock UOM,Kataloški UOM
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Purchase Order {0} is not submitted,Narudžbenicu {0} nije podnesen
DocType: Account,Expenses Included In Asset Valuation,Troškovi uključeni u procjenu vrijednosti imovine
DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normalni referentni raspon za odraslu osobu je 16-20 udaha / min (RCP 2012)
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Set Response Time and Resolution for Priority {0} at index {1}.,Podesite vrijeme odziva i razlučivost za prioritet {0} na indeksu {1}.
DocType: Customs Tariff Number,Tariff Number,Tarifni broj
DocType: Work Order Item,Available Qty at WIP Warehouse,Dostupni broj u WIP Warehouseu
apps/erpnext/erpnext/stock/doctype/item/item.js,Projected,Predviđeno
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Warehouse {1},Serijski Ne {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,Napomena : Sustav neće provjeravati pretjerano isporuke i više - booking za točku {0} kao količinu ili vrijednost je 0
DocType: Issue,Opening Date,Datum otvaranja
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please save the patient first,Prvo spasi pacijenta
apps/erpnext/erpnext/education/api.py,Attendance has been marked successfully.,Sudjelovanje je uspješno označen.
DocType: Program Enrollment,Public Transport,Javni prijevoz
DocType: Sales Invoice,GST Vehicle Type,GST tip vozila
DocType: Soil Texture,Silt Composition (%),Sastav kompilacije (%)
DocType: Journal Entry,Remark,Primjedba
DocType: Healthcare Settings,Avoid Confirmation,Izbjegnite potvrdu
DocType: Bank Account,Integration Details,Detalji integracije
DocType: Purchase Receipt Item,Rate and Amount,Kamatna stopa i iznos
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.,Ne mogu izračunati vrijeme dolaska jer nedostaje adresa vozača.
DocType: Education Settings,Current Academic Term,Trenutni akademski naziv
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Item added,Redak # {0}: Stavka je dodana
DocType: Sales Order,Not Billed,Nije naplaćeno
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Both Warehouse must belong to same Company,Oba skladišta moraju pripadati istoj tvrtki
DocType: Employee Grade,Default Leave Policy,Zadana pravila o napuštanju
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,Odabrani unos za plaćanje trebao bi biti povezan s bankovnom transakcijom dužnika
apps/erpnext/erpnext/public/js/templates/contact_list.html,No contacts added yet.,Još uvijek nema dodanih kontakata.
DocType: Communication Medium Timeslot,Communication Medium Timeslot,Srednja komunikacija vremena
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Iznos naloga zavisnog troška
,Item Balance (Simple),Stavka salda (jednostavna)
apps/erpnext/erpnext/config/accounting.py,Bills raised by Suppliers.,Mjenice podigao dobavljače.
DocType: POS Profile,Write Off Account,Napišite Off račun
DocType: Patient Appointment,Get prescribed procedures,Preuzmite propisane postupke
DocType: Sales Invoice,Redemption Account,Otkupni račun
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.js,First add items in the Item Locations table,Prvo dodajte stavke u tablicu Lokacije predmeta
DocType: Pricing Rule,Discount Amount,Iznos popusta
DocType: Pricing Rule,Period Settings,Postavke razdoblja
DocType: Purchase Invoice,Return Against Purchase Invoice,Povratak protiv fakturi
DocType: Item,Warranty Period (in days),Jamstveni period (u danima)
DocType: Shift Type,Enable Entry Grace Period,Omogući razdoblje unosa za prijavu
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian1,Odnos s Guardian1
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},Odaberite BOM prema stavci {0}
DocType: Shopping Cart Settings,Show Stock Quantity,Prikaži količinu proizvoda
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Neto novčani tijek iz operacije
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Redak # {0}: Status mora biti {1} za popust fakture {2}
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Stavka 4
DocType: Student Admission,Admission End Date,Prijem Datum završetka
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Podugovaranje
DocType: Journal Entry Account,Journal Entry Account,Temeljnica račun
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js,Student Group,Studentski Grupa
DocType: Shopping Cart Settings,Quotation Series,Ponuda serija
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","Stavka postoji s istim imenom ( {0} ) , molimo promijenite ime stavku grupe ili preimenovati stavku"
DocType: Soil Analysis Criteria,Soil Analysis Criteria,Kriteriji analize tla
DocType: Pricing Rule Detail,Pricing Rule Detail,Detalj pravila o cijenama
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create BOM,Stvorite BOM
DocType: Pricing Rule,Apply Rule On Item Group,Primijeni pravilo na grupu predmeta
apps/erpnext/erpnext/accounts/page/pos/pos.js,Please select customer,Molimo izaberite kupca
DocType: Employee Tax Exemption Declaration,Total Declared Amount,Ukupni prijavljeni iznos
DocType: C-Form,I,ja
DocType: Company,Asset Depreciation Cost Center,Imovina Centar Amortizacija troškova
apps/erpnext/erpnext/templates/generators/item/item_configure.js,{0} item found.,{0} predmet je pronađen.
DocType: Production Plan Sales Order,Sales Order Date,Datum narudžbe (kupca)
DocType: Sales Invoice Item,Delivered Qty,Isporučena količina
DocType: Assessment Plan,Assessment Plan,plan Procjena
DocType: Travel Request,Fully Sponsored,Potpuno sponzoriran
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Obrnuti unos dnevnika
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Izradite Job Card
DocType: Quality Procedure Process,Process Description,Opis procesa
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Korisnik {0} je stvoren.
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Trenutno nema raspoloživih količina u bilo kojem skladištu
,Payment Period Based On Invoice Date,Razdoblje za naplatu po Datum fakture
DocType: Sample Collection,No. of print,Broj ispisa
apps/erpnext/erpnext/education/doctype/question/question.py,No correct answer is set for {0},Nije postavljen ispravan odgovor za {0}
DocType: Issue,Response By,Odgovor By
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Birthday Reminder,Podsjetnik za rođendan
DocType: Chart of Accounts Importer,Chart Of Accounts Importer,Uvoznik računa računa
DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,Rezervacija hotela Soba
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Missing Currency Exchange Rates for {0},Nedostaje Valuta za {0}
DocType: Employee Health Insurance,Health Insurance Name,Naziv zdravstvenog osiguranja
DocType: Assessment Plan,Examiner,Ispitivač
DocType: Student,Siblings,Braća i sestre
DocType: Journal Entry,Stock Entry,Međuskladišnica
DocType: Payment Entry,Payment References,Reference plaćanja
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","Broj intervala za polje intervala, npr. Ako Interval je &quot;Dani&quot; i broj intervala naplate je 3, fakture će se generirati svaka 3 dana"
DocType: Clinical Procedure Template,Allow Stock Consumption,Dopusti potrošnju zaliha
DocType: Asset,Insurance Details,Detalji osiguranje
DocType: Account,Payable,Plativ
DocType: Share Balance,Share Type,Vrsta dijeljenja
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter Repayment Periods,Unesite razdoblja otplate
apps/erpnext/erpnext/shopping_cart/cart.py,Debtors ({0}),Dužnici ({0})
DocType: Pricing Rule,Margin,Marža
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,New Customers,Novi kupci
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Gross Profit %,Bruto dobit%
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Appointment {0} and Sales Invoice {1} cancelled,Imenovanje {0} i prodajna faktura {1} otkazani su
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Opportunities by lead source,Mogućnosti izvora olova
DocType: Appraisal Goal,Weightage (%),Weightage (%)
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Change POS Profile,Promjena POS profila
DocType: Bank Reconciliation Detail,Clearance Date,Razmak Datum
DocType: Delivery Settings,Dispatch Notification Template,Predložak obavijesti o otpremi
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Report,Izvješće o procjeni
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Get Employees,Dobiti zaposlenike
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Add your review,Dodajte svoju recenziju
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Gross Purchase Amount is mandatory,Bruto Iznos narudžbe je obavezno
apps/erpnext/erpnext/setup/doctype/company/company.js,Company name not same,Naziv tvrtke nije isti
DocType: Lead,Address Desc,Adresa silazno
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party is mandatory,Stranka je obvezna
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.py,Please set account heads in GST Settings for Compnay {0},Postavite glave računa u GST Postavke za tvrtku {0}
DocType: Course Topic,Topic Name,tema Naziv
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Approval Notification in HR Settings.,Postavite zadani predložak za Obavijest o odobrenju za ostavljanje u HR postavkama.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Atleast one of the Selling or Buying must be selected,Barem jedan od prodajete ili kupujete mora biti odabran
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Select an employee to get the employee advance.,Odaberite zaposlenika kako biste dobili zaposlenika unaprijed.
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please select a valid Date,Odaberite valjani datum
apps/erpnext/erpnext/public/js/setup_wizard.js,Select the nature of your business.,Odaberite prirodu Vašeg poslovanja.
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 koji zahtijevaju samo jedan ulaz, rezultat UOM i normalnu vrijednost <br> Spoj za rezultate koji zahtijevaju više polja za unos s odgovarajućim nazivima događaja, rezultatima UOM-a i normalnim vrijednostima <br> Opisna za testove koji imaju više komponenti rezultata i odgovarajuća polja unosa rezultata. <br> Grupirane za testne predloške koji su skupina drugih testnih predložaka. <br> Nema rezultata za testove bez rezultata. Isto tako, nije stvoren Lab Test. npr. Podni testovi za grupirane rezultate."
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Duplicate entry in References {1} {2},Red # {0}: ponovljeni unos u referencama {1} {2}
apps/erpnext/erpnext/config/manufacturing.py,Where manufacturing operations are carried.,Gdje se odvija proizvodni postupci.
apps/erpnext/erpnext/education/doctype/instructor/instructor.js,As Examiner,Kao ispitivač
DocType: Company,Default Expense Claim Payable Account,Zaduženi platni račun potraživanja za troškove
DocType: Appointment Type,Default Duration,Zadano trajanje
DocType: BOM Explosion Item,Source Warehouse,Izvor galerija
DocType: Installation Note,Installation Date,Instalacija Datum
apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js,Share Ledger,Dijelite knjigu
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} does not belong to company {2},Red # {0}: Imovina {1} ne pripada društvu {2}
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Sales Invoice {0} created,Izrađena je prodajna faktura {0}
DocType: Employee,Confirmation Date,potvrda Datum
DocType: Inpatient Occupancy,Check Out,Provjeri
DocType: C-Form,Total Invoiced Amount,Ukupno Iznos dostavnice
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Min Qty can not be greater than Max Qty,Minimalna količina ne može biti veća od maksimalne količine
DocType: Soil Texture,Silty Clay,Silty Clay
DocType: Account,Accumulated Depreciation,akumulirana amortizacija
DocType: Supplier Scorecard Scoring Standing,Standing Name,Stalni naziv
DocType: Stock Entry,Customer or Supplier Details,Kupca ili dobavljača Detalji
DocType: Payment Entry,ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-
DocType: Asset Value Adjustment,Current Asset Value,Trenutna vrijednost aktive
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM recursion: {0} cannot be parent or child of {1},BOM rekurzija: {0} ne može biti roditelj ili dijete od {1}
DocType: QuickBooks Migrator,Quickbooks Company ID,ID tvrtke QuickBooks
DocType: Travel Request,Travel Funding,Financiranje putovanja
DocType: Employee Skill,Proficiency,vještina
DocType: Loan Application,Required by Date,Potrebna po datumu
DocType: Crop Cycle,A link to all the Locations in which the Crop is growing,Veza na sve lokacije u kojima raste usjeva
DocType: Lead,Lead Owner,Vlasnik potencijalnog kupca
DocType: Production Plan,Sales Orders Detail,Detalj narudžbe
DocType: Bin,Requested Quantity,Tražena količina
DocType: Pricing Rule,Party Information,Informacije o zabavi
DocType: Fees,EDU-FEE-.YYYY.-,EDU-FEE-.YYYY.-
DocType: Patient,Marital Status,Bračni status
DocType: Stock Settings,Auto Material Request,Automatski zahtjev za materijalom
DocType: Woocommerce Settings,API consumer secret,API tajna potrošača
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Dostupno Batch Količina u iz skladišta
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Bruto plaća - Ukupni odbitak - otplate kredita
DocType: Bank Account,Last Integration Date,Zadnji datum integracije
DocType: Expense Claim,Expense Taxes and Charges,Porez na poreza i naknada
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 troškovnik i novi troškovnik ne mogu biti isti
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py,Salary Slip ID,Plaća proklizavanja ID
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date Of Retirement must be greater than Date of Joining,Datum umirovljenja mora biti veći od datuma pristupa
apps/erpnext/erpnext/stock/doctype/item/item.js,Multiple Variants,Višestruke inačice
DocType: Sales Invoice,Against Income Account,Protiv računu dohotka
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Delivered,{0}% Isporučeno
DocType: Subscription,Trial Period Start Date,Datum početka probnog razdoblja
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).,Stavka {0}: Ž Količina Jedinična {1} ne može biti manja od minimalne narudžbe kom {2} (definiranom u točki).
DocType: Certification Application,Certified,potvrđen
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Mjesečni postotak distribucije
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Party can only be one of ,Stranka može biti samo jedna od
apps/erpnext/erpnext/regional/india/utils.py,Please mention Basic and HRA component in Company,Molimo navedite komponentu Basic i HRA u tvrtki
DocType: Daily Work Summary Group User,Daily Work Summary Group User,Korisnik grupa dnevnog rada
DocType: Territory,Territory Targets,Prodajni plan prema teritoriju
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},Molimo postavite zadani {0} u Društvu {1}
DocType: Cheque Print Template,Starting position from top edge,Početni položaj od gornjeg ruba
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Same supplier has been entered multiple times,Isti dobavljač je unesen više puta
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py,Gross Profit / Loss,Bruto dobit / gubitak
,Warehouse wise Item Balance Age and Value,Skladište mudar Stavka Stanje Dob i vrijednost
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Achieved ({}),Postignuto ({})
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Stavka narudžbenice broj
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Name cannot be Company,Ime tvrtke ne mogu biti poduzeća
apps/erpnext/erpnext/support/doctype/issue/issue.py,{0} parameter is invalid,Parametar {0} nije važeći
apps/erpnext/erpnext/config/settings.py,Letter Heads for print templates.,Zaglavlja za ispis predložaka.
apps/erpnext/erpnext/config/settings.py,Titles for print templates e.g. Proforma Invoice.,"Naslovi za ispis predložaka, na primjer predračuna."
DocType: Program Enrollment,Walking,Hodanje
DocType: Student Guardian,Student Guardian,Studentski Guardian
DocType: Member,Member Name,Ime člana
DocType: Stock Settings,Use Naming Series,Upotrijebite seriju naziva
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,No Action,Nema akcije
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Valuation type charges can not marked as Inclusive,Troškovi tipa Vrednovanje se ne može označiti kao Inclusive
DocType: POS Profile,Update Stock,Ažuriraj zalihe
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,Različite mjerne jedinice proizvoda će dovesti do ukupne pogrešne neto težine. Budite sigurni da je neto težina svakog proizvoda u istoj mjernoj jedinici.
DocType: Certification Application,Payment Details,Pojedinosti o plaćanju
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM stopa
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Čitanje prenesene datoteke
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Zaustavljen radni nalog ne može se otkazati, prvo ga otkazati"
DocType: Asset,Journal Entry for Scrap,Temeljnica za otpad
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Molimo povucite stavke iz Dostavnica
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Red {0}: odaberite radnu stanicu protiv operacije {1}
apps/erpnext/erpnext/accounts/utils.py,Journal Entries {0} are un-linked,Dnevničkih zapisa {0} su UN-povezani
apps/erpnext/erpnext/accounts/utils.py,{0} Number {1} already used in account {2},{0} Broj {1} koji je već korišten za račun {2}
apps/erpnext/erpnext/config/crm.py,"Record of all communications of type email, phone, chat, visit, etc.","Snimanje svih komunikacija tipa e-mail, telefon, chat, posjete, itd"
DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Ocjena ocjenitelja dobiva bodovanje
DocType: Manufacturer,Manufacturers used in Items,Proizvođači se koriste u stavkama
apps/erpnext/erpnext/accounts/general_ledger.py,Please mention Round Off Cost Center in Company,Molimo spomenuti zaokružiti troška u Društvu
DocType: Purchase Invoice,Terms,Uvjeti
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Select Days,Odaberite Dani
DocType: Academic Term,Term Name,pojam ime
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the correct code on Mode of Payment {1},Redak {0}: Postavite ispravan kôd na Način plaćanja {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...,Stvaranje plaće skliznula ...
apps/erpnext/erpnext/hr/doctype/department/department.js,You cannot edit root node.,Ne možete uređivati root čvor.
DocType: Buying Settings,Purchase Order Required,Narudžbenica kupnje je obavezna
apps/erpnext/erpnext/public/js/projects/timer.js,Timer,Odbrojavanje
,Item-wise Sales History,Pregled prometa po artiklu
DocType: Expense Claim,Total Sanctioned Amount,Ukupno kažnjeni Iznos
,Purchase Analytics,Analitika nabave
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Total flexible benefit component amount {0} should not be less than max benefits {1},Ukupni iznos komponente fleksibilne naknade {0} ne smije biti manji od maksimalnih naknada {1}
DocType: Sales Invoice Item,Delivery Note Item,Otpremnica proizvoda
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Current invoice {0} is missing,Nedostaje trenutačna faktura {0}
DocType: Asset Maintenance Log,Task,Zadatak
DocType: Purchase Taxes and Charges,Reference Row #,Reference Row #
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Batch number is mandatory for Item {0},Batch broj je obvezna za točku {0}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js,This is a root sales person and cannot be edited.,To jekorijen prodavač i ne može se mijenjati .
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. ","Ako je odabrana, navedena ili izračunana vrijednost u ovoj komponenti neće pridonijeti zaradi ili odbitcima. Međutim, vrijednost se može upućivati na druge komponente koje se mogu dodati ili odbiti."
,Stock Ledger,Glavna knjiga
DocType: Company,Exchange Gain / Loss Account,Razmjena Dobit / gubitka
DocType: Amazon MWS Settings,MWS Credentials,MWS vjerodajnice
apps/erpnext/erpnext/config/selling.py,Blanket Orders from Costumers.,Deke narudžbe kupaca.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Purpose must be one of {0},Svrha mora biti jedna od {0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Fill the form and save it,Ispunite obrazac i spremite ga
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Community Forum,Forum
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Actual qty in stock,Stvarni kvota na zalihi
DocType: Homepage,"URL for ""All Products""",URL za &quot;sve proizvode&quot;
DocType: Leave Application,Leave Balance Before Application,Bilanca odsustva prije predaje zahtjeva
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Send SMS,Pošalji SMS
DocType: Supplier Scorecard Criteria,Max Score,Maksimalni rezultat
DocType: Cheque Print Template,Width of amount in word,Širina iznosa u riječi
DocType: Purchase Order,Get Items from Open Material Requests,Se predmeti s Otvori Materijal zahtjeva
DocType: Hotel Room Amenity,Billable,Naplativo
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Ordered Qty: Quantity ordered for purchase, but not received.","Naručena količina: količina naručena za kupnju, ali nije došla ."
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Chart of Accounts and Parties,Obrada kontnog plana i stranaka
DocType: Lab Test Template,Standard Selling Rate,Standardni prodajni tečaj
DocType: Account,Rate at which this tax is applied,Stopa po kojoj je taj porez se primjenjuje
DocType: Cash Flow Mapper,Section Name,Naziv odjeljka
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Reorder Qty,Poredaj Kom
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Amortizacija reda {0}: očekivana vrijednost nakon korisnog vijeka trajanja mora biti veća ili jednaka {1}
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Current Job Openings,Trenutni radnih mjesta
DocType: Company,Stock Adjustment Account,Stock Adjustment račun
apps/erpnext/erpnext/public/js/payment/pos_payment.html,Write Off,Otpisati
apps/erpnext/erpnext/quality_management/doctype/quality_procedure/quality_procedure.py,{0} already has a Parent Procedure {1}.,{0} već ima roditeljski postupak {1}.
DocType: Healthcare Service Unit,Allow Overlap,Dopusti preklapanje
DocType: Timesheet Detail,Operation ID,Operacija ID
DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","ID korisnika sustava. Ako je postavljen, postat će zadani za sve HR oblike."
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Enter depreciation details,Unesite pojedinosti amortizacije
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,{0}: From {1},{0}: od {1}
DocType: Bank Transaction Mapping,Column in Bank File,Stupac u datoteci banke
apps/erpnext/erpnext/education/doctype/student_leave_application/student_leave_application.py,Leave application {0} already exists against the student {1},Napusti program {0} već postoji protiv učenika {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.,U redu čekanja za ažuriranje najnovije cijene u svim Bill of Materials. Može potrajati nekoliko minuta.
DocType: Pick List,Get Item Locations,Dohvati lokacije predmeta
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Naziv novog računa. Napomena: Molimo vas da ne stvaraju račune za kupce i dobavljače
DocType: POS Profile,Display Items In Stock,Prikaz stavki na zalihi
apps/erpnext/erpnext/config/settings.py,Country wise default Address Templates,Država mudar zadana adresa predlošci
DocType: Payment Order,Payment Order Reference,Referentni nalog za plaćanje
DocType: Water Analysis,Appearance,Izgled
DocType: HR Settings,Leave Status Notification Template,Ostavite predložak obavijesti o statusu
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Avg. Buying Price List Rate,Prosječni. Stopa popisa cjenika
DocType: Sales Order Item,Supplier delivers to Customer,Dobavljač dostavlja Kupcu
apps/erpnext/erpnext/config/non_profit.py,Member information.,Informacije članova.
DocType: Identification Document Type,Identification Document Type,Vrsta dokumenta identifikacije
apps/erpnext/erpnext/utilities/bot.py,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Obrazac / Artikl / {0}) nema na skladištu
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Maintenance,Održavanje imovine
,Sales Payment Summary,Sažetak plaćanja prodaje
DocType: Restaurant,Restaurant,Restoran
DocType: Woocommerce Settings,API consumer key,API ključ potrošača
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,Obavezan je datum
apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Zbog / Referentni datum ne može biti nakon {0}
apps/erpnext/erpnext/config/settings.py,Data Import and Export,Uvoz i izvoz podataka
DocType: Bank Account,Account Details,Detalji računa
DocType: Crop,Materials Required,Potrebni materijali
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Nema učenika Pronađeno
DocType: Employee Tax Exemption Declaration,Monthly HRA Exemption,Mjesečni izuzeće HRA-e
DocType: Clinical Procedure,Medical Department,Medicinski odjel
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Early Exits,Ukupno rani izlazi
DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Kriterij bodovanja ocjenjivača dobavljača
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,Invoice Posting Date,Račun knjiženja Datum
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Sell,Prodavati
DocType: Purchase Invoice,Rounded Total,Zaokruženi iznos
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Slots for {0} are not added to the schedule,Mjesta za {0} ne dodaju se u raspored
DocType: Product Bundle,List items that form the package.,Popis stavki koje čine paket.
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Not permitted. Please disable the Test Template,Nije dopušteno. Onemogućite predložak testa
DocType: Sales Invoice,Distance (in km),Udaljenost (u km)
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py,Percentage Allocation should be equal to 100%,Postotak izdvajanja mora biti 100 %
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select Posting Date before selecting Party,Odaberite datum knjiženja prije odabira stranku
apps/erpnext/erpnext/config/accounting.py,Payment Terms based on conditions,Uvjeti plaćanja na temelju uvjeta
DocType: Program Enrollment,School House,Škola Kuća
DocType: Serial No,Out of AMC,Od AMC
DocType: Opportunity,Opportunity Amount,Iznos prilika
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,Broj deprecijaciju rezervirano ne može biti veća od Ukupan broj deprecijaciju
DocType: Purchase Order,Order Confirmation Date,Datum potvrde narudžbe
DocType: Driver,HR-DRI-.YYYY.-,HR-DRI-.YYYY.-
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py,All Products,Svi proizvodi
DocType: Employee Transfer,Employee Transfer Details,Detalji prijenosa zaposlenika
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Please contact to the user who have Sales Master Manager {0} role,Molimo kontaktirajte korisniku koji imaju Sales Manager Master {0} ulogu
DocType: Company,Default Cash Account,Zadani novčani račun
DocType: Issue,Ongoing,U tijeku
apps/erpnext/erpnext/config/accounting.py,Company (not Customer or Supplier) master.,Društvo ( ne kupaca i dobavljača ) majstor .
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py,This is based on the attendance of this Student,To se temelji na prisustvo ovog Student
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,No Students in,Nema studenata u Zagrebu
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Add more items or open full form,Dodaj još stavki ili otvoriti puni oblik
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Otpremnica {0} mora biti otkazana prije poništenja ove narudžbenice
apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Idite na korisnike
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Uplaćeni iznos + otpis iznos ne može biti veći od SVEUKUPNO
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} nije ispravan broj serije za točku {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Napomena : Nema dovoljno ravnotežu dopust za dozvolu tipa {0}
DocType: Task,Task Description,Opis zadatka
DocType: Training Event,Seminar,Seminar
DocType: Program Enrollment Fee,Program Enrollment Fee,Program za upis naknada
DocType: Item,Supplier Items,Dobavljač Stavke
DocType: Material Request,MAT-MR-.YYYY.-,MAT-MR-.YYYY.-
DocType: Opportunity,Opportunity Type,Tip prilike
DocType: Asset Movement,To Employee,Za zaposlenika
DocType: Employee Transfer,New Company,Nova tvrtka
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py,Transactions can only be deleted by the creator of the Company,Transakcije se mogu samo izbrisana od tvorca Društva
apps/erpnext/erpnext/accounts/general_ledger.py,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Neispravan broj glavnu knjigu unose naći. Možda ste odabrali krivi račun u transakciji.
DocType: Employee,Prefered Contact Email,Poželjni Kontakt E-mail
DocType: Cheque Print Template,Cheque Width,Ček Širina
DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Provjera valjanosti prodajna cijena za točku protiv Cijena za plaćanje ili procijenjena stopa
DocType: Fee Schedule,Fee Schedule,Naknada Raspored
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Column Labels : ,Oznake stupaca:
DocType: Bank Transaction,Settled,Obavljene
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Disbursement Date cannot be after Loan Repayment Start Date,Datum isplate ne može biti nakon početnog datuma vraćanja zajma
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Cess,Uspjeh
DocType: Quality Feedback,Parameters,parametri
DocType: Company,Create Chart Of Accounts Based On,Izrada kontnog plana na temelju
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date of Birth cannot be greater than today.,Datum rođenja ne može biti veća nego danas.
,Stock Ageing,Starost skladišta
DocType: Travel Request,"Partially Sponsored, Require Partial Funding","Djelomično sponzoriran, zahtijeva djelomično financiranje"
apps/erpnext/erpnext/education/doctype/student/student.py,Student {0} exist against student applicant {1},Student {0} postoje protiv studenta podnositelja prijave {1}
DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Prilagođavanje zaokruživanja (valuta tvrtke)
apps/erpnext/erpnext/projects/doctype/task/task.js,Timesheet,kontrolna kartica
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Batch: ,serija:
DocType: Volunteer,Afternoon,Poslijepodne
DocType: Loyalty Program,Loyalty Program Help,Pomoć za program vjernosti
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} '{1}' is disabled,{0} '{1}' je onemogućen
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Open,Postavi kao Opena
DocType: Cheque Print Template,Scanned Cheque,Scanned Ček
DocType: Timesheet,Total Billable Amount,Ukupan iznos za naplatu
DocType: Customer,Credit Limit and Payment Terms,Uvjeti ograničenja i plaćanja kredita
DocType: Loyalty Program,Collection Rules,Pravila za prikupljanje
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 3,Stavka 3
apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js,Order Entry,Unos narudžbe
DocType: Purchase Order,Customer Contact Email,Kupac Kontakt e
DocType: Warranty Claim,Item and Warranty Details,Stavka i jamstvo Detalji
DocType: Chapter,Chapter Members,Članovi poglavlja
DocType: Sales Team,Contribution (%),Doprinos (%)
apps/erpnext/erpnext/controllers/accounts_controller.py,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Napomena : Stupanje Plaćanje neće biti izrađen od ' Gotovina ili bankovni račun ' nije naveden
DocType: Clinical Procedure,Nursing User,Korisnik za njegu
DocType: Employee Benefit Application,Payroll Period,Razdoblje obračuna plaća
DocType: Plant Analysis,Plant Analysis Criterias,Criterija analize bilja
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Batch {1},Serijski broj {0} ne pripada skupini {1}
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Your email address...,Vaša email adresa...
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.,Rok valjanosti ove ponude je završen.
DocType: Expense Claim Account,Expense Claim Account,Rashodi Zatraži račun
DocType: Account,Capital Work in Progress,Kapitalni radovi u tijeku
DocType: Accounts Settings,Allow Stale Exchange Rates,Dopusti stale tečaj
DocType: Sales Person,Sales Person Name,Ime prodajne osobe
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,Please enter atleast 1 invoice in the table,Unesite atleast jedan račun u tablici
apps/erpnext/erpnext/utilities/user_progress.py,Add Users,Dodaj korisnicima
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,No Lab Test created,Nije izrađen laboratorijski test
DocType: POS Item Group,Item Group,Grupa proizvoda
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Student Group: ,Skupina studenata:
DocType: Depreciation Schedule,Finance Book Id,ID knjige financiranja
DocType: Item,Safety Stock,Sigurnost Stock
DocType: Healthcare Settings,Healthcare Settings,Postavke zdravstvene zaštite
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Total Allocated Leaves,Ukupno dopuštena lišća
apps/erpnext/erpnext/projects/doctype/task/task.py,Progress % for a task cannot be more than 100.,Napredak% za zadatak ne može biti više od 100.
DocType: Stock Reconciliation Item,Before reconciliation,Prije pomirenja
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,To {0},Za {0}
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Porezi i naknade uvrštenja (Društvo 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,Stavka Porezna Row {0} mora imati račun tipa poreza ili prihoda i rashoda ili naplativ
DocType: Sales Order,Partly Billed,Djelomično naplaćeno
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} must be a Fixed Asset Item,Stavka {0} mora biti Fixed Asset predmeta
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,HSN,HSN
DocType: Item,Default BOM,Zadani BOM
DocType: Project,Total Billed Amount (via Sales Invoices),Ukupni iznos naplaćenog računa (putem faktura prodaje)
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Debit Note Amount,Debitni iznos bilješke
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,"There are inconsistencies between the rate, no of shares and the amount calculated","Postoje nedosljednosti između stope, broja dionica i izračunate iznosa"
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 prisutni cijeli dan između dana zahtjeva za kompenzacijski dopust
apps/erpnext/erpnext/setup/doctype/company/company.js,Please re-type company name to confirm,Ponovno upišite naziv tvrtke za potvrdu
DocType: Journal Entry,Printing Settings,Ispis Postavke
DocType: Payment Order,Payment Order Type,Vrsta naloga za plaćanje
DocType: Employee Advance,Advance Account,Advance Account
DocType: Job Offer,Job Offer Terms,Uvjeti ponude za posao
DocType: Sales Invoice,Include Payment (POS),Uključi plaćanje (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.,Praćenje sporazuma o razini usluge nije omogućeno.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Total Debit must be equal to Total Credit. The difference is {0},Ukupno zaduženje mora biti jednak ukupnom kreditnom .
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Automotive,Automobilska industrija
DocType: Vehicle,Insurance Company,Osiguravajuće društvo
DocType: Asset Category Account,Fixed Asset Account,Fiksni račun imovinom
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Variable,varijabla
apps/erpnext/erpnext/regional/italy/utils.py,"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","Fiskalni režim je obvezan, ljubazno postavite fiskalni režim u poduzeću {0}"
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js,From Delivery Note,Od otpremnici
DocType: Chapter,Members,članovi
DocType: Student,Student Email Address,Studentski e-mail adresa
DocType: Item,Hub Warehouse,Skladište hubova
DocType: Cashier Closing,From Time,S vremena
DocType: Hotel Settings,Hotel Settings,Postavke hotela
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html,In Stock: ,Na lageru:
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Investment Banking,Investicijsko bankarstvo
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Cash or Bank Account is mandatory for making payment entry,Novac ili bankovni račun je obvezna za izradu ulazak plaćanje
DocType: Education Settings,LMS Settings,LMS postavke
DocType: Company,Discount Allowed Account,Dopušten popust
DocType: Loyalty Program,Multiple Tier Program,Multiple Tier program
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Address,Studentska adresa
DocType: Purchase Invoice,Price List Exchange Rate,Tečaj cjenika
apps/erpnext/erpnext/patches/v11_0/rename_supplier_type_to_supplier_group.py,All Supplier Groups,Sve grupe dobavljača
DocType: Employee Boarding Activity,Required for Employee Creation,Obavezno za stvaranje zaposlenika
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account Number {0} already used in account {1},Broj računa {0} već se koristi u računu {1}
DocType: GoCardless Mandate,Mandate,Mandat
DocType: Hotel Room Reservation,Booked,rezerviran
DocType: Detected Disease,Tasks Created,Created Tasks
DocType: Purchase Invoice Item,Rate,VPC
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Intern,stažista
DocType: Delivery Stop,Address Name,adresa Ime
DocType: Stock Entry,From BOM,Od sastavnice
DocType: Assessment Code,Assessment Code,kod procjena
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,Stock transakcije prije {0} se zamrznut
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule',"Molimo kliknite na ""Generiraj raspored '"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference No is mandatory if you entered Reference Date,Reference Ne obvezno ako ušao referentnog datuma
DocType: Bank Reconciliation Detail,Payment Document,Dokument plaćanja
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py,Error evaluating the criteria formula,Pogreška u procjeni formule kriterija
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date of Joining must be greater than Date of Birth,Datum pristupa mora biti veći od datuma rođenja
DocType: Subscription,Plans,Planovi
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,Opening Balance,Početno stanje
DocType: Salary Slip,Salary Structure,Plaća Struktura
DocType: Account,Bank,Banka
DocType: Job Card,Job Started,Posao je započeo
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Airline,Aviokompanija
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Issue Material,Materijal Izazova
apps/erpnext/erpnext/config/integrations.py,Connect Shopify with ERPNext,Spojite Shopify s ERPNextom
DocType: Production Plan,For Warehouse,Za galeriju
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,Delivery Notes {0} updated,Bilješke o isporuci {0} ažurirane
DocType: Employee,Offer Date,Datum ponude
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Quotations,Citati
DocType: Purchase Order,Inter Company Order Reference,Inter Company Referenca naloga
apps/erpnext/erpnext/accounts/page/pos/pos.js,You are in offline mode. You will not be able to reload until you have network.,Vi ste u izvanmrežnom načinu rada. Nećete biti u mogućnosti da ponovno učitati dok imate mrežu.
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Qty increased by 1,Red # {0}: Količina povećana za 1
DocType: Account,Include in gross,Uključite u 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.,Nema studentskih grupa stvorena.
DocType: Purchase Invoice Item,Serial No,Serijski br
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Monthly Repayment Amount cannot be greater than Loan Amount,Mjesečni iznos otplate ne može biti veća od iznosa kredita
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please enter Maintaince Details first,Unesite prva Maintaince Detalji
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Red # {0}: očekivani datum isporuke ne može biti prije datuma narudžbe
DocType: Purchase Invoice,Print Language,Ispis Language
DocType: Salary Slip,Total Working Hours,Ukupno Radno vrijeme
DocType: Sales Invoice,Customer PO Details,Detalji o kupcima
apps/erpnext/erpnext/education/utils.py,You are not enrolled in program {0},Niste upisani u program {0}
DocType: Stock Entry,Including items for sub assemblies,Uključujući predmeta za sub sklopova
DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Privremeni račun otvaranja
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods In Transit,Roba u tranzitu
apps/erpnext/erpnext/accounts/page/pos/pos.js,Enter value must be positive,Unesite vrijednost moraju biti pozitivne
DocType: Asset,Finance Books,Financijske knjige
DocType: Employee Tax Exemption Declaration Category,Employee Tax Exemption Declaration Category,Kategorija deklaracije poreza na zaposlenike
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py,All Territories,Sve teritorije
DocType: Lost Reason Detail,Lost Reason Detail,Detalj o izgubljenom razlogu
apps/erpnext/erpnext/hr/utils.py,Please set leave policy for employee {0} in Employee / Grade record,Postavite pravila o dopustu za zaposlenika {0} u zapisniku zaposlenika / razreda
apps/erpnext/erpnext/public/js/controllers/transaction.js,Invalid Blanket Order for the selected Customer and Item,Nevažeća narudžba pokrivača za odabrane kupce i stavku
apps/erpnext/erpnext/projects/doctype/task/task_tree.js,Add Multiple Tasks,Dodaj više zadataka
DocType: Purchase Invoice,Items,Proizvodi
apps/erpnext/erpnext/crm/doctype/contract/contract.py,End Date cannot be before Start Date.,Datum završetka ne može biti prije datuma početka.
apps/erpnext/erpnext/education/doctype/course_enrollment/course_enrollment.py,Student is already enrolled.,Student je već upisan.
DocType: Fiscal Year,Year Name,Naziv godine
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,There are more holidays than working days this month.,Postoji više odmor nego radnih dana ovog mjeseca .
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,Sljedeće stavke {0} nisu označene kao {1} stavka. Možete ih omogućiti kao {1} stavku iz svog master stavke
DocType: Production Plan Item,Product Bundle Item,Proizvod bala predmeta
DocType: Sales Partner,Sales Partner Name,Naziv prodajnog partnera
apps/erpnext/erpnext/hooks.py,Request for Quotations,Zahtjev za dostavljanje ponuda
DocType: Payment Reconciliation,Maximum Invoice Amount,Maksimalna Iznos dostavnice
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() failed for empty IBAN,BankAccount.validate_iban () nije uspio za prazan IBAN
DocType: Normal Test Items,Normal Test Items,Normalno ispitne stavke
DocType: QuickBooks Migrator,Company Settings,Tvrtka Postavke
DocType: Additional Salary,Overwrite Salary Structure Amount,Prebriši iznos strukture plaće
DocType: Leave Ledger Entry,Leaves,lišće
DocType: Student Language,Student Language,Student jezika
DocType: Cash Flow Mapping,Is Working Capital,Radni kapital
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js,Submit Proof,Pošaljite dokaz
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order/Quot %,Redoslijed / kvota%
apps/erpnext/erpnext/config/healthcare.py,Record Patient Vitals,Snimite pacijente Vitals
DocType: Fee Schedule,Institution,Institucija
DocType: Asset,Partially Depreciated,djelomično amortiziraju
DocType: Issue,Opening Time,Radno vrijeme
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,From and To dates required,Od i Do datuma zahtijevanih
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Securities & Commodity Exchanges,Vrijednosni papiri i robne razmjene
apps/erpnext/erpnext/templates/pages/search_help.py,Docs Search,Pretraživanje dokumenata
apps/erpnext/erpnext/stock/doctype/item/item.py,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Zadana mjerna jedinica za Variant &#39;{0}&#39; mora biti isti kao u predložak &#39;{1}&#39;
DocType: Shipping Rule,Calculate Based On,Izračun temeljen na
DocType: Contract,Unfulfilled,neispunjen
DocType: Delivery Note Item,From Warehouse,Iz skladišta
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,No employees for the mentioned criteria,Nema zaposlenika za navedene kriterije
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials to Manufacture,Nema Stavke sa Bill materijala za proizvodnju
DocType: Shopify Settings,Default Customer,Zadani kupac
DocType: Sales Stage,Stage Name,Naziv stadija
apps/erpnext/erpnext/config/getting_started.py,Data Import and Settings,Uvoz podataka i postavke
DocType: Warranty Claim,SER-WRN-.YYYY.-,SER-wrn-.YYYY.-
DocType: Assessment Plan,Supervisor Name,Naziv Supervisor
DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,Nemojte potvrditi je li sastanak izrađen za isti dan
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Ship To State,Brod u državu
DocType: Program Enrollment Course,Program Enrollment Course,Tečaj za upis na program
DocType: Invoice Discounting,Bank Charges,Bankovne naknade
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner.py,User {0} is already assigned to Healthcare Practitioner {1},Korisnik {0} već je dodijeljen zdravstvenoj praksi {1}
DocType: Purchase Taxes and Charges,Valuation and Total,Vrednovanje i Total
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Negotiation/Review,Pregovaranje / pregled
DocType: Leave Encashment,Encashment Amount,Iznos ulaganja
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py,Scorecards,bodovima
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Expired Batches,Istekle serije
DocType: Employee,This will restrict user access to other employee records,To će ograničiti pristup korisniku drugim zapisima zaposlenika
DocType: Tax Rule,Shipping City,Dostava Grad
apps/erpnext/erpnext/regional/india/utils.py,GST HSN Code does not exist for one or more items,GST HSN kod ne postoji za jednu ili više stavki
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 ({}),Varijanca ({})
DocType: Purchase Invoice,Import Of Service,Uvoz usluge
DocType: Education Settings,LMS Title,LMS naslov
DocType: Sales Invoice,Ship,Brod
DocType: Staffing Plan Detail,Current Openings,Trenutni otvori
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Operations,Novčani tijek iz redovnog poslovanja
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CGST Amount,Iznos CGST
apps/erpnext/erpnext/utilities/activation.py,Create Student,Stvorite Student
DocType: Purchase Invoice,Shipping Rule,Dostava Pravilo
DocType: Patient Relation,Spouse,Suprug
DocType: Lab Test Groups,Add Test,Dodajte test
DocType: Manufacturer,Limited to 12 characters,Ograničiti na 12 znakova
DocType: Journal Entry,Print Heading,Ispis naslova
DocType: Quality Action Table,Quality Action Table,Tablica kvalitete kvalitete
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Total cannot be zero,Ukupna ne može biti nula
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,'Days Since Last Order' must be greater than or equal to zero,'Dani od posljednje narudžbe' mora biti veći ili jednak nuli
DocType: Plant Analysis Criteria,Maximum Permissible Value,Najveća dopuštena vrijednost
DocType: Journal Entry Account,Employee Advance,Predujam zaposlenika
DocType: Payroll Entry,Payroll Frequency,Plaće Frequency
DocType: Plaid Settings,Plaid Client ID,Plaid ID klijenta
DocType: Lab Test Template,Sensitivity,Osjetljivost
DocType: Plaid Settings,Plaid Settings,Postavke pleta
apps/erpnext/erpnext/erpnext_integrations/doctype/amazon_mws_settings/amazon_methods.py,Sync has been temporarily disabled because maximum retries have been exceeded,Sinkronizacija je privremeno onemogućena zbog prekoračenja maksimalnih pokušaja
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Raw Material,sirovine
DocType: Leave Application,Follow via Email,Slijedite putem e-maila
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Plants and Machineries,Biljke i strojevi
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Iznos poreza Nakon iznosa popusta
DocType: Patient,Inpatient Status,Status pacijenata
DocType: Asset Finance Book,In Percentage,U postocima
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Selected Price List should have buying and selling fields checked.,Odabrani cjenik trebao bi biti provjeren na poljima kupnje i prodaje.
apps/erpnext/erpnext/controllers/buying_controller.py,Please enter Reqd by Date,Unesite Reqd po datumu
DocType: Payment Entry,Internal Transfer,Interni premještaj
DocType: Asset Maintenance,Maintenance Tasks,Zadatci održavanja
apps/erpnext/erpnext/setup/doctype/territory/territory.py,Either target qty or target amount is mandatory,Ili meta Količina ili ciljani iznos je obvezna
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Please select Posting Date first,Molimo odaberite datum knjiženja prvo
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date should be before Closing Date,Otvaranje Datum bi trebao biti prije datuma zatvaranja
DocType: Travel Itinerary,Flight,Let
apps/erpnext/erpnext/public/js/hub/pages/NotFound.vue,Back to home,Povratak kući
DocType: Leave Control Panel,Carry Forward,Prenijeti
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cost Center with existing transactions can not be converted to ledger,Troška s postojećim transakcija ne može pretvoriti u knjizi
DocType: Budget,Applicable on booking actual expenses,Primjenjivo pri rezerviranju stvarnih troškova
DocType: Department,Days for which Holidays are blocked for this department.,Dani za koje su praznici blokirani za ovaj odjel.
DocType: Amazon MWS Settings,ERPNext Integrations,ERPNext integracije
DocType: Crop Cycle,Detected Disease,Otkrivena bolest
,Produced,Proizvedeno
DocType: Issue,Raised By (Email),Povišena Do (e)
DocType: Issue,Service Level Agreement,Ugovor o razini usluge
DocType: Training Event,Trainer Name,Ime trenera
DocType: Mode of Payment,General,Opći
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication,Posljednja komunikacija
,TDS Payable Monthly,TDS se plaća mjesečno
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,U redu čekanja za zamjenu BOM-a. Može potrajati nekoliko minuta.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Ne mogu odbiti kada kategorija je "" vrednovanje "" ili "" Vrednovanje i Total '"
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Ukupna plaćanja
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serijski Nos potrebna za serijaliziranom točke {0}
apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Match Plaćanja s faktura
DocType: Payment Entry,Get Outstanding Invoice,Nabavite izvanredni račun
DocType: Journal Entry,Bank Entry,Bank Stupanje
apps/erpnext/erpnext/stock/doctype/item/item.py,Updating Variants...,Ažuriranje varijanti ...
DocType: Authorization Rule,Applicable To (Designation),Odnosi se na (Oznaka)
,Profitability Analysis,Analiza profitabilnosti
DocType: Fees,Student Email,Studentska e-pošta
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Disburse Loan,Isplati zajam
DocType: Supplier,Prevent POs,Spriječite PO-ove
DocType: Patient,"Allergies, Medical and Surgical History","Alergije, medicinska i kirurška povijest"
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Add to Cart,Dodaj u košaricu
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js,Group By,Grupa Do
apps/erpnext/erpnext/config/accounting.py,Enable / disable currencies.,Omogućiti / onemogućiti valute .
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Could not submit some Salary Slips,Nije bilo moguće poslati nagradu za plaće
DocType: Project Template,Project Template,Predložak projekta
DocType: Exchange Rate Revaluation,Get Entries,Dobijte unose
DocType: Production Plan,Get Material Request,Dobiti materijala zahtjev
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Postal Expenses,Poštanski troškovi
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html,Sales Summary,Sažetak prodaje
apps/erpnext/erpnext/controllers/trends.py,Total(Amt),Ukupno (AMT)
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please identify/create Account (Group) for type - {0},Identificirajte / kreirajte račun (grupu) za vrstu - {0}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Entertainment & Leisure,Zabava i slobodno vrijeme
,Item Variant Details,Pojedinosti varijante stavke
DocType: Quality Inspection,Item Serial No,Serijski broj proizvoda
DocType: Payment Request,Is a Subscription,Je li pretplata
apps/erpnext/erpnext/utilities/activation.py,Create Employee Records,Stvaranje zaposlenika Records
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Present,Ukupno Present
DocType: Work Order,MFG-WO-.YYYY.-,MFG-WO-.YYYY.-
DocType: Drug Prescription,Hour,Sat
DocType: Restaurant Order Entry,Last Sales Invoice,Posljednja prodajna faktura
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select Qty against item {0},Odaberite Qty od stavke {0}
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,Novi serijski broj ne može biti na skladištu. Skladište mora biti postavljen od strane međuskladišnice ili primke
DocType: Lead,Lead Type,Tip potencijalnog kupca
apps/erpnext/erpnext/utilities/activation.py,Create Quotation,Napravi ponudu
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,You are not authorized to approve leaves on Block Dates,Niste ovlašteni za odobravanje lišće o skupnom Datumi
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} Request for {1},{0} Zahtjev za {1}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,All these items have already been invoiced,Svi ovi proizvodi su već fakturirani
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.,Nisu pronađene nepodmirene fakture za {0} {1} koji ispunjavaju filtre koje ste naveli.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Set New Release Date,Postavite novi datum izdavanja
DocType: Company,Monthly Sales Target,Mjesečni cilj prodaje
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,No outstanding invoices found,Nisu pronađene nepodmirene fakture
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Can be approved by {0},Može biti odobren od strane {0}
DocType: Hotel Room,Hotel Room Type,Vrsta sobe hotela
DocType: Customer,Account Manager,Account Manager
DocType: Issue,Resolution By Variance,Rezolucija po varijanti
DocType: Leave Allocation,Leave Period,Ostavite razdoblje
DocType: Item,Default Material Request Type,Zadana Materijal Vrsta zahtjeva
DocType: Supplier Scorecard,Evaluation Period,Razdoblje procjene
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js,Unknown,nepoznat
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order not created,Radni nalog nije izrađen
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}","Iznos {0} već zatraži za komponentu {1}, \ postavite iznos koji je jednak ili veći od {2}"
DocType: Shipping Rule,Shipping Rule Conditions,Dostava Koje uvjete
DocType: Purchase Invoice,Export Type,Vrsta izvoza
DocType: Salary Slip Loan,Salary Slip Loan,Zajmoprimac za plaću
DocType: BOM Update Tool,The new BOM after replacement,Novi BOM nakon zamjene
,Point of Sale,Point of Sale
DocType: Payment Entry,Received Amount,primljeni iznos
DocType: Patient,Widow,Udovica
DocType: GST Settings,GSTIN Email Sent On,GSTIN e-pošta poslana
DocType: Program Enrollment,Pick/Drop by Guardian,Pick / Drop od strane Guardian
DocType: Bank Account,SWIFT number,SWIFT broj
DocType: Payment Entry,Party Name,Naziv stranke
DocType: POS Closing Voucher,Total Collected Amount,Ukupni naplaćeni iznos
DocType: Employee Benefit Application,Benefits Applied,Prednosti primijenjene
DocType: Crop,Planting UOM,Sadnja UOM-a
DocType: Account,Tax,Porez
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Not Marked,neobilježen
DocType: Service Level Priority,Response Time Period,Vrijeme odgovora
DocType: Contract,Signed,potpisan
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices Summary,Sažetak otvaranja faktura
DocType: Member,NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-
DocType: Education Settings,Education Manager,Voditelj obrazovanja
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inter-State Supplies,Međudržavne potrepštine
DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Minimalna duljina između svake biljke u polju za optimalni rast
DocType: Quality Inspection,Report Date,Prijavi Datum
DocType: BOM,Routing,Usmjeravanje
DocType: Serial No,Asset Details,Pojedinosti o aktivi
DocType: Employee Tax Exemption Declaration Category,Declared Amount,Deklarirani iznos
DocType: Bank Statement Transaction Payment Item,Invoices,Računi
DocType: Water Analysis,Type of Sample,Vrsta uzorka
DocType: Batch,Source Document Name,Izvorni naziv dokumenta
DocType: Production Plan,Get Raw Materials For Production,Dobiti sirovine za proizvodnju
DocType: Job Opening,Job Title,Titula
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Buduće plaćanje Ref
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čava da {1} neće ponuditi ponudu, ali su citirane sve stavke \. Ažuriranje statusa licitacije."
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}.,Maksimalni uzorci - {0} već su zadržani za šaržu {1} i stavku {2} u seriji {3}.
DocType: Manufacturing Settings,Update BOM Cost Automatically,Ažurirajte automatski trošak BOM-a
DocType: Lab Test,Test Name,Naziv testiranja
DocType: Healthcare Settings,Clinical Procedure Consumable Item,Potrošnja za kliničku proceduru
apps/erpnext/erpnext/utilities/activation.py,Create Users,Stvaranje korisnika
apps/erpnext/erpnext/utilities/user_progress.py,Gram,Gram
DocType: Employee Tax Exemption Category,Max Exemption Amount,Iznos maksimalnog izuzeća
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,Subscriptions,Pretplate
DocType: Quality Review Table,Objective,Cilj
DocType: Supplier Scorecard,Per Month,Na mjesec
DocType: Education Settings,Make Academic Term Mandatory,Učini akademski pojam obvezan
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Quantity to Manufacture must be greater than 0.,Količina za proizvodnju mora biti veći od 0.
apps/erpnext/erpnext/config/crm.py,Visit report for maintenance call.,Pogledajte izvješće razgovora vezanih uz održavanje.
DocType: Stock Entry,Update Rate and Availability,Brzina ažuriranja i dostupnost
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.,Postotak koju smiju primiti ili isporučiti više od naručene količine. Na primjer: Ako ste naručili 100 jedinica. i tvoj ispravak je 10% onda se smiju primati 110 jedinica.
DocType: Shopping Cart Settings,Show Contact Us Button,Prikaži gumb Kontaktirajte nas
DocType: Loyalty Program,Customer Group,Grupa kupaca
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch ID (Optional),Novo ID serije (izborno)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Expense account is mandatory for item {0},Rashodi račun je obvezna za predmet {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Release date must be in the future,Datum izlaska mora biti u budućnosti
DocType: BOM,Website Description,Opis web stranice
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Equity,Neto promjena u kapitalu
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py,Not permitted. Please disable the Service Unit Type,Nije dopušteno. Onemogućite vrstu usluge
apps/erpnext/erpnext/crm/doctype/lead/lead.py,"Email Address must be unique, already exists for {0}","E-mail adresa mora biti jedinstvena, već postoji za {0}"
DocType: Serial No,AMC Expiry Date,AMC Datum isteka
DocType: Asset,Receipt,Priznanica
,Sales Register,Prodaja Registracija
DocType: Daily Work Summary Group,Send Emails At,Slanje e-pošte na
DocType: Quotation Lost Reason,Quotation Lost Reason,Razlog nerealizirane ponude
apps/erpnext/erpnext/accounts/doctype/sales_invoice/regional/india_list.js,Generate e-Way Bill JSON,Stvorite e-Way Bill JSON
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Transaction reference no {0} dated {1},Transakcija referenca ne {0} datumom {1}
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js,There is nothing to edit.,Ne postoji ništa za uređivanje .
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Form View,Prikaz obrasca
DocType: HR Settings,Expense Approver Mandatory In Expense Claim,Potrošač troškova obvezan u zahtjevu za trošak
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Summary for this month and pending activities,Sažetak za ovaj mjesec i tijeku aktivnosti
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,Please set Unrealized Exchange Gain/Loss Account in Company {0},Unesite neispunjeni račun dobiti i gubitka u tvrtki {0}
apps/erpnext/erpnext/utilities/user_progress.py,"Add users to your organization, other than yourself.","Dodajte korisnike u svoju organizaciju, osim sebe."
DocType: Customer Group,Customer Group Name,Naziv grupe kupaca
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}),Redak {0}: Količina nije dostupna za {4} u skladištu {1} u vrijeme knjiženja unosa ({2} {3})
apps/erpnext/erpnext/public/js/pos/pos.html,No Customers yet!,Još nema kupaca!
DocType: Quality Procedure Process,Link existing Quality Procedure.,Povežite postojeći postupak kvalitete.
apps/erpnext/erpnext/config/hr.py,Loans,krediti
DocType: Healthcare Service Unit,Healthcare Service Unit,Jedinica za zdravstvenu zaštitu
,Customer-wise Item Price,Kupcima prilagođena cijena
apps/erpnext/erpnext/public/js/financial_statements.js,Cash Flow Statement,Izvještaj o novčanom tijeku
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No material request created,Nije stvoren materijalni zahtjev
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.py,Loan Amount cannot exceed Maximum Loan Amount of {0},Iznos kredita ne može biti veći od maksimalnog iznosa zajma {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},Molimo uklonite ovu fakturu {0} od C-obrasca {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,Molimo odaberite prenositi ako želite uključiti prethodnoj fiskalnoj godini je ravnoteža ostavlja na ovoj fiskalnoj godini
DocType: GL Entry,Against Voucher Type,Protiv voucher vrsti
DocType: Healthcare Practitioner,Phone (R),Telefon (R)
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid {0} for Inter Company Transaction.,Nevažeći {0} za transakciju unutar tvrtke.
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Time slots added,Dodano je vrijeme
DocType: Products Settings,Attributes,Značajke
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Enable Template,Omogući predložak
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please enter Write Off Account,Unesite otpis račun
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Last Order Date,Zadnje narudžbe Datum
DocType: Accounts Settings,Unlink Advance Payment on Cancelation of Order,Prekini vezu s predujmom otkazivanja narudžbe
DocType: Salary Component,Is Payable,Isplati se
DocType: Inpatient Record,B Negative,Negativan
DocType: Pricing Rule,Price Discount Scheme,Shema popusta na cijene
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Maintenance Status has to be Cancelled or Completed to Submit,Status održavanja mora biti poništen ili dovršen za slanje
DocType: Amazon MWS Settings,US,NAS
DocType: Holiday List,Add Weekly Holidays,Dodajte tjedne praznike
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Report Item,Stavka izvješća
DocType: Staffing Plan Detail,Vacancies,Slobodna radna mjesta
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 društvu {1}
DocType: Homepage Section,Use this field to render any custom HTML in the section.,Upotrijebite ovo polje za prikaz bilo kojeg prilagođenog HTML-a u odjeljku.
DocType: Leave Type,Rounding,Zaokruživanje
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Serial Numbers in row {0} does not match with Delivery Note,Serijski brojevi u retku {0} ne podudaraju se s dostavom
DocType: Employee Benefit Application,Dispensed Amount (Pro-rated),Nepodmireni iznos (procijenjeni)
DocType: Student,Guardian Details,Guardian Detalji
DocType: C-Form,C-Form,C-obrazac
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! First 2 digits of GSTIN should match with State number {0}.,Nevažeći GSTIN! Prve dvije znamenke GSTIN-a trebaju se podudarati s državnim brojem {0}.
DocType: Agriculture Task,Start Day,Dan početka
DocType: Vehicle,Chassis No,šasija Ne
DocType: Payment Entry,Initiated,Pokrenut
DocType: Production Plan Item,Planned Start Date,Planirani datum početka
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select a BOM,Odaberite BOM
DocType: Purchase Invoice,Availed ITC Integrated Tax,Availed ITC integrirani porez
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Repayment Entry,Izradite unos otplate
DocType: Purchase Order Item,Blanket Order Rate,Brzina narudžbe
,Customer Ledger Summary,Sažetak knjige klijenta
apps/erpnext/erpnext/hooks.py,Certification,potvrda
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Are you sure you want to make debit note?,Jeste li sigurni da želite izvršiti zaduženje?
DocType: Bank Guarantee,Clauses and Conditions,Klauzule i uvjeti
DocType: Serial No,Creation Document Type,Tip stvaranje dokumenata
DocType: Amazon MWS Settings,ES,ES
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invoices,Nabavite fakture
DocType: Leave Allocation,New Leaves Allocated,Novi Leaves Dodijeljeni
apps/erpnext/erpnext/controllers/trends.py,Project-wise data is not available for Quotation,Projekt - mudar podaci nisu dostupni za ponudu
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,End on,Završi
DocType: Project,Expected End Date,Očekivani Datum završetka
DocType: Budget Account,Budget Amount,Iznos proračuna
DocType: Donor,Donor Name,Naziv donatora
DocType: Journal Entry,Inter Company Journal Entry Reference,Referentni referentni časopis za tvrtke
DocType: Course,Topics,Teme
DocType: Tally Migration,Is Day Book Data Processed,Obrađuju li se podaci dnevnih knjiga
DocType: Appraisal Template,Appraisal Template Title,Procjena Predložak Naslov
apps/erpnext/erpnext/utilities/user_progress_utils.py,Commercial,trgovački
DocType: Patient,Alcohol Current Use,Tekuća upotreba alkohola
DocType: Employee Tax Exemption Proof Submission,House Rent Payment Amount,Iznos plaćanja iznajmljivanja kuće
DocType: Student Admission Program,Student Admission Program,Program upisa studenata
DocType: Employee Tax Exemption Sub Category,Tax Exemption Category,Kategorija oslobođenja od plaćanja poreza
DocType: Payment Entry,Account Paid To,Račun plaćeni za
DocType: Subscription Settings,Grace Period,Razdoblje milosti
DocType: Item Alternative,Alternative Item Name,Alternativni naziv stavke
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py,Parent Item {0} must not be a Stock Item,Roditelj Stavka {0} ne smije biti kataloški predmeta
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Cannot create a Delivery Trip from Draft documents.,Ne mogu stvoriti putovanje dostave iz nacrta dokumenata.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Website Listing,Popis web stranica
apps/erpnext/erpnext/config/buying.py,All Products or Services.,Svi proizvodi i usluge.
DocType: Email Digest,Open Quotations,Otvori citate
apps/erpnext/erpnext/www/all-products/item_row.html,More Details,Više pojedinosti
DocType: Supplier Quotation,Supplier Address,Dobavljač Adresa
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} od {2} {3} je {4}. To će biti veći od {5}
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,This feature is under development...,Ova je značajka u razvoju ...
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Creating bank entries...,Izrada bankovnih unosa ...
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Out Qty,Od kol
apps/erpnext/erpnext/buying/doctype/supplier/supplier.py,Series is mandatory,Serija je obvezno
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Financial Services,Financijske usluge
DocType: Student Sibling,Student ID,studentska iskaznica
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Quantity must be greater than zero,Količina mora biti veća od nule
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 zaposlenika <a href=""#Form/Employee/{0}"">{0}</a> \ da biste otkazali ovaj dokument"
apps/erpnext/erpnext/config/projects.py,Types of activities for Time Logs,Vrste aktivnosti za vrijeme Evidencije
DocType: Opening Invoice Creation Tool,Sales,Prodaja
DocType: Stock Entry Detail,Basic Amount,Osnovni iznos
DocType: Training Event,Exam,Ispit
DocType: Email Campaign,Email Campaign,Kampanja e-pošte
apps/erpnext/erpnext/public/js/hub/hub_call.js,Marketplace Error,Pogreška na tržištu
DocType: Complaint,Complaint,prigovor
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Warehouse required for stock Item {0},Skladište je potrebno za skladišne proizvode {0}
DocType: Leave Allocation,Unused leaves,Neiskorišteni lišće
apps/erpnext/erpnext/patches/v11_0/create_department_records_for_each_company.py,All Departments,Svi odjeli
DocType: Healthcare Service Unit,Vacant,prazan
DocType: Patient,Alcohol Past Use,Prethodna upotreba alkohola
DocType: Fertilizer Content,Fertilizer Content,Sadržaj gnojiva
apps/erpnext/erpnext/public/js/hub/pages/Seller.vue,No description,bez opisa
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Cr,Cr
DocType: Tax Rule,Billing State,Državna naplate
DocType: Quality Goal,Monitoring Frequency,Učestalost nadgledanja
DocType: Share Transfer,Transfer,Prijenos
DocType: Quality Action,Quality Feedback,Povratne informacije o kvaliteti
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Work Order {0} must be cancelled before cancelling this Sales Order,Radni nalog {0} mora biti otkazan prije otkazivanja ovog prodajnog naloga
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Fetch exploded BOM (including sub-assemblies),Fetch eksplodirala BOM (uključujući i podsklopova )
DocType: Authorization Rule,Applicable To (Employee),Odnosi se na (Radnik)
apps/erpnext/erpnext/controllers/accounts_controller.py,Due Date is mandatory,Datum dospijeća je obavezno
apps/erpnext/erpnext/controllers/accounts_controller.py,Cannot set quantity less than received quantity,Ne može se postaviti količina manja od primljene količine
apps/erpnext/erpnext/controllers/item_variant.py,Increment for Attribute {0} cannot be 0,Pomak za Osobina {0} ne može biti 0
DocType: Employee Benefit Claim,Benefit Type and Amount,Vrsta i iznos koristi
DocType: Delivery Stop,Visited,posjetila
apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py,Rooms Booked,Sobe rezervirane
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Ends On date cannot be before Next Contact Date.,Završava Datum ne može biti prije Sljedećeg datuma kontakta.
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batch Entries,Ulazne serije
DocType: Journal Entry,Pay To / Recd From,Platiti do / primiti od
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Unpublish Item,Ponipublishtavanje stavke
DocType: Naming Series,Setup Series,Postavljanje Serija
DocType: Payment Reconciliation,To Invoice Date,Za Račun Datum
DocType: Bank Account,Contact HTML,Kontakt HTML
DocType: Support Settings,Support Portal,Portal podrške
apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py,Registration fee can not be Zero,Pristojba za registraciju ne može biti nula
DocType: Disease,Treatment Period,Razdoblje liječenja
DocType: Travel Itinerary,Travel Itinerary,Itinerar putovanja
apps/erpnext/erpnext/education/api.py,Result already Submitted,Rezultat je već poslan
apps/erpnext/erpnext/controllers/buying_controller.py,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Rezervirano skladište obvezno je za stavku {0} u sirovinama koje ste dobili
,Inactive Customers,Neaktivni korisnici
DocType: Student Admission Program,Maximum Age,Maksimalna dob
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Please wait 3 days before resending the reminder.,Pričekajte 3 dana prije ponovnog slanja podsjetnika.
DocType: Landed Cost Voucher,Purchase Receipts,Primke
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,"Upload a bank statement, link or reconcile a bank account","Prenesite bankovni izvod, povežite ili usklađujete bankovni račun"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,How Pricing Rule is applied?,Kako se primjenjuje pravilo cijena?
DocType: Stock Entry,Delivery Note No,Otpremnica br
DocType: Cheque Print Template,Message to show,Poruka za prikaz
apps/erpnext/erpnext/public/js/setup_wizard.js,Retail,Maloprodaja
DocType: Student Attendance,Absent,Odsutan
DocType: Staffing Plan,Staffing Plan Detail,Detalj planova osoblja
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,Dodjela odmora% s povezana je s aplikacijom za dopust% s
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Product Bundle,Snop proizvoda
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,Nije moguće pronaći rezultat koji započinje na {0}. Morate imati postignute rezultate koji pokrivaju 0 do 100
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Invalid reference {1},Red {0}: Pogrešna referentni {1}
apps/erpnext/erpnext/assets/doctype/location/location_tree.js,New Location,Nova lokacija
DocType: Purchase Invoice,Purchase Taxes and Charges Template,Predložak nabavnih poreza i terećenja
DocType: Additional Salary,Date on which this component is applied,Datum primjene ove komponente
DocType: Subscription,Current Invoice Start Date,Datum početka tekuće fakture
DocType: Designation Skill,Designation Skill,Oznaka Vještina
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of goods,Uvoz robe
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}: Iznos potraživanja ili dugovanja potreban za {2}
DocType: GL Entry,Remarks,Primjedbe
DocType: Support Settings,Track Service Level Agreement,Sporazum o razini usluge praćenja
DocType: Hotel Room Amenity,Hotel Room Amenity,Ugodnost hotela
DocType: Budget,Action if Annual Budget Exceeded on MR,Postupak ako je godišnji proračun prekoračen na MR
DocType: Course Enrollment,Course Enrollment,Upis na tečaj
DocType: Payment Entry,Account Paid From,Račun se plaća iz
DocType: Purchase Order Item Supplied,Raw Material Item Code,Sirovine Stavka Šifra
DocType: Task,Parent Task,Roditeljska zadaća
DocType: Project,From Template,Iz Predloška
DocType: Journal Entry,Write Off Based On,Otpis na temelju
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Print and Stationery,Ispis i konfekcija
DocType: Stock Settings,Show Barcode Field,Prikaži Barkod Polje
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Send Supplier Emails,Pošalji Supplier e-pošte
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 se već obrađuju za razdoblje od {0} i {1}, dopusta zahtjev ne može biti između ovom razdoblju."
DocType: Fiscal Year,Auto Created,Auto Created
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,Submit this to create the Employee record,Pošaljite ovo kako biste stvorili zapisnik zaposlenika
DocType: Item Default,Item Default,Stavka je zadana
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Intra-State Supplies,Unutarnje države
DocType: Chapter Member,Leave Reason,Ostavite razlog
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py,IBAN is not valid,IBAN nije valjan
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Invoice {0} no longer exists,Račun {0} više ne postoji
DocType: Guardian Interest,Guardian Interest,Guardian kamata
DocType: Volunteer,Availability,dostupnost
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,Prijava za odlazak povezana je s izdvajanjima za dopust {0}. Aplikacija za napuštanje ne može se postaviti kao dopust bez plaćanja
apps/erpnext/erpnext/config/retail.py,Setup default values for POS Invoices,Postavljanje zadanih vrijednosti za POS fakture
DocType: Employee Training,Training,Trening
DocType: Project,Time to send,Vrijeme je za slanje
apps/erpnext/erpnext/public/js/hub/pages/Selling.vue,This page keeps track of your items in which buyers have showed some interest.,Ova stranica prati vaše predmete za koje su kupci pokazali neki interes.
DocType: Timesheet,Employee Detail,Detalj zaposlenika
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.py,Set warehouse for Procedure {0} ,Postavite skladište za postupak {0}
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Email ID,Guardian1 ID e-pošte
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Error: {0} is mandatory field,Pogreška: {0} je obavezno polje
DocType: Lab Prescription,Test Code,Ispitni kod
apps/erpnext/erpnext/config/website.py,Settings for website homepage,Postavke za web stranice početnu stranicu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} je na čekanju 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},Zahtjevi za odobrenje nisu dopušteni za {0} zbog položaja {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Koristi lišće
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Želite li poslati materijalni zahtjev
DocType: Job Offer,Awaiting Response,Očekujem odgovor
DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Above,Iznad
DocType: Support Search Source,Link Options,Mogućnosti veze
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Total Amount {0},Ukupni iznos {0}
apps/erpnext/erpnext/controllers/item_variant.py,Invalid attribute {0} {1},Neispravan atribut {0} {1}
DocType: Supplier,Mention if non-standard payable account,Navedite ako je nestandardni račun koji se plaća
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py,Please select the assessment group other than 'All Assessment Groups',Odaberite grupu za procjenu osim &quot;Sve grupe za procjenu&quot;
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Row {0}: Cost center is required for an item {1},Redak {0}: centar za trošak je potreban za stavku {1}
DocType: Training Event Employee,Optional,neobavezan
DocType: Salary Slip,Earning & Deduction,Zarada &amp; Odbitak
DocType: Agriculture Analysis Criteria,Water Analysis,Analiza vode
DocType: Price List,Price Not UOM Dependent,Cijena nije UOM ovisna
apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,Stvorene su varijante {0}.
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Ugovor o razini usluge već postoji.
DocType: Quality Objective,Quality Objective,Cilj kvalitete
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Optional. This setting will be used to filter in various transactions.,Izborni . Ova postavka će se koristiti za filtriranje u raznim transakcijama .
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Negative Valuation Rate is not allowed,Negativna stopa vrijednovanja nije dopuštena
DocType: Holiday List,Weekly Off,Tjedni Off
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js,Reload Linked Analysis,Ponovno učitaj povezanu analizu
DocType: Fiscal Year,"For e.g. 2012, 2012-13","Za npr. 2012, 2012-13"
DocType: Purchase Order,Purchase Order Pricing Rule,Pravilo cijene narudžbe
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Provisional Profit / Loss (Credit),Privremeni dobit / gubitak (Credit)
DocType: Sales Invoice,Return Against Sales Invoice,Povratak protiv prodaje fakturu
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 5,Stavka 5
DocType: Serial No,Creation Time,vrijeme kreiranja
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Total Revenue,Ukupni prihodi
DocType: Patient,Other Risk Factors,Drugi čimbenici rizika
DocType: Sales Invoice,Product Bundle Help,Proizvod bala Pomoć
,Monthly Attendance Sheet,Mjesečna lista posjećenosti
DocType: Homepage Section Card,Subtitle,Titl
apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py,No record found,Nije pronađen zapis
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Scrapped Asset,Troškovi otpisan imovinom
DocType: Employee Checkin,OUT,OUT
apps/erpnext/erpnext/controllers/stock_controller.py,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Mjesto troška je ovezno za stavku {2}
DocType: Vehicle,Policy No,politika Nema
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get Items from Product Bundle,Se predmeti s Bundle proizvoda
DocType: Asset,Straight Line,Ravna crta
DocType: Project User,Project User,Korisnik projekta
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split,Split
DocType: Tally Migration,Master Data,Glavni podaci
DocType: Employee Transfer,Re-allocate Leaves,Ponovno alocirajte lišće
DocType: GL Entry,Is Advance,Je Predujam
apps/erpnext/erpnext/config/hr.py,Employee Lifecycle,Životni ciklus zaposlenika
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Attendance From Date and Attendance To Date is mandatory,Gledanost od datuma do datuma je obvezna
apps/erpnext/erpnext/controllers/buying_controller.py,Please enter 'Is Subcontracted' as Yes or No,Unesite ' Je podugovoren ' kao da ili ne
DocType: Item,Default Purchase Unit of Measure,Zadana jedinicna mjera kupnje
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication Date,Posljednji datum komunikacije
DocType: Clinical Procedure Item,Clinical Procedure Item,Postupak kliničke procedure
DocType: Sales Team,Contact No.,Kontakt broj
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Billing Address is same as Shipping Address,Adresa za naplatu jednaka je adresi za dostavu
DocType: Bank Reconciliation,Payment Entries,Prijave plaćanja
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py,Access token or Shopify URL missing,Nedostaje pristupni token ili Shopify URL
DocType: Location,Latitude,širina
DocType: Work Order,Scrap Warehouse,otpaci Skladište
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šte je potrebno za redak br. {0}, postavite zadano skladište za stavku {1} za tvrtku {2}"
DocType: Work Order,Check if material transfer entry is not required,Provjerite nije li unos prijenosa materijala potreban
DocType: Program Enrollment Tool,Get Students From,Dobiti studenti iz
apps/erpnext/erpnext/config/help.py,Publish Items on Website,Objavi stavke na web stranici
apps/erpnext/erpnext/utilities/activation.py,Group your students in batches,Grupa vaši učenici u serijama
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be greater than unadjusted amount,Dodijeljeni iznos ne može biti veći od neprilagođenog iznosa
DocType: Authorization Rule,Authorization Rule,Pravilo autorizacije
apps/erpnext/erpnext/projects/doctype/project/project.py,Status must be Cancelled or Completed,Status mora biti otkazan ili dovršen
DocType: Sales Invoice,Terms and Conditions Details,Uvjeti Detalji
DocType: Sales Invoice,Sales Taxes and Charges Template,Prodaja Porezi i pristojbe Predložak
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Total (Credit),Ukupno (Credit)
DocType: Repayment Schedule,Payment Date,Datum plačanja
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch Qty,Nova količina serije
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Apparel & Accessories,Odjeća i modni dodaci
apps/erpnext/erpnext/controllers/accounts_controller.py,Item quantity can not be zero,Količina predmeta ne može biti jednaka nuli
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Could not solve weighted score function. Make sure the formula is valid.,Nije moguće riješiti funkciju ponderirane ocjene. Provjerite je li formula valjana.
DocType: Invoice Discounting,Loan Period (Days),Razdoblje zajma (dani)
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Purchase Order Items not received on time,Stavke za kupnju nisu dobivene na vrijeme
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Number of Order,Broj narudžbe
DocType: Item Group,HTML / Banner that will show on the top of product list.,HTML / baner koji će se prikazivati na vrhu liste proizvoda.
DocType: Shipping Rule,Specify conditions to calculate shipping amount,Navedite uvjete za izračunavanje iznosa dostave
DocType: Program Enrollment,Institute's Bus,Autobus instituta
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Uloga dopušteno postavljanje blokada računa i uređivanje Frozen Entries
DocType: Supplier Scorecard Scoring Variable,Path,Staza
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cannot convert Cost Center to ledger as it has child nodes,"Ne može se pretvoriti troška za knjigu , kao da ima djece čvorova"
DocType: Production Plan,Total Planned Qty,Ukupni planirani broj
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Transactions already retreived from the statement,Transakcije su već povučene iz izjave
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Opening Value,Otvaranje vrijednost
DocType: Salary Component,Formula,Formula
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Serial #,Serijski #
DocType: Material Request Plan Item,Required Quantity,Potrebna količina
DocType: Lab Test Template,Lab Test Template,Predložak testa laboratorija
apps/erpnext/erpnext/accounts/doctype/accounting_period/accounting_period.py,Accounting Period overlaps with {0},Računovodstveno razdoblje se preklapa s {0}
apps/erpnext/erpnext/setup/doctype/company/company.py,Sales Account,Račun prodaje
DocType: Purchase Invoice Item,Total Weight,Totalna tezina
DocType: Pick List Item,Pick List Item,Odaberi stavku popisa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Commission on Sales,Komisija za prodaju
DocType: Job Offer Term,Value / Description,Vrijednost / Opis
apps/erpnext/erpnext/controllers/accounts_controller.py,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Red # {0}: Imovina {1} ne može se podnijeti, to je već {2}"
DocType: Tax Rule,Billing Country,Naplata Država
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Are you sure you want to make credit note?,Jeste li sigurni da želite uplatiti kreditni račun?
DocType: Purchase Order Item,Expected Delivery Date,Očekivani rok isporuke
DocType: Restaurant Order Entry,Restaurant Order Entry,Unos narudžbe restorana
apps/erpnext/erpnext/accounts/general_ledger.py,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debitne i kreditne nije jednaka za {0} # {1}. Razlika je {2}.
DocType: Clinical Procedure Item,Invoice Separately as Consumables,Fakturiranje odvojeno kao potrošni materijal
DocType: Budget,Control Action,Kontrolna radnja
DocType: Asset Maintenance Task,Assign To Name,Dodijeli ime
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Entertainment Expenses,Zabava Troškovi
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open Item {0},Otvoreno Stavka {0}
DocType: Asset Finance Book,Written Down Value,Pisana vrijednost
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Prodaja Račun {0} mora biti otkazana prije poništenja ovu prodajnog naloga
DocType: Clinical Procedure,Age,Doba
DocType: Sales Invoice Timesheet,Billing Amount,Naplata Iznos
DocType: Cash Flow Mapping,Select Maximum Of 1,Odaberite Maksimalno od 1
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Navedena je pogrešna količina za proizvod {0}. Količina treba biti veći od 0.
DocType: Company,Default Employee Advance Account,Zadani račun predujam zaposlenika
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Search Item (Ctrl + i),Pretraživanje (Ctrl + i)
DocType: C-Form,ACC-CF-.YYYY.-,ACC-CF-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction can not be deleted,Račun s postojećom transakcijom ne može se izbrisati
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Why do think this Item should be removed?,Zašto mislite da bi ovaj predmet trebao biti uklonjen?
DocType: Vehicle,Last Carbon Check,Posljednja Carbon Check
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Pravni troškovi
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Molimo odaberite količinu na red
DocType: Purchase Invoice,Posting Time,Vrijeme knjiženja
DocType: Timesheet,% Amount Billed,% Naplaćeni iznos
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefonski troškovi
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 ovo ako želite prisiliti korisniku odabir seriju prije spremanja. Tu će biti zadana ako to provjerili.
apps/erpnext/erpnext/stock/get_item_details.py,No Item with Serial No {0},Nema proizvoda sa serijskim brojem {0}
DocType: Email Digest,Open Notifications,Otvoreno Obavijesti
DocType: Payment Entry,Difference Amount (Company Currency),Razlika Iznos (Društvo valuta)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Expenses,Izravni troškovi
DocType: Pricing Rule Detail,Child Docname,Ime djeteta
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,New Customer Revenue,Novi prihod kupca
apps/erpnext/erpnext/config/support.py,Service Level.,Razina usluge.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Travel Expenses,putni troškovi
DocType: Maintenance Visit,Breakdown,Slom
DocType: Travel Itinerary,Vegetarian,Vegetarijanac
DocType: Patient Encounter,Encounter Date,Datum susreta
DocType: Work Order,Update Consumed Material Cost In Project,Ažuriranje troškova utrošenog materijala u projektu
apps/erpnext/erpnext/controllers/accounts_controller.py,Account: {0} with currency: {1} can not be selected,Račun: {0} s valutom: {1} ne može se odabrati
DocType: Bank Statement Transaction Settings Item,Bank Data,Podaci o bankama
DocType: Purchase Receipt Item,Sample Quantity,Količina uzorka
DocType: Bank Guarantee,Name of Beneficiary,Naziv Korisnika
DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Ažuriranje BOM-a automatski se naplaćuje putem Planera, temeljeno na najnovijoj stopi vrednovanja / stopi cjenika / zadnje stope kupnje sirovina."
DocType: Supplier,SUP-.YYYY.-,SUP-.YYYY.-
,BOM Items and Scraps,BOM Predmeti i bilješke
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}: nadređeni račun {1} ne pripada tvrtki: {2}
apps/erpnext/erpnext/setup/doctype/company/company.js,Successfully deleted all transactions related to this company!,Uspješno izbrisati sve transakcije vezane uz ovu tvrtku!
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,As on Date,Kao i na datum
DocType: Additional Salary,HR,HR
DocType: Course Enrollment,Enrollment Date,Datum registracije
DocType: Healthcare Settings,Out Patient SMS Alerts,Out Patient SMS obavijesti
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Probation,Probni rad
DocType: Company,Sales Settings,Prodajne postavke
DocType: Program Enrollment Tool,New Academic Year,Nova akademska godina
DocType: Supplier Scorecard,Load All Criteria,Učitaj sve kriterije
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Return / Credit Note,Povrat / odobrenje kupcu
DocType: Stock Settings,Auto insert Price List rate if missing,"Ako ne postoji, automatski ubaciti cjenik"
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Total Paid Amount,Ukupno uplaćeni iznos
DocType: GST Settings,B2C Limit,B2C ograničenje
DocType: Job Card,Transferred Qty,prebačen Kol
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,The selected payment entry should be linked with a creditor bank transaction,Odabrani unos za plaćanje trebao bi biti povezan s bankovnom transakcijom vjerovnika
DocType: POS Closing Voucher,Amount in Custody,Iznos u pritvoru
apps/erpnext/erpnext/config/help.py,Navigating,Kretanje
apps/erpnext/erpnext/hr/doctype/hr_settings/hr_settings.js,Password policy cannot contain spaces or simultaneous hyphens. The format will be restructured automatically,Pravila zaporki ne mogu sadržavati razmake ili simultane crtice. Format će se automatski restrukturirati
DocType: Quotation Item,Planning,planiranje
DocType: Salary Component,Depends on Payment Days,Ovisi o danima plaćanja
DocType: Contract,Signee,Signee
DocType: Share Balance,Issued,Izdano
DocType: Loan,Repayment Start Date,Početni datum otplate
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Student Activity,Aktivnost studenata
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Supplier Id,Id Dobavljač
DocType: Payment Request,Payment Gateway Details,Payment Gateway Detalji
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity should be greater than 0,Količina bi trebala biti veća od 0
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Price or product discount slabs are required,Obavezne su ploče sa cijenama ili popustima na proizvode
DocType: Journal Entry,Cash Entry,Novac Stupanje
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,Child nodes can be only created under 'Group' type nodes,Dijete čvorovi mogu biti samo stvorio pod tipa čvorišta &#39;Grupa&#39;
DocType: Attendance Request,Half Day Date,Poludnevni Datum
DocType: Academic Year,Academic Year Name,Naziv akademske godine
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} not allowed to transact with {1}. Please change the Company.,{0} nije dopušteno izvršiti transakciju s {1}. Promijenite tvrtku.
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},Iznos maksimalnog izuzeća ne može biti veći od maksimalnog iznosa izuzeća {0} kategorije izuzeća od poreza {1}
DocType: Sales Partner,Contact Desc,Kontakt ukratko
DocType: Email Digest,Send regular summary reports via Email.,Pošalji redovite sažetak izvješća putem e-maila.
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Please set default account in Expense Claim Type {0},Molimo postavite zadanog računa o troškovima za tužbu tipa {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Available Leaves,Dostupni lišće
DocType: Assessment Result,Student Name,Ime studenta
DocType: Hub Tracked Item,Item Manager,Stavka Manager
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Payroll Payable,Plaće Plaća
DocType: GSTR 3B Report,April,travanj
DocType: Plant Analysis,Collection Datetime,Datum datuma prikupljanja
DocType: Asset Repair,ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-
DocType: Work Order,Total Operating Cost,Ukupni trošak
apps/erpnext/erpnext/controllers/selling_controller.py,Note: Item {0} entered multiple times,Napomena : Proizvod {0} je upisan više puta
apps/erpnext/erpnext/config/buying.py,All Contacts.,Svi kontakti.
DocType: Accounting Period,Closed Documents,Zatvoreni dokumenti
DocType: Healthcare Settings,Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Upravljanje računom za imenovanje slati i poništiti automatski za Pacijentovo susret
apps/erpnext/erpnext/config/website.py,Add cards or custom sections on homepage,Dodajte kartice ili prilagođene odjeljke na početnu stranicu
DocType: Patient Appointment,Referring Practitioner,Referentni praktičar
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation,Kratica Društvo
apps/erpnext/erpnext/hr/doctype/employee/employee.py,User {0} does not exist,Korisnik {0} ne postoji
DocType: Payment Term,Day(s) after invoice date,Dan (a) nakon datuma fakture
apps/erpnext/erpnext/setup/doctype/company/company.js,Date of Commencement should be greater than Date of Incorporation,Datum početka mora biti veći od datuma osnivanja
DocType: Contract,Signed On,Potpisan
DocType: Bank Account,Party Type,Tip stranke
DocType: Discounted Invoice,Discounted Invoice,Račun s popustom
DocType: Payment Schedule,Payment Schedule,Raspored plaćanja
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,No Employee found for the given employee field value. '{}': {},Za određenu vrijednost polja zaposlenika nije pronađen nijedan zaposlenik. &#39;{}&#39;: {}
DocType: Item Attribute Value,Abbreviation,Skraćenica
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry already exists,Ulaz za plaćanje već postoji
DocType: Course Content,Quiz,Kviz
DocType: Subscription,Trial Period End Date,Datum završetka probnog razdoblja
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Not authroized since {0} exceeds limits,Niste ovlašteni od {0} prijeđenog limita
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Start entering data from here : ,Počnite unositi podatke odavde:
DocType: Serial No,Asset Status,Status aktive
DocType: Sales Invoice,Over Dimensional Cargo (ODC),Preko dimenzionalnog tereta (ODC)
DocType: Restaurant Order Entry,Restaurant Table,Tablica restorana
DocType: Hotel Room,Hotel Manager,Voditelj hotela
apps/erpnext/erpnext/utilities/activation.py,Create Student Batch,Stvorite skupinu učenika
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Set Tax Rule for shopping cart,Postavite Porezni Pravilo za košaricu
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.py,There are no vacancies under staffing plan {0},Nema slobodnih radnih mjesta u okviru kadrovskog plana {0}
DocType: Purchase Invoice,Taxes and Charges Added,Porezi i naknade Dodano
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Row amortizacije {0}: Sljedeći datum amortizacije ne može biti prije datuma raspoloživog korištenja
,Sales Funnel,prodaja dimnjak
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Naziv je obavezan
DocType: Project,Task Progress,Zadatak Napredak
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Kolica
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.py,Bank account {0} already exists and could not be created again,Bankovni račun {0} već postoji i ne može ga se ponovo stvoriti
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Missed,Poziv propušten
DocType: Certified Consultant,GitHub ID,GitHub ID
DocType: Staffing Plan,Total Estimated Budget,Ukupni procijenjeni proračun
,Qty to Transfer,Količina za prijenos
apps/erpnext/erpnext/config/selling.py,Quotes to Leads or Customers.,Ponude za kupce ili potencijalne kupce.
DocType: Stock Settings,Role Allowed to edit frozen stock,Uloga dopuštenih urediti smrznute zalihe
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Customer Groups,Sve grupe kupaca
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Accumulated Monthly,ukupna mjesečna
DocType: Attendance Request,On Duty,Na dužnosti
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je obavezno. Možda Mjenjačnica zapis nije stvoren za {1} na {2}.
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,Staffing Plan {0} already exist for designation {1},Plan osoblja {0} već postoji za oznaku {1}
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Template is mandatory.,Porez Predložak je obavezno.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Goods are already received against the outward entry {0},Roba je već primljena prema vanjskom ulazu {0}
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Last Issue,Zadnje izdanje
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} does not exist,Račun {0}: nadređeni račun {1} ne postoji
DocType: Bank Account,Mask,Maska
DocType: POS Closing Voucher,Period Start Date,Datum početka razdoblja
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Stopa cjenika (valuta tvrtke)
DocType: Products Settings,Products Settings,proizvodi Postavke
,Item Price Stock,Cijena artikala
apps/erpnext/erpnext/config/retail.py,To make Customer based incentive schemes.,Da biste napravili poticajne sheme temeljene na kupcu.
DocType: Lab Prescription,Test Created,Kreirano testiranje
DocType: Healthcare Settings,Custom Signature in Print,Prilagođeni potpis u tisku
DocType: Account,Temporary,Privremen
DocType: Material Request Plan Item,Customer Provided,Kupci opskrbljeni
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Customer LPO No.,Kupac LPO br.
DocType: Amazon MWS Settings,Market Place Account Group,Grupa računa robne kuće
DocType: Program,Courses,Tečajevi
DocType: Monthly Distribution Percentage,Percentage Allocation,Postotak raspodjele
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Secretary,tajnica
apps/erpnext/erpnext/regional/india/utils.py,House rented dates required for exemption calculation,Kuća iznajmljuje datume potrebne za izračun izuzeća
DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Ako onemogućite &quot;, riječima &#39;polja neće biti vidljiva u bilo koju transakciju"
DocType: Quality Review Table,Quality Review Table,Tablica pregleda kvalitete
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,This action will stop future billing. Are you sure you want to cancel this subscription?,Ta će radnja zaustaviti buduće naplate. Jeste li sigurni da želite otkazati ovu pretplatu?
DocType: Serial No,Distinct unit of an Item,Razlikuje jedinica stavku
DocType: Supplier Scorecard Criteria,Criteria Name,Naziv kriterija
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.js,Please set Company,Postavite tvrtku
DocType: Procedure Prescription,Procedure Created,Postupak izrađen
DocType: Pricing Rule,Buying,Nabava
apps/erpnext/erpnext/config/agriculture.py,Diseases & Fertilizers,Bolesti i gnojiva
DocType: HR Settings,Employee Records to be created by,Zaposlenik Records bi se stvorili
DocType: Inpatient Record,AB Negative,AB Negative
DocType: POS Profile,Apply Discount On,Nanesite popusta na
DocType: Member,Membership Type,Vrsta članstva
,Reqd By Date,Reqd Po datumu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Creditors,Vjerovnici
DocType: Assessment Plan,Assessment Name,Naziv Procjena
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No is mandatory,Red # {0}: Serijski br obvezno
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Stavka Wise Porezna Detalj
DocType: Employee Onboarding,Job Offer,Ponuda za posao
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Abbreviation,Institut naziv
,Item-wise Price List Rate,Item-wise cjenik
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Supplier Quotation,Dobavljač Ponuda
apps/erpnext/erpnext/config/support.py,Issue Priority.,Prioritet pitanja.
DocType: Quotation,In Words will be visible once you save the Quotation.,U riječi će biti vidljiv nakon što spremite ponudu.
apps/erpnext/erpnext/utilities/transaction_base.py,Quantity ({0}) cannot be a fraction in row {1},Količina ({0}) ne može biti frakcija u retku {1}
DocType: Contract,Unsigned,Nepotpisan
DocType: Selling Settings,Each Transaction,Svaka transakcija
apps/erpnext/erpnext/stock/doctype/item/item.py,Barcode {0} already used in Item {1},Barkod {0} se već koristi u proizvodu {1}
DocType: Shift Type,The time before the shift end time when check-out is considered as early (in minutes).,Vrijeme prije završetka smjene prilikom odjave smatra se ranim (u minutama).
apps/erpnext/erpnext/config/selling.py,Rules for adding shipping costs.,Pravila za dodavanje troškova prijevoza.
DocType: Hotel Room,Extra Bed Capacity,Dodatni krevetni kapacitet
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Varaiance ,Varaiance
apps/erpnext/erpnext/config/hr.py,Performance,Izvođenje
DocType: Item,Opening Stock,Otvaranje Stock
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Customer is required,Kupac je dužan
DocType: Lab Test,Result Date,Rezultat datuma
DocType: Purchase Order,To Receive,Primiti
DocType: Leave Period,Holiday List for Optional Leave,Popis za odmor za izborni dopust
DocType: Item Tax Template,Tax Rates,Porezne stope
apps/erpnext/erpnext/utilities/user_progress.py,user@example.com,user@example.com
DocType: Asset,Asset Owner,Vlasnik imovine
DocType: Item,Website Content,Sadržaj web stranice
DocType: Bank Account,Integration ID,Integracijski ID
DocType: Purchase Invoice,Reason For Putting On Hold,Razlog za stavljanje na čekanje
DocType: Employee,Personal Email,Osobni email
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Variance,Ukupne varijance
DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Ako je omogućeno, sustav će objaviti računovodstvene stavke za popis automatski."
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() accepted invalid IBAN {},BankAccount.validate_iban () prihvatio nevaljanu 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,Gledatelja za zaposlenika {0} već označena za ovaj dan
DocType: Work Order Operation,"in Minutes
Updated via 'Time Log'","U nekoliko minuta 
 Ažurirano putem 'Time Log'"
DocType: Customer,From Lead,Od Olovo
DocType: Amazon MWS Settings,Synch Orders,Sinkronizacijske narudžbe
apps/erpnext/erpnext/config/manufacturing.py,Orders released for production.,Narudžbe objavljen za proizvodnju.
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Fiscal Year...,Odaberite fiskalnu godinu ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS Profil potrebna da bi POS unos
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.","Bodovne bodove izračunat će se iz potrošnje (putem Prodajnog računa), na temelju faktora prikupljanja."
DocType: Program Enrollment Tool,Enroll Students,upisati studenti
DocType: Company,HRA Settings,Postavke HRA
DocType: Homepage,Hero Section,Sekcija heroja
DocType: Employee Transfer,Transfer Date,Datum prijenosa
DocType: Lab Test,Approved Date,Odobreni 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 jednom skladištu je obavezno
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 stavke kao što su UOM, grupa stavki, opis i broj sati."
DocType: Certification Application,Certification Status,Status certifikacije
apps/erpnext/erpnext/public/js/hub/marketplace.js,Marketplace,tržište
DocType: Travel Itinerary,Travel Advance Required,Potrebno je unaprijed
DocType: Subscriber,Subscriber Name,Pretplatničko ime
DocType: Serial No,Out of Warranty,Od jamstvo
DocType: Bank Statement Transaction Settings Item,Mapped Data Type,Vrsta kartiranog podataka
DocType: BOM Update Tool,Replace,Zamijeniti
apps/erpnext/erpnext/templates/includes/product_list.js,No products found.,Nisu pronađeni proizvodi.
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,Publish More Items,Objavite još predmeta
apps/erpnext/erpnext/support/doctype/issue/issue.py,This Service Level Agreement is specific to Customer {0},Ovaj Ugovor o razini usluge specifičan je za kupca {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Invoice {1},{0} u odnosu na prodajnom računu {1}
DocType: Antibiotic,Laboratory User,Korisnik laboratorija
DocType: Request for Quotation Item,Project Name,Naziv projekta
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Customer Address,Molimo postavite korisničku adresu
DocType: Customer,Mention if non-standard receivable account,Spomenuti ako nestandardni potraživanja 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,Dodajte preostale pogodnosti {0} na bilo koju postojeću komponentu
DocType: Journal Entry Account,If Income or Expense,Ako prihoda i rashoda
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},Prostor za zatvaranje bonova za POS postoji {0} između datuma {1} i {2}
DocType: Bank Statement Transaction Entry,Matching Invoices,Usklađivanje faktura
DocType: Work Order,Required Items,potrebne stavke
DocType: Stock Ledger Entry,Stock Value Difference,Stock Vrijednost 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,Stavka retka {0}: {1} {2} ne postoji u gornjoj tablici &quot;{1}&quot;
apps/erpnext/erpnext/config/help.py,Human Resource,Ljudski Resursi
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Pomirenje Plaćanje Plaćanje
DocType: Disease,Treatment Task,Zadatak liječenja
DocType: Payment Order Reference,Bank Account Details,Detalji bankovnog računa
DocType: Purchase Order Item,Blanket Order,Narudžba pokrivača
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.py,Repayment Amount must be greater than ,Iznos otplate mora biti veći od
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Tax Assets,porezna imovina
DocType: BOM Item,BOM No,BOM br.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Journal Entry {0} does not have account {1} or already matched against other voucher,Temeljnica {0} nema račun {1} ili već usklađeni protiv drugog bona
DocType: Item,Moving Average,Prosječna ponderirana cijena
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Benefit,Korist
DocType: BOM Update Tool,The BOM which will be replaced,BOM koji će biti zamijenjen
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Electronic Equipments,elektroničke opreme
DocType: Asset,Maintenance Required,Potrebno je održavanje
DocType: Account,Debit,Zaduženje
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leaves must be allocated in multiples of 0.5,"Odsustva moraju biti dodijeljena kao višekratnici od 0,5"
DocType: Work Order,Operation Cost,Operacija troškova
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Identifying Decision Makers,Identificiranje donositelja odluka
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Outstanding Amt,Izvanredna Amt
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Set cilja predmet Grupa-mudar za ovaj prodavač.
DocType: Stock Settings,Freeze Stocks Older Than [Days],Freeze Dionice stariji od [ dana ]
DocType: Payment Entry,Payment Ordered,Plaćanje je naručeno
DocType: Asset Maintenance Team,Maintenance Team Name,Ime tima za održavanje
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.","Ako dva ili više Cijene Pravila nalaze se na temelju gore navedenih uvjeta, Prioritet se primjenjuje. Prioritet je broj između 0 do 20, a zadana vrijednost je nula (prazno). Veći broj znači da će imati prednost ako ima više Cijene pravila s istim uvjetima."
apps/erpnext/erpnext/controllers/trends.py,Fiscal Year: {0} does not exists,Fiskalna godina: {0} ne postoji
DocType: Currency Exchange,To Currency,Valutno
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Dopusti sljedeći korisnici odobriti ostavite aplikacije za blok dana.
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Lifecycle,Životni ciklus
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Payment Document Type,Vrsta dokumenta plaćanja
apps/erpnext/erpnext/controllers/selling_controller.py,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Stopa prodaje za stavku {0} niža je od njegove {1}. Stopa prodaje trebao bi biti najmanje {2}
DocType: Designation Skill,Skill,Vještina
DocType: Subscription,Taxes,Porezi
DocType: Purchase Invoice Item,Weight Per Unit,Težina po jedinici
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Paid and Not Delivered,Plaćeni i nije isporučena
DocType: QuickBooks Migrator,Default Cost Center,Zadana troškovnih centara
apps/erpnext/erpnext/www/all-products/index.html,Toggle Filters,Uključi filtre
apps/erpnext/erpnext/config/stock.py,Stock Transactions,Stock transakcije
DocType: Budget,Budget Accounts,Proračun računa
DocType: Employee,Internal Work History,Unutarnja Povijest Posao
DocType: Bank Statement Transaction Entry,New Transactions,Nove transakcije
DocType: Depreciation Schedule,Accumulated Depreciation Amount,Akumulirana amortizacija iznos
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Private Equity,Private Equity
DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Variable Scorecard dobavljača
DocType: Shift Type,Working Hours Threshold for Half Day,Prag radnog vremena za pola dana
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please create purchase receipt or purchase invoice for the item {0},Izradite račun za kupnju ili fakturu za kupnju stavke {0}
DocType: Job Card,Material Transferred,Prijenos materijala
DocType: Employee Advance,Due Advance Amount,Dospjeli iznos unaprijed
DocType: Maintenance Visit,Customer Feedback,Kupac Ocjena
DocType: Account,Expense,rashod
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js,Score cannot be greater than Maximum Score,Rezultat ne može biti veća od najvišu ocjenu
DocType: Support Search Source,Source Type,Vrsta izvora
DocType: Course Content,Course Content,Sadržaj predmeta
apps/erpnext/erpnext/utilities/user_progress.py,Customers and Suppliers,Kupci i dobavljači
DocType: Item Attribute,From Range,Iz raspona
DocType: BOM,Set rate of sub-assembly item based on BOM,Postavite stavku podsklopa na temelju BOM-a
DocType: Inpatient Occupancy,Invoiced,fakturirana
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,WooCommerce Products,WooCommerce proizvodi
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in formula or condition: {0},sintaktička pogreška u formuli ili stanja: {0}
apps/erpnext/erpnext/stock/utils.py,Item {0} ignored since it is not a stock item,Proizvod {0} se ignorira budući da nije skladišni artikal
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 se ne primjenjuje pravilo Cijene u određenoj transakciji, svim primjenjivim pravilima cijena bi trebala biti onemogućen."
DocType: Payment Term,Day(s) after the end of the invoice month,Dan (i) nakon završetka mjeseca fakture
DocType: Assessment Group,Parent Assessment Group,Roditelj Grupa procjena
DocType: Employee Checkin,Shift Actual End,Stvarni kraj pomaka
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Jobs,Posao
,Sales Order Trends,Trend narudžbi kupca
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.,&#39;Iz paketa br.&#39; polje ne smije biti prazno niti vrijednost manja od 1.
DocType: Employee,Held On,Održanoj
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js,Production Item,Proizvodni proizvod
,Employee Information,Informacije o zaposleniku
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Healthcare Practitioner not available on {0},Zdravstvena praksa nije dostupna na {0}
DocType: Stock Entry Detail,Additional Cost,Dodatni trošak
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"Can not filter based on Voucher No, if grouped by Voucher","Ne možete filtrirati na temelju vaučer No , ako grupirani po vaučer"
DocType: Quality Inspection,Incoming,Dolazni
apps/erpnext/erpnext/setup/doctype/company/company.js,Default tax templates for sales and purchase are created.,Osnovni su predlošci poreza za prodaju i kupnju.
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py,Assessment Result record {0} already exists.,Zapis ocjena rezultata {0} već postoji.
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.","Primjer: ABCD. #####. Ako je niz postavljen, a transakcije se ne navode u Batch No, tada će se automatski izračunati broj serije na temelju ove serije. Ako uvijek želite izričito spomenuti Nijednu seriju za ovu stavku, ostavite to prazno. Napomena: ta će postavka imati prednost pred Prefiksom serije naziva u Stock Settings."
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Outward taxable supplies(zero rated),Porezni porezi (nulta ocjena)
DocType: BOM,Materials Required (Exploded),Potrebna roba
apps/erpnext/erpnext/buying/report/purchase_analytics/purchase_analytics.js,based_on,based_on
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Submit Review,Pošaljite pregled
DocType: Contract,Party User,Korisnik stranke
apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Postavite prazan filtar Tvrtke ako je Skupna pošta &quot;Tvrtka&quot;
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Knjiženja Datum ne može biti datum u budućnosti
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Red # {0}: Serijski br {1} ne odgovara {2} {3}
DocType: Stock Entry,Target Warehouse Address,Adresa ciljne skladišta
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Casual dopust
DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Vrijeme prije početka vremena smjene tijekom kojeg se prijava zaposlenika uzima u obzir za prisustvo.
DocType: Agriculture Task,End Day,Dan završetka
DocType: Batch,Batch ID,ID serije
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Note: {0},Napomena: {0}
DocType: Stock Settings,Action if Quality inspection is not submitted,Postupak ako se ne preda inspekcija kakvoće
,Delivery Note Trends,Trend otpremnica
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,This Week's Summary,Ovaj tjedan Sažetak
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,In Stock Qty,Na skladištu Kol
,Daily Work Summary Replies,Odgovori dnevnog rada
DocType: Delivery Trip,Calculate Estimated Arrival Times,Izračunajte procijenjene vrijeme dolaska
apps/erpnext/erpnext/accounts/general_ledger.py,Account: {0} can only be updated via Stock Transactions,Račun: {0} može se ažurirati samo preko Stock promet
DocType: Student Group Creation Tool,Get Courses,dobiti Tečajevi
DocType: Tally Migration,ERPNext Company,Tvrtka ERPNext
DocType: Shopify Settings,Webhooks,Webhooks
DocType: Bank Account,Party,Stranka
DocType: Healthcare Settings,Patient Name,Ime pacijenta
DocType: Variant Field,Variant Field,Polje varijante
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Target Location,Ciljana lokacija
DocType: Sales Order,Delivery Date,Datum isporuke
DocType: Opportunity,Opportunity Date,Datum prilike
DocType: Employee,Health Insurance Provider,Davatelj zdravstvenog osiguranja
DocType: Service Level,Holiday List (ignored during SLA calculation),Lista praznika (zanemareno tijekom izračuna SLA)
DocType: Products Settings,Show Availability Status,Prikaži stanje dostupnosti
DocType: Purchase Receipt,Return Against Purchase Receipt,Povratak na primku
DocType: Water Analysis,Person Responsible,Osoba odgovorna
DocType: Request for Quotation Item,Request for Quotation Item,Zahtjev za ponudu točke
DocType: Purchase Order,To Bill,Za Billa
DocType: Material Request,% Ordered,% Naruč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 Studentsku grupu na tečaju, tečaj će biti validiran za svakog studenta iz upisanih kolegija u upisu na program."
DocType: Employee Grade,Employee Grade,Grade zaposlenika
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Rad po komadu
DocType: GSTR 3B Report,June,lipanj
DocType: Share Balance,From No,Od br
DocType: Shift Type,Early Exit Grace Period,Period prijevremenog izlaska iz milosti
DocType: Task,Actual Time (in Hours),Stvarno vrijeme (u satima)
DocType: Employee,History In Company,Povijest tvrtke
DocType: Customer,Customer Primary Address,Primarna adresa korisnika
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Connected,Poziv je povezan
apps/erpnext/erpnext/config/crm.py,Newsletters,Newsletteri
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Reference No.,Referentni broj
DocType: Drug Prescription,Description/Strength,Opis / Snaga
apps/erpnext/erpnext/config/hr.py,Energy Point Leaderboard,Energy Point Leaderboard
DocType: Bank Statement Transaction Entry,Create New Payment/Journal Entry,Izradi novu uplatu / unos dnevnika
DocType: Certification Application,Certification Application,Potvrda prijave
DocType: Leave Type,Is Optional Leave,Izborni dopust
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Declare Lost,Proglasite izgubljenim
DocType: Share Balance,Is Company,Tvrtka
DocType: Pricing Rule,Same Item,Ista stavka
DocType: Stock Ledger Entry,Stock Ledger Entry,Upis u glavnu knjigu
DocType: Quality Action Resolution,Quality Action Resolution,Kvalitetna rezolucija akcije
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Half day Leave on {1},{0} na Poludnevni dopust na {1}
DocType: Department,Leave Block List,Popis neodobrenih odsustva
DocType: Purchase Invoice,Tax ID,OIB
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item {0} is not setup for Serial Nos. Column must be blank,Stavka {0} nije setup za serijski brojevi Stupac mora biti prazan
apps/erpnext/erpnext/regional/india/utils.py,Either GST Transporter ID or Vehicle No is required if Mode of Transport is Road,"Ako je način prijevoza cestovni, nije potreban ili GST Transporter ID ili vozilo"
DocType: Accounts Settings,Accounts Settings,Postavke računa
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Approve,Odobriti
DocType: Loyalty Program,Customer Territory,Teritorij korisnika
DocType: Email Digest,Sales Orders to Deliver,Prodajni nalozi za isporuku
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Number of new Account, it will be included in the account name as a prefix","Broj novog računa, bit će uključen u naziv računa kao prefiks"
DocType: Maintenance Team Member,Team Member,Član tima
DocType: GSTR 3B Report,Invoices with no Place Of Supply,Računi bez mjesta opskrbe
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,No Result to submit,Nema rezultata za slanje
DocType: Customer,Sales Partner and Commission,Prodaja partner i komisija
DocType: Loan,Rate of Interest (%) / Year,Kamatna stopa (%) / godina
,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'","Ukupno {0} za sve stavke nula, možda biste trebali promijeniti &#39;Podijeliti optužbi na temelju&#39;"
apps/erpnext/erpnext/hr/utils.py,To date can not be less than from date,Do danas ne može biti manji od datuma
DocType: Opportunity,To Discuss,Za Raspravljajte
apps/erpnext/erpnext/stock/stock_ledger.py,{0} units of {1} needed in {2} to complete this transaction.,{0} jedinica {1} potrebna u {2} za dovršetak ovu transakciju.
DocType: Loan Type,Rate of Interest (%) Yearly,Kamatna stopa (%) godišnje
apps/erpnext/erpnext/config/quality_management.py,Quality Goal.,Cilj kvalitete.
DocType: Support Settings,Forum URL,URL foruma
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Accounts,Privremeni računi
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Source Location is required for the asset {0},Izvor Lokacija je potrebna za imovinu {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Black,Crna
DocType: BOM Explosion Item,BOM Explosion Item,BOM eksplozije artikla
DocType: Shareholder,Contact List,Popis kontakata
DocType: Account,Auditor,Revizor
DocType: Project,Frequency To Collect Progress,Učestalost prikupljanja napretka
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items produced,{0} predmeti koji
apps/erpnext/erpnext/utilities/user_progress.py,Learn More,Uči više
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} is not added in the table,{0} nije dodan u tablici
DocType: Payment Entry,Party Bank Account,Račun stranke
DocType: Cheque Print Template,Distance from top edge,Udaljenost od gornjeg ruba
DocType: POS Closing Voucher Invoices,Quantity of Items,Količina stavki
apps/erpnext/erpnext/stock/get_item_details.py,Price List {0} is disabled or does not exist,Cjenik {0} je onemogućen ili ne postoji
DocType: Purchase Invoice,Return,Povratak
DocType: Account,Disable,Ugasiti
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Mode of payment is required to make a payment,Način plaćanja potrebno je izvršiti uplatu
DocType: Task,Pending Review,U tijeku pregled
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,"Edit in full page for more options like assets, serial nos, batches etc.","Uređivanje u cijeloj stranici za više opcija kao što su imovina, serijski brojevi, serije itd."
DocType: Leave Type,Maximum Continuous Days Applicable,Maksimalni neprekidni dani primjenjivi
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 4,Raspon starenja 4
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Batch {2},{0} - {1} nije upisana u skupinu {2}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,"Asset {0} cannot be scrapped, as it is already {1}","Imovina {0} ne može biti otpisan, kao što je već {1}"
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Cheques Required,Potrebna je provjera
DocType: Task,Total Expense Claim (via Expense Claim),Ukupni rashodi Zatraži (preko Rashodi Zahtjeva)
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Absent,Mark Odsutni
DocType: Job Applicant Source,Job Applicant Source,Izvor kandidata za posao
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,IGST Amount,Iznos IGST
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup company,Postavljanje tvrtke nije uspjelo
DocType: Asset Repair,Asset Repair,Popravak imovine
DocType: Warehouse,Warehouse Type,Vrsta skladišta
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Red {0}: Valuta sastavnice # {1} bi trebao biti jednak odabranoj valuti {2}
DocType: Journal Entry Account,Exchange Rate,Tečaj
DocType: Patient,Additional information regarding the patient,Dodatne informacije o pacijentu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Sales Order {0} is not submitted,Prodajnog naloga {0} nije podnesen
DocType: Homepage,Tag Line,Tag linija
DocType: Fee Component,Fee Component,Naknada Komponenta
apps/erpnext/erpnext/config/hr.py,Fleet Management,Mornarički menađer
apps/erpnext/erpnext/config/agriculture.py,Crops & Lands,Usjevi i zemljišta
DocType: Shift Type,Enable Exit Grace Period,Omogući izlazno milosno razdoblje
DocType: Cheque Print Template,Regular,redovan
DocType: Fertilizer,Density (if liquid),Gustoća (ako je tekućina)
apps/erpnext/erpnext/education/doctype/course/course.py,Total Weightage of all Assessment Criteria must be 100%,Ukupno weightage svih kriterija za ocjenjivanje mora biti 100%
DocType: Purchase Order Item,Last Purchase Rate,Zadnja kupovna cijena
DocType: GSTR 3B Report,August,kolovoz
DocType: Account,Asset,Imovina (Aktiva)
DocType: Quality Goal,Revised On,Revidirano dana
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock cannot exist for Item {0} since has variants,Stock ne može postojati točkom {0} jer ima varijante
DocType: Healthcare Practitioner,Mobile,Mobilni
DocType: Issue,Reset Service Level Agreement,Poništite ugovor o razini usluge
,Sales Person-wise Transaction Summary,Pregled prometa po prodavaču
DocType: Training Event,Contact Number,Kontakt broj
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} does not exist,Skladište {0} ne postoji
DocType: Cashier Closing,Custody,starateljstvo
DocType: Employee Tax Exemption Proof Submission Detail,Employee Tax Exemption Proof Submission Detail,Pojedinosti o podnošenju dokaza o izuzeću poreza za zaposlenike
DocType: Monthly Distribution,Monthly Distribution Percentages,Mjesečni postotci distribucije
apps/erpnext/erpnext/stock/doctype/batch/batch.py,The selected item cannot have Batch,Izabrani predmet ne može imati Hrpa
DocType: Delivery Note,% of materials delivered against this Delivery Note,% robe od ove otpremnice je isporučeno
DocType: Asset Maintenance Log,Has Certificate,Ima certifikat
DocType: Project,Customer Details,Korisnički podaci
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.js,Print IRS 1099 Forms,Ispiši obrasce IRS 1099
DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,Provjerite zahtijeva li Asset preventivno održavanje ili umjeravanje
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation cannot have more than 5 characters,Kratica tvrtke ne može imati više od 5 znakova
DocType: Employee,Reports to,Izvješća
,Unpaid Expense Claim,Neplaćeni Rashodi Zatraži
DocType: Payment Entry,Paid Amount,Plaćeni iznos
apps/erpnext/erpnext/utilities/user_progress.py,Explore Sales Cycle,Istražite prodajni ciklus
DocType: Assessment Plan,Supervisor,Nadzornik
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Retention Stock Entry,Zadržavanje dionice
,Available Stock for Packing Items,Raspoloživo stanje za pakirane proizvode
DocType: Item Variant,Item Variant,Stavka Variant
DocType: Employee Skill Map,Trainings,treninzi
,Work Order Stock Report,Izvješće o stanju na radnom mjestu
DocType: Purchase Receipt,Auto Repeat Detail,Automatski ponavljanje pojedinosti
DocType: Assessment Result Tool,Assessment Result Tool,Procjena Alat Rezultat
apps/erpnext/erpnext/education/doctype/instructor/instructor.js,As Supervisor,Kao supervizor
DocType: Leave Policy Detail,Leave Policy Detail,Ostavite detalje o politici
DocType: BOM Scrap Item,BOM Scrap Item,BOM otpaci predmeta
apps/erpnext/erpnext/accounts/page/pos/pos.js,Submitted orders can not be deleted,Dostavljeni nalozi se ne može izbrisati
DocType: Leave Control Panel,Department (optional),Odjel (izborno)
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 računa već u zaduženje, ne smiju postaviti 'ravnoteža se mora' kao 'kreditne'"
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.
				","Ako {0} {1} vrijedi predmet <b>{2}</b> , na njega će se primijeniti shema <b>{3}</b> ."
DocType: Customer Feedback,Quality Management,Upravljanje kvalitetom
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} has been disabled,Stavka {0} je onemogućen
DocType: Project,Total Billable Amount (via Timesheets),Ukupan iznos koji se naplaćuje (putem vremenskih brojeva)
DocType: Agriculture Task,Previous Business Day,Prethodni radni dan
DocType: Loan,Repay Fixed Amount per Period,Vratiti fiksni iznos po razdoblju
DocType: Employee,Health Insurance No,Zdravstveno osiguranje br
DocType: Employee Tax Exemption Proof Submission,Tax Exemption Proofs,Dokaz o oslobođenju poreza
apps/erpnext/erpnext/buying/utils.py,Please enter quantity for Item {0},Molimo unesite količinu za točku {0}
DocType: Quality Procedure,Processes,procesi
DocType: Shift Type,First Check-in and Last Check-out,Prva prijava i posljednja odjava
apps/erpnext/erpnext/regional/report/hsn_wise_summary_of_outward_supplies/hsn_wise_summary_of_outward_supplies.py,Total Taxable Amount,Ukupni iznos oporezive
DocType: Employee External Work History,Employee External Work History,Zaposlenik Vanjski Rad Povijest
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Job card {0} created,Izrađena je kartica za posao {0}
DocType: Opening Invoice Creation Tool,Purchase,Nabava
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Balance Qty,Bilanca kol
DocType: Pricing Rule,Conditions will be applied on all the selected items combined. ,Uvjeti će se primjenjivati na sve odabrane stavke zajedno.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Goals cannot be empty,Ciljevi ne može biti prazan
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js,Enrolling students,Upisuje studente
DocType: Item Group,Parent Item Group,Nadređena grupa proizvoda
DocType: Appointment Type,Appointment Type,Vrsta imenovanja
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,{0} for {1},{0} od {1}
DocType: Healthcare Settings,Valid number of days,Vrijedi broj dana
apps/erpnext/erpnext/setup/doctype/company/company.js,Cost Centers,Troška
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Restart Subscription,Ponovo pokreni pretplatu
DocType: Linked Plant Analysis,Linked Plant Analysis,Povezana analiza biljaka
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Transporter ID,ID transportera
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Value Proposition,Vrijednost propozicija
DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,Stopa po kojoj supplier valuta se pretvaraju u tvrtke bazne valute
DocType: Purchase Invoice Item,Service End Date,Datum završetka usluge
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,Row #{0}: Timings conflicts with row {1},Red # {0}: vremenu sukobi s redom {1}
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Dopusti stopu nulte procjene
DocType: Bank Guarantee,Receiving,Primanje
DocType: Training Event Employee,Invited,pozvan
apps/erpnext/erpnext/config/accounting.py,Setup Gateway accounts.,Postava Gateway račune.
apps/erpnext/erpnext/config/integrations.py,Connect your bank accounts to ERPNext,Povežite svoje bankovne račune s ERPNext-om
DocType: Employee,Employment Type,Zapošljavanje Tip
apps/erpnext/erpnext/config/projects.py,Make project from a template.,Napravite projekt iz predloška.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Fixed Assets,Dugotrajne imovine
DocType: Payment Entry,Set Exchange Gain / Loss,Postavite Exchange dobici / gubici
,GST Purchase Register,Registar kupnje GST-a
,Cash Flow,Protok novca
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%,Udio kombiniranog računa mora biti jednak 100%
DocType: Item Default,Default Expense Account,Zadani račun rashoda
DocType: GST Account,CGST Account,CGST račun
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Email ID,Student ID e-pošte
DocType: Employee,Notice (days),Obavijest (dani)
DocType: POS Closing Voucher Invoices,POS Closing Voucher Invoices,POS fakture zatvaranja bonova za POS
DocType: Tax Rule,Sales Tax Template,Porez Predložak
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Download JSON,Preuzmite JSON
DocType: Employee Benefit Application Detail,Pay Against Benefit Claim,Zahtjev za naknadu štete
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Update Cost Center Number,Ažurirajte broj mjesta troška
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select items to save the invoice,Odaberite stavke za spremanje račun
DocType: Employee,Encashment Date,Encashment Datum
DocType: Training Event,Internet,Internet
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Seller Information,Podaci o prodavaču
DocType: Special Test Template,Special Test Template,Posebni predložak testa
DocType: Account,Stock Adjustment,Stock Podešavanje
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,Default Activity Cost exists for Activity Type - {0},Zadana aktivnost Troškovi postoji Vrsta djelatnosti - {0}
DocType: Work Order,Planned Operating Cost,Planirani operativni trošak
DocType: Academic Term,Term Start Date,Pojam Datum početka
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Authentication Failed,Provjera autentičnosti nije uspjela
apps/erpnext/erpnext/config/accounting.py,List of all share transactions,Popis svih transakcija dionica
DocType: Supplier,Is Transporter,Je transporter
DocType: Shopify Settings,Import Sales Invoice from Shopify if Payment is marked,Uvozite prodajnu fakturu od tvrtke Shopify ako je Plaćanje označeno
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp Count,Count Count
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Both Trial Period Start Date and Trial Period End Date must be set,Moraju biti postavljeni datum početka datuma probnog razdoblja i datum završetka probnog razdoblja
apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py,Average Rate,Prosječna stopa
apps/erpnext/erpnext/controllers/accounts_controller.py,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Ukupni iznos plaćanja u rasporedu plaćanja mora biti jednak Grand / Rounded Total
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot have Valuation Rate",&quot;Stavka opskrbljena kupcem&quot; ne može imati stopu vrednovanja
DocType: Subscription Plan Detail,Plan,Plan
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Bank Statement balance as per General Ledger,Banka Izjava stanje po glavnom knjigom
DocType: Job Applicant,Applicant Name,Podnositelj zahtjeva Ime
DocType: Authorization Rule,Customer / Item Name,Kupac / Stavka Ime
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 ** Opcije ** u drugom ** ** točke. To je korisno ako vezanje određene artikle ** ** u paketu i održavanje zalihe zapakiranom ** Opcije ** a ne zbroj ** ** stavke. Paket ** ** Stavka će imati &quot;Je kataloški Stavka&quot; kao &quot;ne&quot; i &quot;Je li prodaja predmeta&quot; kao &quot;Da&quot;. Na primjer: Ako se prodaje Prijenosna računala i ruksacima odvojeno i imaju posebnu cijenu ako kupac kupuje i onda laptop + ruksak će biti novi bala proizvoda predmeta. Napomena: BOM = Bill materijala
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Serial No is mandatory for Item {0},Serijski Nema je obvezna za točke {0}
DocType: Website Attribute,Attribute,Atribut
DocType: Staffing Plan Detail,Current Count,Tekući broj
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Please specify from/to range,Navedite od / do rasponu
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Opening {0} Invoice created,Otvaranje {0} fakture je izrađeno
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,Stopa predmeta vrednovanja preračunava obzirom sletio troškova iznos vaučera
apps/erpnext/erpnext/config/selling.py,Default settings for selling transactions.,Zadane postavke za prodajne transakcije.
DocType: Guardian,Guardian Of ,staratelj
DocType: Grading Scale Interval,Threshold,Prag
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Filter Employees By (Optional),Filtriraj zaposlenike prema (neobavezno)
DocType: BOM Update Tool,Current BOM,Trenutni BOM
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Balance (Dr - Cr),Stanje (Dr - Cr)
DocType: Pick List,Qty of Finished Goods Item,Količina proizvoda gotove robe
apps/erpnext/erpnext/public/js/utils.js,Add Serial No,Dodaj serijski broj
DocType: Work Order Item,Available Qty at Source Warehouse,Dostupni broj u Izvornoj skladištu
apps/erpnext/erpnext/config/support.py,Warranty,garancija
DocType: Purchase Invoice,Debit Note Issued,Terećenju 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,Filtar na temelju Centra za naplatu primjenjuje se samo ako je Budget Control odabran kao Centar za trošak
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,"Search by item code, serial number, batch no or barcode","Pretraživanje po kodu stavke, serijskog broja, šarže ili crtičnog koda"
DocType: Work Order,Warehouses,Skladišta
DocType: Shift Type,Last Sync of Checkin,Zadnja sinkronizacija Checkin-a
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Add a new address,Dodaj novu adresu
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,{0} asset cannot be transferred,{0} imovina se ne može se prenijeti
DocType: Hotel Room Pricing,Hotel Room Pricing,Cijene soba hotela
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py,"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Ne mogu se označiti prazni bolesnički zapis, postoje neplaćene fakture {0}"
DocType: Subscription,Days Until Due,Dani do dospijeća
apps/erpnext/erpnext/stock/doctype/item/item.js,This Item is a Variant of {0} (Template).,Ova stavka je varijanta od {0} (Predložak).
DocType: Workstation,per hour,na sat
DocType: Blanket Order,Purchasing,Nabava
DocType: Announcement,Announcement,Obavijest
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Customer LPO,Korisnički LPO
DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Za grupu studenata temeljenih na bazi, studentska će se serijska cjelina validirati za svakog studenta iz prijave za program."
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Skladište se ne može izbrisati dok postoje upisi u glavnu knjigu za ovo skladište.
apps/erpnext/erpnext/public/js/setup_wizard.js,Distribution,Distribucija
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;,"Status zaposlenika ne može se postaviti na &quot;Lijevo&quot;, jer sljedeći zaposlenici trenutno prijavljuju ovog zaposlenika:"
DocType: Journal Entry Account,Loan,Zajam
DocType: Expense Claim Advance,Expense Claim Advance,Predujam za troškove
DocType: Lab Test,Report Preference,Prednost izvješća
apps/erpnext/erpnext/config/non_profit.py,Volunteer information.,Dobrovoljne informacije.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Project Manager,Voditelj projekta
,Quoted Item Comparison,Citirano predmeta za usporedbu
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Overlap in scoring between {0} and {1},Preklapanje u bodovanju između {0} i {1}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Dispatch,Otpremanje
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Max discount allowed for item: {0} is {1}%,Maksimalni dopušteni popust za proizvod: {0} je {1}%
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Net Asset value as on,Neto imovina kao i na
DocType: Crop,Produce,proizvoditi
DocType: Hotel Settings,Default Taxes and Charges,Zadani poreza i naknada
DocType: Account,Receivable,potraživanja
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Red # {0}: Nije dopušteno mijenjati dobavljača kao narudžbenice već postoji
DocType: Stock Entry,Material Consumption for Manufacture,Potrošnja materijala za proizvodnju
DocType: Item Alternative,Alternative Item Code,Kôd alternativne stavke
DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,Uloga koja je dopušteno podnijeti transakcije koje premašuju kreditnih ograničenja postavljena.
DocType: Production Plan,Select Items to Manufacture,Odaberite stavke za proizvodnju
DocType: Delivery Stop,Delivery Stop,Dostava zaustavljanja
apps/erpnext/erpnext/accounts/page/pos/pos.js,"Master data syncing, it might take some time","Master Data sinkronizacije, to bi moglo potrajati neko vrijeme"
DocType: Material Request Plan Item,Material Issue,Materijal Issue
DocType: Employee Education,Qualification,Kvalifikacija
DocType: Item Price,Item Price,Cijena proizvoda
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Soap & Detergent,Sapun i deterdžent
DocType: BOM,Show Items,Prikaži stavke
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.py,Duplicate Tax Declaration of {0} for period {1},Umnožavanje porezne deklaracije od {0} za razdoblje {1}
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py,From Time cannot be greater than To Time.,S vremena ne može biti veća od na vrijeme.
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Do you want to notify all the customers by email?,Želite li obavijestiti sve korisnike putem e-pošte?
DocType: Subscription Plan,Billing Interval,Interval naplate
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Motion Picture & Video,Pokretna slika & video
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js,Ordered,Naručeno
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Resume,rezime
DocType: Salary Detail,Component,sastavni dio
DocType: Video,YouTube,YouTube
apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py,Row {0}: {1} must be greater than 0,Redak {0}: {1} mora biti veći od 0
DocType: Assessment Criteria,Assessment Criteria Group,Kriteriji za ocjenu Grupa
DocType: Healthcare Settings,Patient Name By,Ime pacijenta po
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Accrual Journal Entry for salaries from {0} to {1},Obračunski dnevnik za plaće od {0} do {1}
DocType: Sales Invoice Item,Enable Deferred Revenue,Omogućivanje odgođenog prihoda
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Opening Accumulated Depreciation must be less than equal to {0},Otvaranje za akumuliranu amortizaciju mora biti manja od jednaka {0}
DocType: Warehouse,Warehouse Name,Naziv skladišta
DocType: Naming Series,Select Transaction,Odaberite transakciju
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Unesite Odobravanje ulogu ili Odobravanje korisnike
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Ugovor o razini usluge s tipom entiteta {0} i entitetom {1} već postoji.
DocType: Journal Entry,Write Off Entry,Otpis unos
DocType: BOM,Rate Of Materials Based On,Stopa materijali na temelju
DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Ako je omogućeno, polje Akademsko razdoblje bit će obvezno u Alatu za upis na program."
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Values of exempt, nil rated and non-GST inward supplies","Vrijednosti izuzetih, nultih bodova i unutarnjih isporuka bez GST-a"
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Uncheck all,Poništite sve
DocType: Purchase Taxes and Charges,On Item Quantity,Na Količina predmeta
DocType: POS Profile,Terms and Conditions,Odredbe i uvjeti
DocType: Asset,Booked Fixed Asset,Rezervirano fiksno sredstvo
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,To Date should be within the Fiscal Year. Assuming To Date = {0},Za datum mora biti unutar fiskalne godine. Pod pretpostavkom da bi datum = {0}
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Ovdje možete održavati visina, težina, alergije, medicinske brige itd."
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Creating Accounts...,Stvaranje računa ...
DocType: Leave Block List,Applies to Company,Odnosi se na Društvo
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Cannot cancel because submitted Stock Entry {0} exists,"Ne može se otkazati, jer skladišni ulaz {0} postoji"
DocType: Loan,Disbursement Date,datum isplate
DocType: Service Level Agreement,Agreement Details,Pojedinosti o ugovoru
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Start Date of Agreement can't be greater than or equal to End Date.,Datum početka ugovora ne može biti veći ili jednak Krajnjem datumu.
DocType: BOM Update Tool,Update latest price in all BOMs,Ažuriranje najnovije cijene u svim BOM-ovima
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Done,Pospremljen
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Medical Record,Medicinski zapis
DocType: Vehicle,Vehicle,Vozilo
DocType: Purchase Invoice,In Words,Riječima
apps/erpnext/erpnext/hr/doctype/leave_ledger_entry/leave_ledger_entry.py,To date needs to be before from date,Do danas treba biti prije od datuma
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the name of the bank or lending institution before submittting.,Unesite naziv banke ili institucije posudbe prije slanja.
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py,{0} must be submitted,{0} mora biti poslano
DocType: POS Profile,Item Groups,stavka Grupe
DocType: Company,Standard Working Hours,Standardno radno vrijeme
DocType: Sales Order Item,For Production,Za proizvodnju
DocType: Payment Request,payment_url,payment_url
DocType: Exchange Rate Revaluation Account,Balance In Account Currency,Saldo u 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,Dodajte Privremeni račun otvaranja u računskom planu
DocType: Customer,Customer Primary Contact,Primarni kontakt korisnika
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp/Lead %,Opp / Lead%
DocType: Bank Guarantee,Bank Account Info,Podaci o bankovnom računu
DocType: Bank Guarantee,Bank Guarantee Type,Vrsta bankarskog jamstva
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() failed for valid IBAN {},BankAccount.validate_iban () nije uspio za važeći IBAN {}
DocType: Payment Schedule,Invoice Portion,Dio dostavnice
,Asset Depreciations and Balances,Imovine deprecijacije i sredstva
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} transferred from {2} to {3},Iznos {0} {1} prenesen iz {2} u {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} nema raspored zdravstvenih radnika. Dodajte ga u majstor zdravstvene prakse
DocType: Sales Invoice,Get Advances Received,Kreiraj avansno primanje
DocType: Email Digest,Add/Remove Recipients,Dodaj / ukloni primatelja
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js,"To set this Fiscal Year as Default, click on 'Set as Default'","Za postavljanje ove fiskalne godine kao zadano , kliknite na "" Set as Default '"
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Amount of TDS Deducted,Iznos TDS Deducted
DocType: Production Plan,Include Subcontracted Items,Uključi podugovarane predmete
apps/erpnext/erpnext/projects/doctype/project/project.py,Join,Pridružiti
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Shortage Qty,Nedostatak Kom
DocType: Purchase Invoice,Input Service Distributor,Distributer ulaznih usluga
apps/erpnext/erpnext/stock/doctype/item/item.py,Item variant {0} exists with same attributes,Inačica Stavka {0} postoji s istim atributima
DocType: Loan,Repay from Salary,Vrati iz plaće
DocType: Exotel Settings,API Token,API token
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Requesting payment against {0} {1} for amount {2},Zahtjev za isplatu od {0} {1} za iznos {2}
DocType: Additional Salary,Salary Slip,Plaća proklizavanja
apps/erpnext/erpnext/support/doctype/issue/issue.py,Allow Resetting Service Level Agreement from Support Settings.,Dopusti resetiranje sporazuma o razini usluge iz postavki podrške.
DocType: Lead,Lost Quotation,Izgubljena Ponuda
apps/erpnext/erpnext/utilities/user_progress.py,Student Batches,Studentske serije
DocType: Pricing Rule,Margin Rate or Amount,Margina brzine ili količine
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,'To Date' is required,'Do datuma ' je potrebno
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Actual Qty: Quantity available in the warehouse.,Stvarna kol: količina dostupna na skladištu.
DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Izradi pakiranje gaćice za pakete biti isporučena. Koristi se za obavijesti paket broj, sadržaj paketa i njegovu težinu."
DocType: Sales Invoice Item,Sales Order Item,Naručeni proizvod - prodaja
DocType: Salary Slip,Payment Days,Plaćanja Dana
DocType: Stock Settings,Convert Item Description to Clean HTML,Pretvori opis stavke u čisti HTML
DocType: Patient,Dormant,latentan
DocType: Payroll Entry,Deduct Tax For Unclaimed Employee Benefits,Odbitak poreza za neplaćene naknade zaposlenicima
DocType: Salary Slip,Total Interest Amount,Ukupni iznos kamate
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with child nodes cannot be converted to ledger,Skladišta s djetetom čvorovi se ne može pretvoriti u glavnoj knjizi
DocType: BOM,Manage cost of operations,Uredi troškove poslovanja
DocType: Accounts Settings,Stale Days,Dani tišine
DocType: Travel Itinerary,Arrival Datetime,Datum dolaska
DocType: Tax Rule,Billing Zipcode,Poštanski broj za slanje računa
DocType: Attendance,HR-ATT-.YYYY.-,HR-ATT-.YYYY.-
DocType: Crop,Row Spacing UOM,Raspored razmaka UOM
DocType: Assessment Result Detail,Assessment Result Detail,Procjena Detalj Rezultat
DocType: Employee Education,Employee Education,Obrazovanje zaposlenika
DocType: Service Day,Workday,Radni dan
apps/erpnext/erpnext/setup/doctype/terms_and_conditions/terms_and_conditions.py,At least one of the Applicable Modules should be selected,Treba odabrati barem jedan od primjenjivih modula
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate item group found in the item group table,Dvostruki stavke skupina nalaze se u tablici stavke grupe
apps/erpnext/erpnext/config/quality_management.py,Tree of Quality Procedures.,Stablo postupaka kvalitete.
apps/erpnext/erpnext/public/js/controllers/transaction.js,It is needed to fetch Item Details.,To je potrebno kako bi dohvatili Stavka Pojedinosti.
DocType: Fertilizer,Fertilizer Name,Ime gnojiva
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,Serijski Ne {0} već je primila
,Requested Items To Be Transferred,Traženi proizvodi spremni za transfer
DocType: Expense Claim,Vehicle Log,vozila Prijava
DocType: Sales Invoice,Is Discounted,Se snižava
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on Actual,Akcija ako je akumulirani mjesečni proračun premašen na stvarnu
DocType: Salary Component,Create Separate Payment Entry Against Benefit Claim,Stvaranje odvojene isplate od potraživanja od koristi
DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),Prisutnost povišene temperature (temperatura&gt; 38.5 ° C / 101.3 ° F ili trajanje temperature&gt; 38 ° C / 100.4 ° F)
DocType: Customer,Sales Team Details,Detalji prodnog tima
apps/erpnext/erpnext/accounts/page/pos/pos.js,Delete permanently?,Brisanje trajno?
DocType: Expense Claim,Total Claimed Amount,Ukupno Zatražio Iznos
apps/erpnext/erpnext/config/crm.py,Potential opportunities for selling.,Potencijalne prilike za prodaju.
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,{} is an invalid Attendance Status.,{} je nevažeći status posjećenosti.
DocType: Shareholder,Folio no.,Folio br.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,Invalid {0},Pogrešna {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Sick Leave,bolovanje
DocType: Email Digest,Email Digest,E-pošta
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","Kako je projicirana količina sirovina veća od potrebne količine, nema potrebe stvarati materijalni zahtjev. Ipak, ako želite uputiti materijalni zahtjev, molimo uključite potvrdni okvir <b>Zanemari postojeću projiciranu količinu</b>"
DocType: Delivery Note,Billing Address Name,Naziv adrese za naplatu
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Department Stores,Robne kuće
,Item Delivery Date,Datum isporuke stavke
DocType: Selling Settings,Sales Update Frequency,Ažuriranje ažuriranja prodaje
DocType: Production Plan,Material Requested,Traženi materijal
DocType: Warehouse,PIN,PIN
DocType: Bin,Reserved Qty for sub contract,Rezervirani kvota za podugovor
DocType: Patient Service Unit,Patinet Service Unit,Patinet servisna jedinica
DocType: Sales Invoice,Base Change Amount (Company Currency),Baza Promjena Iznos (Društvo valuta)
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,No accounting entries for the following warehouses,Nema računovodstvenih unosa za ova skladišta
apps/erpnext/erpnext/shopping_cart/cart.py,Only {0} in stock for item {1},Samo {0} na zalihama za stavku {1}
DocType: Account,Chargeable,Naplativ
DocType: Company,Change Abbreviation,Promijeni naziv
DocType: Contract,Fulfilment Details,Pojedinosti ispunjenja
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py,Pay {0} {1},Plaćajte {0} {1}
DocType: Employee Onboarding,Activities,djelatnost
DocType: Expense Claim Detail,Expense Date,Rashodi Datum
DocType: Item,No of Months,Broj mjeseci
DocType: Item,Max Discount (%),Maksimalni popust (%)
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,Credit Days cannot be a negative number,Dani kredita ne može biti negativan broj
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Upload a statement,Prenesite izjavu
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Report this item,Prijavite ovu stavku
DocType: Purchase Invoice Item,Service Stop Date,Datum zaustavljanja usluge
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Last Order Amount,Iznos zadnje narudžbe
DocType: Cash Flow Mapper,e.g Adjustments for:,npr. prilagodbe 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} zadržati uzorak temelji se na seriji, molimo Vas da provjerite je li šifra br. Zadržati uzorak stavke"
DocType: Task,Is Milestone,Je li Milestone
DocType: Certification Application,Yet to appear,Ipak se pojavi
DocType: Delivery Stop,Email Sent To,Mail poslan
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Salary Structure not found for employee {0} and date {1},Nije pronađena struktura plaća za zaposlenika {0} i datum {1}
DocType: Job Card Item,Job Card Item,Radna mjesta za posao
DocType: Accounts Settings,Allow Cost Center In Entry of Balance Sheet Account,Dozvoli centar za trošak unosom bilance stanja računa
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge with Existing Account,Spajanje s postojećim računom
DocType: Budget,Warn,Upozoriti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Sve su stavke već prenesene za ovu radnu narudžbu.
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Sve ostale primjedbe, značajan napor da bi trebao ići u evidenciji."
DocType: Asset Maintenance,Manufacturing User,Proizvodni korisnik
DocType: Purchase Invoice,Raw Materials Supplied,Sirovine nabavlja
DocType: Subscription Plan,Payment Plan,Plan plaćanja
DocType: Bank Transaction,Series,Serija
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Currency of the price list {0} must be {1} or {2},Valuta cjenika {0} mora biti {1} ili {2}
apps/erpnext/erpnext/config/accounting.py,Subscription Management,Upravljanje pretplatama
DocType: Appraisal,Appraisal Template,Procjena Predložak
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Pin Code,Za kodiranje koda
DocType: Soil Texture,Ternary Plot,Ternarna ploča
DocType: Amazon MWS Settings,Check this to enable a scheduled Daily synchronization routine via scheduler,Označite ovu opciju kako biste omogućili planiranu rutinu Dnevne sinkronizacije putem rasporeda
DocType: Item Group,Item Classification,Klasifikacija predmeta
apps/erpnext/erpnext/templates/pages/home.html,Publications,publikacije
DocType: Driver,License Number,Broj dozvole
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Business Development Manager,Voditelj razvoja poslovanja
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Održavanje Posjetite Namjena
DocType: Stock Entry,Stock Entry Type,Vrsta unosa dionica
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Invoice Patient Registration,Registracija pacijenta računa
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,Fiskalnoj godini
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js,View Leads,Pogledaj vodi
DocType: Program Enrollment Tool,New Program,Novi program
DocType: Item Attribute Value,Attribute Value,Vrijednost atributa
DocType: POS Closing Voucher Details,Expected Amount,Očekivani iznos
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Multiple,Izradi više
,Itemwise Recommended Reorder Level,Itemwise - preporučena razina ponovne narudžbe
apps/erpnext/erpnext/hr/utils.py,Employee {0} of grade {1} have no default leave policy,Zaposlenik {0} razreda {1} nema zadanu politiku odlaska
DocType: Salary Detail,Salary Detail,Plaća Detalj
DocType: Email Digest,New Purchase Invoice,Nova faktura za kupnju
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select {0} first,Odaberite {0} Prvi
apps/erpnext/erpnext/public/js/hub/marketplace.js,Added {0} users,Dodano je {0} korisnika
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Less Than Amount,Manje od iznosa
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","U slučaju višerazinskog programa, Kupci će biti automatski dodijeljeni odgovarajućem stupcu po njihovu potrošenom"
DocType: Appointment Type,Physician,Liječnik
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Batch {0} of Item {1} has expired.,Hrpa {0} od {1} Stavka je istekla.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py,Consultations,konzultacije
apps/erpnext/erpnext/manufacturing/report/bom_variance_report/bom_variance_report.py,Finished Good,Izvrsno 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.","Stavka Cijena pojavljuje se više puta na temelju Cjenika, Dobavljača / Kupca, Valute, Stavke, UOM, Qta i datuma."
DocType: Sales Invoice,Commission,provizija
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 može biti veći od planirane količine ({2}) u Radnoj nalogu {3}
DocType: Certification Application,Name of Applicant,Naziv podnositelja zahtjeva
apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Vrijeme list za proizvodnju.
apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,suma stavke
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.,Nije moguće mijenjati svojstva varijanti nakon transakcije zaliha. Morat ćete napraviti novu stavku da to učinite.
apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA mandat
DocType: Healthcare Practitioner,Charges,Naknade
DocType: Production Plan,Get Items For Work Order,Preuzmite stavke za radni nalog
DocType: Salary Detail,Default Amount,Zadani iznos
DocType: Lab Test Template,Descriptive,Opisni
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Warehouse not found in the system,Skladište nije pronađeno u sustavu
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,This Month's Summary,Ovomjesečnom Sažetak
DocType: Quality Inspection Reading,Quality Inspection Reading,Inspekcija kvalitete - čitanje
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py,`Freeze Stocks Older Than` should be smaller than %d days.,` Zamrzni Zalihe starije od ` bi trebao biti manji od % d dana .
DocType: Tax Rule,Purchase Tax Template,Predložak poreza pri nabavi
apps/erpnext/erpnext/utilities/user_progress.py,Set a sales goal you'd like to achieve for your company.,Postavite cilj prodaje koji biste željeli postići svojoj tvrtki.
DocType: Quality Goal,Revision,Revizija
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Healthcare Services,Zdravstvene usluge
,Project wise Stock Tracking,Projekt mudar Stock Praćenje
DocType: GST HSN Code,Regional,Regionalni
apps/erpnext/erpnext/config/healthcare.py,Laboratory,Laboratorija
DocType: UOM Category,UOM Category,Kategorija UOM
DocType: Clinical Procedure Item,Actual Qty (at source/target),Stvarni Kol (na izvoru / ciljne)
DocType: Item Customer Detail,Ref Code,Ref. Šifra
DocType: Accounts Settings,Address used to determine Tax Category in transactions.,Adresa koja se koristi za određivanje porezne kategorije u transakcijama.
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Customer Group is Required in POS Profile,Grupa korisnika je obavezna u POS profilu
DocType: HR Settings,Payroll Settings,Postavke plaće
apps/erpnext/erpnext/config/accounting.py,Match non-linked Invoices and Payments.,Klađenje na ne-povezane faktura i plaćanja.
DocType: POS Settings,POS Settings,POS Postavke
apps/erpnext/erpnext/templates/pages/cart.html,Place Order,Naručiti
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.js,Create Invoice,Stvorite fakturu
DocType: Email Digest,New Purchase Orders,Nova narudžba kupnje
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Root cannot have a parent cost center,Korijen ne mogu imati središte troškova roditelj
DocType: POS Closing Voucher,Expense Details,Rashodi Detalji
apps/erpnext/erpnext/public/js/stock_analytics.js,Select Brand...,Odaberite brand ...
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""",Redak polja filtra # {0}: Naziv polja <b>{1}</b> mora biti tipa &quot;Link&quot; ili &quot;Table MultiSelect&quot;
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Accumulated Depreciation as on,Akumulirana amortizacija na
DocType: Employee Tax Exemption Category,Employee Tax Exemption Category,Kategorija oslobođenja od plaćanja poreza za zaposlenike
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Amount should not be less than zero.,Iznos ne smije biti manji od nule.
DocType: Sales Invoice,C-Form Applicable,Primjenjivi C-obrazac
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Operation Time must be greater than 0 for Operation {0},Operacija vrijeme mora biti veći od 0 za rad {0}
DocType: Support Search Source,Post Route String,Obaviti redak puta
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Warehouse is mandatory,Skladište je obavezno
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to create website,Izrada web mjesta nije uspjela
DocType: Soil Analysis,Mg/K,Mg / K
DocType: UOM Conversion Detail,UOM Conversion Detail,UOM pretvorbe Detalj
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Admission and Enrollment,Upis i upis
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Retention Stock Entry already created or Sample Quantity not provided,Dionice za zadržavanje koji su već stvoreni ili Uzorak Količina nije predviđen
DocType: Program,Program Abbreviation,naziv programa
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Voucher (Consolidated),Grupiranje po vaučerima (konsolidirani)
DocType: HR Settings,Encrypt Salary Slips in Emails,Šifrirajte kamate na plaće u e-porukama
DocType: Question,Multiple Correct Answer,Više točnih odgovora
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Charges are updated in Purchase Receipt against each item,Optužbe su ažurirani u KUPNJE protiv svake stavke
DocType: Warranty Claim,Resolved By,Riješen Do
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Discharge,Raspored otpuštanja
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Cheques and Deposits incorrectly cleared,Čekovi i depozita pogrešno izbrisani
DocType: Homepage Section Card,Homepage Section Card,Kartica odjela početne stranice
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: You can not assign itself as parent account,Račun {0}: Ne možeš ga dodijeliti kao nadređeni račun
DocType: Purchase Invoice Item,Price List Rate,Stopa cjenika
apps/erpnext/erpnext/utilities/activation.py,Create customer quotes,Stvaranje kupaca citati
apps/erpnext/erpnext/public/js/controllers/transaction.js,Service Stop Date cannot be after Service End Date,Zaustavni datum usluge ne može biti nakon datuma završetka usluge
DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Pokaži ""raspoloživo"" ili ""nije raspoloživo"" na temelju trentnog stanja na skladištu."
apps/erpnext/erpnext/config/manufacturing.py,Bill of Materials (BOM),Sastavnice (BOM)
DocType: Item,Average time taken by the supplier to deliver,Prosječno vrijeme potrebno od strane dobavljača za isporuku
DocType: Travel Itinerary,Check-in Date,Datum prijave
DocType: Sample Collection,Collected By,Prikupljeno od strane
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js,Assessment Result,Rezultat Procjena
DocType: Hotel Room Package,Hotel Room Package,Soba paket hotela
DocType: Employee Transfer,Employee Transfer,Prijenos zaposlenika
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Hours,Sati
DocType: Project,Expected Start Date,Očekivani datum početka
DocType: Purchase Invoice,04-Correction in Invoice,04-Ispravak u fakturi
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order already created for all items with BOM,Radni nalog već stvoren za sve stavke s BOM-om
DocType: Bank Account,Party Details,Detalji stranke
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant Details Report,Izvješće o pojedinostima o varijacijama
DocType: Setup Progress Action,Setup Progress Action,Postavljanje napretka
DocType: Course Activity,Video,Video
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Price List,Cjenik kupnje
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Remove item if charges is not applicable to that item,Uklanjanje stavke ako troškovi se ne odnosi na tu stavku
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Cancel Subscription,Odustani od pretplate
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Please select Maintenance Status as Completed or remove Completion Date,Odaberite Status održavanja kao Dovršen ili uklonite Datum dovršetka
DocType: Supplier,Default Payment Terms Template,Predložak predloženih uvjeta plaćanja
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Transaction currency must be same as Payment Gateway currency,Transakcija valute mora biti isti kao i Payment Gateway valute
DocType: Payment Entry,Receive,Primite
DocType: Employee Benefit Application Detail,Earning Component,Komponenta zarade
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Items and UOMs,Obrada predmeta i UOM-ova
apps/erpnext/erpnext/regional/italy/utils.py,Please set either the Tax ID or Fiscal Code on Company '%s',Molimo vas da unesete ili porezni broj ili fiskalni kod tvrtke &#39;% s&#39;
apps/erpnext/erpnext/templates/pages/rfq.html,Quotations: ,citati:
DocType: Contract,Partially Fulfilled,Djelomično ispunjeno
DocType: Maintenance Visit,Fully Completed,Potpuno Završeni
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,"Special Characters except ""-"", ""#"", ""."", ""/"", ""{"" and ""}"" not allowed in naming series","Posebni znakovi osim &quot;-&quot;, &quot;#&quot;, &quot;.&quot;, &quot;/&quot;, &quot;{&quot; I &quot;}&quot; nisu dopušteni u imenovanju serija"
DocType: Purchase Invoice Item,Is nil rated or exempted,Nema ocjene ili je izuzetan
DocType: Employee,Educational Qualification,Obrazovne kvalifikacije
DocType: Workstation,Operating Costs,Operativni troškovi
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 dolazak na temelju &quot;Checkinge Employee Checkin&quot; za zaposlenike koji su dodijeljeni ovoj smjeni.
DocType: Asset,Disposal Date,Datum Odlaganje
DocType: Service Level,Response and Resoution Time,Vrijeme reakcije i odziva
DocType: Employee Leave Approver,Employee Leave Approver,Zaposlenik dopust Odobritelj
apps/erpnext/erpnext/stock/doctype/item/item.py,Row {0}: An Reorder entry already exists for this warehouse {1},Red {0}: Ulazak redoslijeda već postoji za to skladište {1}
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.js,Please enter the designation,Unesite oznaku
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py,"Cannot declare as lost, because Quotation has been made.","Ne može se proglasiti izgubljenim, jer je ponuda napravljena."
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Items for Raw Material Request,Predmeti za zahtjev za sirovinom
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,CWIP Account,CWIP račun
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Feedback,Povratne informacije trening
apps/erpnext/erpnext/config/accounting.py,Tax Withholding rates to be applied on transactions.,Stope zadržavanja poreza koje će se primjenjivati na transakcije.
DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Kriteriji ocjenjivanja dobavljača
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select Start Date and End Date for Item {0},Molimo odaberite datum početka i datum završetka za točke {0}
DocType: Maintenance Schedule,MAT-MSH-.YYYY.-,MAT-MSH-.YYYY.-
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Course is mandatory in row {0},Tečaj je obavezan u redu {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 može biti veći od Do danas
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,To date cannot be before from date,Do danas ne može biti prije od datuma
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non GST Inward Supplies,Non GST ulazne potrepštine
DocType: Employee Group Table,Employee Group Table,Tablica grupa zaposlenih
DocType: Packed Item,Prevdoc DocType,Prevdoc DOCTYPE
DocType: Cash Flow Mapper,Section Footer,Podnožje podatka
apps/erpnext/erpnext/stock/doctype/item/item.js,Add / Edit Prices,Dodaj / Uredi cijene
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Employee Promotion cannot be submitted before Promotion Date ,Promocija zaposlenika ne može se poslati prije datuma promocije
DocType: Batch,Parent Batch,Roditeljska šarža
DocType: Cheque Print Template,Cheque Print Template,Ček Predložak Ispis
DocType: Salary Component,Is Flexible Benefit,Je fleksibilna korist
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Chart of Cost Centers,Grafikon troškovnih centara
DocType: Subscription Settings,Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,Broj dana nakon datuma fakture protekao je prije otkazivanja pretplate ili označavanja pretplate kao neplaćen
DocType: Clinical Procedure Template,Sample Collection,Prikupljanje uzoraka
,Requested Items To Be Ordered,Traženi Proizvodi se mogu naručiti
DocType: Price List,Price List Name,Naziv cjenika
DocType: Delivery Stop,Dispatch Information,Podaci o otpremi
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill JSON can only be generated from submitted document,e-Way Bill JSON može se generirati samo iz poslanog dokumenta
DocType: Blanket Order,Manufacturing,Proizvodnja
,Ordered Items To Be Delivered,Naručeni proizvodi za dostavu
DocType: Account,Income,Prihod
DocType: Industry Type,Industry Type,Industrija Tip
apps/erpnext/erpnext/templates/includes/cart.js,Something went wrong!,Nešto je pošlo po krivu!
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Warning: Leave application contains following block dates,Upozorenje: Ostavite program sadrži sljedeće blok datume
DocType: Bank Statement Settings,Transaction Data Mapping,Mapping podataka transakcija
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Sales Invoice {0} has already been submitted,Prodajni računi {0} su već potvrđeni
DocType: Salary Component,Is Tax Applicable,Je li primjenjivo porez
DocType: Supplier Scorecard Scoring Criteria,Score,Postići
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} does not exist,Fiskalna godina {0} ne postoji
DocType: Asset Maintenance Log,Completion Date,Završetak Datum
DocType: Purchase Invoice Item,Amount (Company Currency),Iznos (valuta tvrtke)
DocType: Program,Is Featured,Je istaknuto
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Fetching...,Preuzimanje u tijeku ...
DocType: Agriculture Analysis Criteria,Agriculture User,Korisnik poljoprivrede
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Valid till date cannot be before transaction date,Vrijednost do datuma ne može biti prije datuma 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} jedinica {1} potrebna u {2} na {3} {4} od {5} za dovršetak ovu transakciju.
DocType: Fee Schedule,Student Category,Studentski Kategorija
DocType: Announcement,Student,Student
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 za početak postupka nije dostupna u skladištu. Želite li snimiti prijenos dionica?
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,New {0} pricing rules are created,Stvorena su nova {0} pravila o cijenama
DocType: Shipping Rule,Shipping Rule Type,Pravilo vrste isporuke
apps/erpnext/erpnext/utilities/user_progress.py,Go to Rooms,Idite na sobe
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,"Company, Payment Account, From Date and To Date is mandatory","Tvrtka, račun za plaćanje, od datuma i do datuma je obavezan"
DocType: Company,Budget Detail,Detalji proračuna
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Please enter message before sending,Unesite poruku prije slanja
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Setting up company,Osnivanje tvrtke
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Of the supplies shown in 3.1 (a) above, details of inter-State supplies made to unregisterd
	persons, composition taxable persons and UIN holders","Od isporuka prikazanih u točki 3.1 (a), detalji međudržavnih isporuka neregistriranim osobama, poreznim obveznicima sastavnicama i vlasnicima UIN-a"
DocType: Education Settings,Enable LMS,Omogući LMS
DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUPLICATE ZA DOBAVLJAČ
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Please save the report again to rebuild or update,Spremite izvješće ponovo da biste ga ponovo izgradili ili ažurirali
DocType: Service Level Agreement,Response and Resolution Time,Vrijeme odziva i rješavanja
DocType: Asset,Custodian,staratelj
apps/erpnext/erpnext/config/retail.py,Point-of-Sale Profile,Point-of-prodaju Profil
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py,{0} should be a value between 0 and 100,{0} mora biti vrijednost između 0 i 100
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Payment of {0} from {1} to {2},Plaćanje {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),Unutarnje zalihe podložne povratnom naboju (osim 1 i 2 gore)
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount(Company Currency),Iznos narudžbe (valuta tvrtke)
DocType: Chart of Accounts Importer,Import Chart of Accounts from a csv file,Uvezi račun s CSV datoteke
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Unsecured Loans,unsecured krediti
DocType: Cost Center,Cost Center Name,Troška Name
DocType: Student,B+,B +
DocType: HR Settings,Max working hours against Timesheet,Max radnog vremena protiv timesheet
DocType: Shift Type,Strictly based on Log Type in Employee Checkin,Strogo na temelju vrste dnevnika u Checkin Employee
DocType: Maintenance Schedule Detail,Scheduled Date,Planirano Datum
DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Poruka veća od 160 karaktera bit će izdjeljena u više poruka
DocType: Purchase Receipt Item,Received and Accepted,Primljeni i prihvaćeni
,GST Itemised Sales Register,GST označeni prodajni registar
DocType: Staffing Plan,Staffing Plan Details,Detalji o planu osoblja
DocType: Soil Texture,Silt Loam,Silt Loam
,Serial No Service Contract Expiry,Istek ugovora za serijski broj usluge
DocType: Employee Health Insurance,Employee Health Insurance,Zdravstveno osiguranje zaposlenika
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,You cannot credit and debit same account at the same time,Ne možete istovremeno kreditirati i debitirati isti račun
DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Pulsni broj odraslih je bilo gdje između 50 i 80 otkucaja u minuti.
DocType: Naming Series,Help HTML,HTML pomoć
DocType: Student Group Creation Tool,Student Group Creation Tool,Studentski alat za izradu Grupa
DocType: Item,Variant Based On,Varijanta na temelju
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Total weightage assigned should be 100%. It is {0},Ukupno bi trebalo biti dodijeljena weightage 100 % . To je {0}
DocType: Loyalty Point Entry,Loyalty Program Tier,Razina lojalnosti
apps/erpnext/erpnext/utilities/user_progress.py,Your Suppliers,Vaši dobavljači
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Cannot set as Lost as Sales Order is made.,Ne mogu se postaviti kao izgubljen kao prodajnog naloga je napravio .
DocType: Request for Quotation Item,Supplier Part No,Dobavljač Dio Ne
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for hold: ,Razlog zadržavanja:
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Ne mogu odbiti kada je kategorija za &quot;vrednovanje&quot; ili &quot;Vaulation i ukupni &#39;
apps/erpnext/erpnext/public/js/hub/components/reviews.js,Anonymous,anoniman
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Received From,Primljeno od
DocType: Lead,Converted,Pretvoreno
DocType: Item,Has Serial No,Ima serijski br
DocType: Stock Entry Detail,PO Supplied Item,Predmet isporučenog predmeta
DocType: Employee,Date of Issue,Datum izdavanja
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}","Kao i po postavkama kupnje ako je zahtjev za kupnju potreban == &#39;YES&#39;, a zatim za izradu fakture za kupnju, korisnik mora najprije stvoriti potvrdu o kupnji za stavku {0}"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Set Supplier for item {1},Red # {0}: Postavite dobavljač za stavke {1}
DocType: Global Defaults,Default Distance Unit,Zadana jedinica udaljenosti
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: Hours value must be greater than zero.,Red {0}: Sati vrijednost mora biti veća od nule.
apps/erpnext/erpnext/stock/doctype/item/item.py,Website Image {0} attached to Item {1} cannot be found,Web stranica slike {0} prilogu točki {1} Ne mogu naći
DocType: Asset,Assets,Imovina
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Computer,računalo
DocType: Item,List this Item in multiple groups on the website.,Prikaži ovu stavku u više grupa na web stranici.
DocType: Subscription,Current Invoice End Date,Datum završetka tekuće fakture
DocType: Payment Term,Due Date Based On,Datum dospijeća na temelju
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Please set default customer group and territory in Selling Settings,Postavite zadanu grupu korisnika i teritorij u Postavkama prodaje
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} does not exist,{0} {1} ne postoji
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please check Multi Currency option to allow accounts with other currency,Molimo provjerite više valuta mogućnost dopustiti račune s druge valute
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Item: {0} does not exist in the system,Stavka: {0} ne postoji u sustavu
apps/erpnext/erpnext/accounts/doctype/account/account.py,You are not authorized to set Frozen value,Niste ovlašteni za postavljanje zamrznute vrijednosti
DocType: Payment Reconciliation,Get Unreconciled Entries,Kreiraj neusklađene ulaze
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} is on Leave on {1},Zaposlenik {0} je na dopustu na {1}
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments selected for Journal Entry,Nije odabrana otplata za unos dnevnika
DocType: Purchase Invoice,GST Category,GST kategorija
DocType: Payment Reconciliation,From Invoice Date,Iz dostavnice Datum
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Budgets,Proračuni
DocType: Invoice Discounting,Disbursed,isplaćeni
DocType: Healthcare Settings,Laboratory Settings,Laboratorijske postavke
DocType: Clinical Procedure,Service Unit,Servisna jedinica
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Successfully Set Supplier,Uspješno postavite dobavljača
DocType: Leave Encashment,Leave Encashment,Ostavi naplate
apps/erpnext/erpnext/public/js/setup_wizard.js,What does it do?,Što učiniti ?
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py,Tasks have been created for managing the {0} disease (on row {1}),Zadaci su stvoreni za upravljanje {0} bolestom (u retku {1})
DocType: Crop,Byproducts,nusproizvodi
apps/erpnext/erpnext/stock/doctype/batch/batch.js,To Warehouse,Za skladište
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,All Student Admissions,Svi Studentski Upisi
,Average Commission Rate,Prosječna provizija
DocType: Share Balance,No of Shares,Broj dionica
DocType: Taxable Salary Slab,To Amount,Iznos
apps/erpnext/erpnext/stock/doctype/item/item.py,'Has Serial No' can not be 'Yes' for non-stock item,'Ima serijski broj' ne može biti 'Da' za neskladišne proizvode
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Status,Odaberite Status
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance can not be marked for future dates,Gledatelji ne može biti označena za budući datum
DocType: Support Search Source,Post Description Key,Ključ za opis post
DocType: Pricing Rule,Pricing Rule Help,Pravila cijena - pomoć
DocType: School House,House Name,Ime kuća
DocType: Fee Schedule,Total Amount per Student,Ukupni iznos po studentu
DocType: Opportunity,Sales Stage,Prodajna pozornica
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Customer PO,Kupci PO
DocType: Purchase Taxes and Charges,Account Head,Zaglavlje računa
DocType: Company,HRA Component,HRA komponenta
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Electrical,Električna
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 ostatak svoje organizacije kao svoje korisnike. Također možete dodati pozvati kupce da svoj portal dodajući ih iz Kontakata
DocType: Stock Entry,Total Value Difference (Out - In),Ukupna vrijednost razlika (Out - In)
DocType: Employee Checkin,Location / Device ID,Lokacija / ID uređaja
DocType: Grant Application,Requested Amount,Zahtijevani iznos
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Exchange Rate is mandatory,Red {0}: tečaj je obavezno
DocType: Invoice Discounting,Bank Charges Account,Račun bankovnih naknada
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,User ID not set for Employee {0},Korisnik ID nije postavljen za zaposlenika {0}
DocType: Vehicle,Vehicle Value,Vrijednost vozila
DocType: Crop Cycle,Detected Diseases,Otkrivene bolesti
DocType: Stock Entry,Default Source Warehouse,Zadano izvorno skladište
DocType: Item,Customer Code,Kupac Šifra
DocType: Bank,Data Import Configuration,Konfiguracija uvoza podataka
DocType: Asset Maintenance Task,Last Completion Date,Datum posljednjeg dovršetka
apps/erpnext/erpnext/accounts/report/inactive_sales_items/inactive_sales_items.js,Days Since Last Order,Dana od posljednje narudžbe
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To account must be a Balance Sheet account,Zaduženja računa mora biti bilanca račun
DocType: Asset,Naming Series,Imenovanje serije
DocType: Vital Signs,Coated,premazan
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Redak {0}: očekivana vrijednost nakon korisnog životnog vijeka mora biti manja od bruto narudžbenice
apps/erpnext/erpnext/regional/italy/utils.py,Please set {0} for address {1},Postavite {0} za adresu {1}
DocType: GoCardless Settings,GoCardless Settings,Postavke GoCardless
apps/erpnext/erpnext/controllers/stock_controller.py,Create Quality Inspection for Item {0},Napravite inspekciju kvalitete za predmet {0}
DocType: Leave Block List,Leave Block List Name,Naziv popisa neodobrenih odsustava
DocType: Certified Consultant,Certification Validity,Valjanost certifikacije
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Insurance Start date should be less than Insurance End date,Osiguranje Datum početka mora biti manja od osiguranja datum završetka
DocType: Support Settings,Service Level Agreements,Ugovori o razini usluge
DocType: Shopping Cart Settings,Display Settings,Prikaz postavki
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Assets,dionicama u vrijednosti
DocType: Restaurant,Active Menu,Aktivni izbornik
DocType: Accounting Dimension Detail,Default Dimension,Zadana dimenzija
DocType: Target Detail,Target Qty,Ciljana Kol
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Against Loan: {0},Protiv zajma: {0}
DocType: Shopping Cart Settings,Checkout Settings,Blagajna Postavke
DocType: Student Attendance,Present,Sadašnje
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Delivery Note {0} must not be submitted,Otpremnica {0} ne smije biti potvrđena
DocType: HR Settings,"The salary slip emailed to the employee will be password protected, the password will be generated based on the password policy.","Popis plaće upućen zaposleniku bit će zaštićen lozinkom, a lozinka će se generirati na temelju pravila o zaporkama."
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Closing Account {0} must be of type Liability / Equity,Zatvaranje računa {0} mora biti tipa odgovornosti / Equity
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Slip of employee {0} already created for time sheet {1},Plaća proklizavanja zaposlenika {0} već stvoren za vremensko listu {1}
DocType: Vehicle Log,Odometer,mjerač za pređeni put
DocType: Production Plan Item,Ordered Qty,Naručena kol
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is disabled,Stavka {0} je onemogućen
DocType: Stock Settings,Stock Frozen Upto,Kataloški Frozen Upto
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,BOM does not contain any stock item,BOM ne sadrži bilo koji zaliha stavku
DocType: Chapter,Chapter Head,Glava poglavlja
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Search for a payment,Traži plaćanje
DocType: Payment Term,Month(s) after the end of the invoice month,Mjesec (i) nakon završetka mjeseca fakture
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 bi trebala imati fleksibilnu komponentu koristi za raspodjelu iznosa naknada
apps/erpnext/erpnext/config/projects.py,Project activity / task.,Projekt aktivnost / zadatak.
DocType: Vital Signs,Very Coated,Vrlo obložena
DocType: Salary Component,Only Tax Impact (Cannot Claim But Part of Taxable Income),Samo porezni utjecaj (ne može se potraživati samo dio oporezivog dohotka)
DocType: Vehicle Log,Refuelling Details,Punjenje Detalji
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab result datetime cannot be before testing datetime,Datetime rezultata laboratorija ne može biti prije testiranja datetime
DocType: Delivery Trip,Use Google Maps Direction API to optimize route,Za optimizaciju rute koristite API za usmjeravanje Google Maps
DocType: POS Profile,Allow user to edit Discount,Dopusti korisniku uređivanje popusta
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Get customers from,Kupujte korisnike
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per rules 42 & 43 of CGST Rules,Prema pravilima 42 i 43 CGST pravila
DocType: Purchase Invoice Item,Include Exploded Items,Uključi eksplodirane predmete
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,"Buying must be checked, if Applicable For is selected as {0}","Nabava mora biti provjerena, ako je primjenjivo za odabrano kao {0}"
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Discount must be less than 100,Popust mora biti manji od 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}.",Vrijeme pokretanja ne može biti veće od ili jednako konačnom vremenu \ za {0}.
DocType: Shipping Rule,Restrict to Countries,Ograničite na zemlje
DocType: Shift Type,Alternating entries as IN and OUT during the same shift,Naizmjenični unosi kao IN i OUT tijekom iste promjene
DocType: Shopify Settings,Shared secret,Zajednička tajna
DocType: Amazon MWS Settings,Synch Taxes and Charges,Sinkroniziranje poreza i naknada
DocType: Purchase Invoice,Write Off Amount (Company Currency),Otpis iznos (Društvo valuta)
DocType: Sales Invoice Timesheet,Billing Hours,Radno vrijeme naplate
DocType: Project,Total Sales Amount (via Sales Order),Ukupni iznos prodaje (putem prodajnog naloga)
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Default BOM for {0} not found,Zadana BOM za {0} nije pronađena
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 početka fiskalne godine trebao bi biti godinu dana ranije od datuma završetka fiskalne godine
apps/erpnext/erpnext/stock/doctype/item/item.py,Row #{0}: Please set reorder quantity,Red # {0}: Molimo postavite naručivanja količinu
apps/erpnext/erpnext/public/js/pos/pos.html,Tap items to add them here,Dodirnite stavke da biste ih dodali ovdje
DocType: Course Enrollment,Program Enrollment,Program za upis
apps/erpnext/erpnext/controllers/item_variant.py,Rename Not Allowed,Preimenovanje nije dopušteno
DocType: Share Transfer,To Folio No,Folio br
DocType: Landed Cost Voucher,Landed Cost Voucher,Nalog zavisnog troška
apps/erpnext/erpnext/config/accounting.py,Tax Category for overriding tax rates.,Porezna kategorija za previsoke porezne stope.
apps/erpnext/erpnext/public/js/queries.js,Please set {0},Molimo postavite {0}
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} je neaktivan učenik
DocType: Employee,Health Details,Zdravlje Detalji
DocType: Leave Encashment,Encashable days,Napadi koji se mogu vezati
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Za izradu referentnog dokumenta zahtjeva za plaćanje potrebno je
DocType: Soil Texture,Sandy Clay,Sandy Clay
DocType: Grant Application,Assessment  Manager,Voditelj procjene
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Allocate Payment Amount,Dodjela iznos otplate
DocType: Subscription Plan,Subscription Plan,Plan pretplate
DocType: Employee External Work History,Salary,Plaća
DocType: Serial No,Delivery Document Type,Dokument isporuke - tip
DocType: Sales Order,Partly Delivered,Djelomično isporučeno
DocType: Item Variant Settings,Do not update variants on save,Ne ažurirajte inačice spremanja
DocType: Email Digest,Receivables,Potraživanja
DocType: Lead Source,Lead Source,Izvor potencijalnog kupca
DocType: Customer,Additional information regarding the customer.,Dodatne informacije o kupcu.
DocType: Quality Inspection Reading,Reading 5,Čitanje 5
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} povezan je s {2}, ali račun stranke je {3}"
DocType: Bank Statement Settings Item,Bank Header,Bank Header
apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js,View Lab Tests,Pogledajte laboratorijske testove
DocType: Hub Users,Hub Users,Korisnici huba
DocType: Purchase Invoice,Y,Y
DocType: Maintenance Visit,Maintenance Date,Datum održavanje
DocType: Purchase Invoice Item,Rejected Serial No,Odbijen Serijski br
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,Godina datum početka ili završetka je preklapanje s {0}. Da bi se izbjegla postavite tvrtku
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Please mention the Lead Name in Lead {0},Navedite Lead Name u Lead {0}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Start date should be less than end date for Item {0},Početak bi trebao biti manji od krajnjeg datuma za točke {0}
DocType: Shift Type,Auto Attendance Settings,Postavke automatske posjećenosti
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.","Primjer:. ABCD ##### 
 Ako Serija je postavljena i serijski broj ne spominje u prometu, a zatim automatsko serijski broj će biti izrađen na temelju ove serije. Ako ste uvijek žele eksplicitno spomenuti serijski brojevi za tu stavku. ostavite praznim."
DocType: Upload Attendance,Upload Attendance,Upload Attendance
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,BOM and Manufacturing Quantity are required,BOM i proizvodnja Količina potrebne su
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 2,Starenje Raspon 2
DocType: SG Creation Tool Course,Max Strength,Max snaga
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Account {0} already exists in child company {1}. The following fields have different values, they should be same:<ul><li>{2}</li></ul>","Račun {0} već postoji u dječjoj tvrtki {1}. Sljedeća polja imaju različite vrijednosti, trebala bi biti ista: <ul><li> {2} </li></ul>"
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Installing presets,Instaliranje unaprijed postavljenih postavki
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 {},Nijedna isporuka nije odabrana za kupca {}
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Rows Added in {0},Redovi dodano u {0}
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Employee {0} has no maximum benefit amount,Zaposlenik {0} nema maksimalnu naknadu
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select Items based on Delivery Date,Odaberite stavke na temelju datuma isporuke
DocType: Grant Application,Has any past Grant Record,Ima li nekih prethodnih Grant Record
,Sales Analytics,Prodajna analitika
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Available {0},Dostupno {0}
,Prospects Engaged But Not Converted,"Izgledi angažirani, ali nisu konvertirani"
DocType: Manufacturing Settings,Manufacturing Settings,Postavke proizvodnje
DocType: Quality Feedback Template Parameter,Quality Feedback Template Parameter,Parametar predloška za povratne informacije o kvaliteti
apps/erpnext/erpnext/config/settings.py,Setting up Email,Postavljanje e-poštu
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Mobile No,Guardian1 Mobile Ne
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please enter default currency in Company Master,Unesite zadanu valutu u tvrtki Master
DocType: Stock Entry Detail,Stock Entry Detail,Detalji međuskladišnice
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Daily Reminders,Dnevne Podsjetnici
apps/erpnext/erpnext/templates/pages/help.html,See all open tickets,Pogledajte sve otvorene ulaznice
DocType: Brand,Brand Defaults,Zadane vrijednosti robne marke
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js,Healthcare Service Unit Tree,Tree zdravstvene usluge
DocType: Pricing Rule,Product,Proizvod
DocType: Products Settings,Home Page is Products,Početna stranica su proizvodi
,Asset Depreciation Ledger,Imovine Amortizacija knjiga
DocType: Salary Structure,Leave Encashment Amount Per Day,Naplaćivanje iznosa naplate po danu
DocType: Loyalty Program Collection,For how much spent = 1 Loyalty Point,Koliko potrošeno = 1 Loyalty Point
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Rule Conflicts with {0},Porezni Pravilo Sukobi s {0}
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,New Account Name,Naziv novog računa
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Sirovine Isporuka Troškovi
DocType: Selling Settings,Settings for Selling Module,Postavke za prodaju modula
DocType: Hotel Room Reservation,Hotel Room Reservation,Rezervacija hotela
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Customer Service,Služba za korisnike
DocType: BOM,Thumbnail,Thumbnail
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,No contacts with email IDs found.,Nije pronađen nijedan kontakt s ID-ovima e-pošte.
DocType: Item Customer Detail,Item Customer Detail,Proizvod - detalji kupca
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum benefit amount of employee {0} exceeds {1},Maksimalna naknada zaposlenika {0} premašuje {1}
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total allocated leaves are more than days in the period,Ukupno dodijeljeni Listovi su više od dana u razdoblju
DocType: Linked Soil Analysis,Linked Soil Analysis,Povezana analiza tla
DocType: Pricing Rule,Percentage,Postotak
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Item {0} must be a stock Item,Proizvod {0} mora biti skladišni
DocType: Manufacturing Settings,Default Work In Progress Warehouse,Zadana rad u tijeku Skladište
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Rasporedi za {0} preklapanja, želite li nastaviti nakon preskakanja preklapanih utora?"
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js,Grant Leaves,Odustani od ostavljanja
DocType: Restaurant,Default Tax Template,Zadani predložak poreza
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,{0} Students have been enrolled,{0} Učenici su upisani
DocType: Fees,Student Details,Pojedinosti studenata
DocType: Woocommerce Settings,"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".",Ovo je zadani UOM koji se koristi za artikle i prodajne naloge. Povratni UOM je &quot;Nos&quot;.
DocType: Purchase Invoice Item,Stock Qty,Kataloški broj
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Ctrl+Enter to submit,Ctrl + Enter za slanje
DocType: Contract,Requires Fulfilment,Zahtijeva ispunjenje
DocType: QuickBooks Migrator,Default Shipping Account,Zadani račun za otpreme
DocType: Loan,Repayment Period in Months,Rok otplate u mjesecima
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Error: Not a valid id?,Pogreška: Nije valjana id?
DocType: Naming Series,Update Series Number,Update serije Broj
DocType: Account,Equity,pravičnost
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}: Tip računa 'Dobit i gubitak'  {2} nije dopušten u Početnom Unosu
DocType: Job Offer,Printing Details,Ispis Detalji
DocType: Task,Closing Date,Datum zatvaranja
DocType: Sales Order Item,Produced Quantity,Proizvedena količina
DocType: Item Price,Quantity  that must be bought or sold per UOM,Količina koja se mora kupiti ili prodati po UOM-u
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Engineer,inženjer
DocType: Promotional Scheme Price Discount,Max Amount,Maksimalni iznos
DocType: Journal Entry,Total Amount Currency,Ukupno Valuta Iznos
DocType: Pricing Rule,Min Amt,Min Amt
DocType: Item,Is Customer Provided Item,Je li predmet kupca
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Search Sub Assemblies,Traži Sub skupštine
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Item Code required at Row No {0},Kod proizvoda je potreban u redu broj {0}
DocType: GST Account,SGST Account,SGST račun
apps/erpnext/erpnext/utilities/user_progress.py,Go to Items,Idite na stavke
DocType: Sales Partner,Partner Type,Tip partnera
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Actual,Stvaran
DocType: Restaurant Menu,Restaurant Manager,Voditelj restorana
DocType: Call Log,Call Log,Popis poziva
DocType: Authorization Rule,Customerwise Discount,Customerwise Popust
apps/erpnext/erpnext/config/projects.py,Timesheet for tasks.,Timesheet za zadatke.
DocType: Purchase Invoice,Against Expense Account,Protiv Rashodi račun
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Installation Note {0} has already been submitted,Napomena instalacije {0} je već potvrđena
DocType: BOM,Raw Material Cost (Company Currency),Trošak sirovina (Društvena valuta)
apps/erpnext/erpnext/regional/india/utils.py,House rent paid days overlapping with {0},"Najam plaćenih dana za kuću, preklapajući se sa {0}"
DocType: GSTR 3B Report,October,listopad
DocType: Bank Reconciliation,Get Payment Entries,Dobiti Ulaz plaćanja
DocType: Quotation Item,Against Docname,Protiv Docname
DocType: SMS Center,All Employee (Active),Svi zaposlenici (aktivni)
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Detailed Reason,Detaljan razlog
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,View Now,Pogledaj sada
DocType: BOM,Raw Material Cost,Troškova sirovine
DocType: Woocommerce Settings,Woocommerce Server URL,URL poslužitelja Woocommerce
DocType: Item Reorder,Re-Order Level,Ponovno bi razini
DocType: Additional Salary,Deduct Full Tax on Selected Payroll Date,Odbijeni puni porez na odabrani datum plaće
DocType: Shopify Tax Account,Shopify Tax/Shipping Title,Zapišite porez / dostavu
apps/erpnext/erpnext/projects/doctype/project/project.js,Gantt Chart,Gantogram
DocType: Crop Cycle,Cycle Type,Vrsta ciklusa
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Part-time,Privemeno (nepuno radno vrijeme)
DocType: Employee,Applicable Holiday List,Primjenjivo odmor Popis
DocType: Employee,Cheque,Ček
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Synchronize this account,Sinkronizirajte ovaj račun
DocType: Training Event,Employee Emails,E-pošte zaposlenika
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Series Updated,Serija ažurirana
apps/erpnext/erpnext/accounts/doctype/account/account.py,Report Type is mandatory,Vrsta izvješća je obvezno
DocType: Item,Serial Number Series,Serijski broj serije
,Sales Partner Transaction Summary,Sažetak transakcije prodajnog partnera
apps/erpnext/erpnext/buying/utils.py,Warehouse is mandatory for stock Item {0} in row {1},Skladište je obvezno za skladišne proizvode {0} u redu {1}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Retail & Wholesale,Trgovina na veliko i
DocType: Issue,First Responded On,Prvo Odgovorili Na
DocType: Website Item Group,Cross Listing of Item in multiple groups,Križ Oglas pošiljke u više grupa
DocType: Employee Tax Exemption Declaration,Other Incomes,Ostali prihodi
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 godina Datum početka i datum završetka fiskalne godine već su postavljeni u fiskalnoj godini {0}
DocType: Projects Settings,Ignore User Time Overlap,Zanemari Vrijeme preklapanja korisnika
DocType: Accounting Period,Accounting Period,Obračunsko razdoblje
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date updated,Razmak Datum ažurirana
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split Batch,Split Batch
DocType: Stock Settings,Batch Identification,Identifikacija serije
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Successfully Reconciled,Uspješno Pomirio
DocType: Request for Quotation Supplier,Download PDF,Preuzmite PDF
DocType: Work Order,Planned End Date,Planirani datum završetka
DocType: Shareholder,Hidden list maintaining the list of contacts linked to Shareholder,Skriveni popis koji vodi popis kontakata povezanih s Dioničarom
DocType: Exchange Rate Revaluation Account,Current Exchange Rate,Trenutačna tečajna lista
DocType: Item,"Sales, Purchase, Accounting Defaults","Prodaja, Kupnja, Računovodstvene vrijednosti"
DocType: Accounting Dimension Detail,Accounting Dimension Detail,Detalji dimenzije računovodstva
apps/erpnext/erpnext/config/non_profit.py,Donor Type information.,Informacije o donatoru.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Leave on {1},{0} na dopustu na {1}
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available for use date is required,Dostupan je za datum upotrebe
DocType: Request for Quotation,Supplier Detail,Dobavljač Detalj
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Error in formula or condition: {0},Greška u formuli ili stanja: {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Invoiced Amount,Dostavljeni iznos
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Criteria weights must add up to 100%,Ponderi kriterija moraju se dodati do 100%
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js,Attendance,Pohađanje
apps/erpnext/erpnext/public/js/pos/pos.html,Stock Items,zalihi
DocType: Sales Invoice,Update Billed Amount in Sales Order,Ažurirajte količinu naplaćenu u prodajnom nalogu
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Contact Seller,Kontaktirajte prodavača
DocType: BOM,Materials,Materijali
DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Ako nije označeno, popis će biti dodan u svakom odjela gdje se mora primjenjivati."
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Posting date and posting time is mandatory,Datum knjiženja i knjiženje vrijeme je obvezna
apps/erpnext/erpnext/config/buying.py,Tax template for buying transactions.,Porezna Predložak za kupnju transakcije .
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Please login as a Marketplace User to report this item.,Prijavite se kao korisnik Marketplacea kako biste prijavili ovu stavku.
,Sales Partner Commission Summary,Sažetak komisije za prodajne partnere
,Item Prices,Cijene proizvoda
DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,U riječi će biti vidljiv nakon što spremite narudžbenice.
DocType: Holiday List,Add to Holidays,Dodaj u praznike
DocType: Woocommerce Settings,Endpoint,Endpoint
DocType: Period Closing Voucher,Period Closing Voucher,Razdoblje Zatvaranje bon
DocType: Patient Encounter,Review Details,Pojedinosti pregleda
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shareholder does not belong to this company,Dioničar ne pripada ovoj tvrtki
DocType: Dosage Form,Dosage Form,Oblik doziranja
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,Please set up the Campaign Schedule in the Campaign {0},Postavite Raspored kampanje u kampanji {0}
apps/erpnext/erpnext/config/buying.py,Price List master.,Glavni cjenik.
DocType: Task,Review Date,Recenzija Datum
DocType: BOM,Allow Alternative Item,Dopusti alternativnu stavku
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Purchase Receipt doesn't have any Item for which Retain Sample is enabled.,Kupnja potvrde nema stavku za koju je omogućen zadržati uzorak.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Invoice Grand Total,Faktura ukupno
DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Serija za unos amortizacije imovine (unos dnevnika)
DocType: Membership,Member Since,Član od
DocType: Purchase Invoice,Advance Payments,Avansima
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Time logs are required for job card {0},Zapisnik posla potreban je za evidenciju vremena {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Healthcare Service,Odaberite zdravstvenu službu
DocType: Purchase Taxes and Charges,On Net Total,VPC
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},Vrijednost za atribut {0} mora biti unutar raspona od {1} {2} u koracima od {3} za točku {4}
DocType: Pricing Rule,Product Discount Scheme,Shema popusta na proizvode
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,No issue has been raised by the caller.,Nazivatelj nije pokrenuo nijedan problem.
DocType: Restaurant Reservation,Waitlisted,na listi čekanja
DocType: Employee Tax Exemption Declaration Category,Exemption Category,Kategorija izuzeća
apps/erpnext/erpnext/accounts/doctype/account/account.py,Currency can not be changed after making entries using some other currency,Valuta se ne može mijenjati nakon što unose pomoću neke druge valute
DocType: Shipping Rule,Fixed,fiksni
DocType: Vehicle Service,Clutch Plate,držač za tanjur
DocType: Tally Migration,Round Off Account,Zaokružiti račun
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Administrative Expenses,Administrativni troškovi
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consulting,savjetodavni
DocType: Subscription Plan,Based on price list,Na temelju cjenika
DocType: Customer Group,Parent Customer Group,Nadređena grupa kupaca
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill JSON can only be generated from Sales Invoice,e-Way Bill JSON može se generirati samo iz prodajne fakture
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Maximum attempts for this quiz reached!,Došli su maksimalni pokušaji ovog kviza!
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Subscription,Pretplata
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Pending,Kreiranje pristojbe na čekanju
DocType: Project Template Task,Duration (Days),Trajanje (dani)
DocType: Appraisal Goal,Score Earned,Ocjena Zarađeni
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Notice Period,Otkaznog roka
DocType: Asset Category,Asset Category Name,Imovina Kategorija Naziv
apps/erpnext/erpnext/setup/doctype/territory/territory.js,This is a root territory and cannot be edited.,Ovo je glavni teritorij i ne može se mijenjati.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js,New Sales Person Name,Novo ime prodajnog agenta
DocType: Packing Slip,Gross Weight UOM,Bruto težina UOM
DocType: Employee Transfer,Create New Employee Id,Stvorite novi ID zaposlenika
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Set Details,Postavite pojedinosti
apps/erpnext/erpnext/templates/pages/home.html,By {0},Do {0}
DocType: Travel Itinerary,Travel From,Putovanje od
DocType: Asset Maintenance Task,Preventive Maintenance,Preventivni remont
DocType: Delivery Note Item,Against Sales Invoice,Protiv prodaje fakture
DocType: Purchase Invoice,07-Others,07-Ostalo
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please enter serial numbers for serialized item ,Unesite serijske brojeve za serijsku stavku
DocType: Bin,Reserved Qty for Production,Rezervirano Kol za proizvodnju
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,Ostavite neoznačeno ako ne želite razmotriti grupu dok stvarate grupe temeljene na tečajima.
DocType: Asset,Frequency of Depreciation (Months),Učestalost Amortizacija (mjeseci)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Credit Account,Kreditni račun
DocType: Landed Cost Item,Landed Cost Item,Stavka zavisnih troškova
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js,Show zero values,Pokaži nulte vrijednosti
DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Količina proizvoda dobivena nakon proizvodnje / pakiranja od navedene količine sirovina
DocType: Lab Test,Test Group,Test grupa
DocType: Service Level Agreement,Entity,entiteta
DocType: Payment Reconciliation,Receivable / Payable Account,Potraživanja / Plaća račun
DocType: Delivery Note Item,Against Sales Order Item,Protiv prodaje reda točkom
DocType: Company,Company Logo,Logo tvrtke
DocType: QuickBooks Migrator,Default Warehouse,Glavno skladište
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Budget cannot be assigned against Group Account {0},Proračun se ne može dodijeliti protiv grupe nalog {0}
DocType: Shopping Cart Settings,Show Price,Pokaži cijenu
DocType: Healthcare Settings,Patient Registration,Registracija pacijenata
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Please enter parent cost center,Unesite roditelj troška
DocType: Delivery Note,Print Without Amount,Ispis Bez visini
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py,Depreciation Date,Amortizacija Datum
,Work Orders in Progress,Radni nalozi u tijeku
DocType: Issue,Support Team,Tim za podršku
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expiry (In Days),Rok (u danima)
DocType: Appraisal,Total Score (Out of 5),Ukupna ocjena (od 5)
DocType: Student Attendance Tool,Batch,Serija
DocType: Support Search Source,Query Route String,Upit Stringa rute
DocType: Tally Migration,Day Book Data,Podaci o dnevnoj knjizi
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update rate as per last purchase,Stopa ažuriranja po zadnjoj kupnji
DocType: Donor,Donor Type,Vrsta donatora
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Auto repeat document updated,Ažurira se automatski ponavljanje dokumenta
apps/erpnext/erpnext/stock/doctype/item/item.js,Balance,Ravnoteža
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please select the Company,Odaberite tvrtku
DocType: Employee Checkin,Skip Auto Attendance,Preskočite automatsku posjetu
DocType: BOM,Job Card,Radna mjesta za posao
DocType: Room,Seating Capacity,Sjedenje Kapacitet
DocType: Issue,ISS-,ISS-
DocType: Item,Is Non GST,Nije GST
DocType: Lab Test Groups,Lab Test Groups,Lab test grupe
apps/erpnext/erpnext/config/accounting.py,Profitability,rentabilnost
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,Party Type and Party is mandatory for {0} account,Vrsta stranke i stranka obvezni su za {0} račun
DocType: Project,Total Expense Claim (via Expense Claims),Ukupni rashodi Zatraži (preko Rashodi potraživanja)
DocType: GST Settings,GST Summary,GST Sažetak
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,Molimo omogućite zadani dolazni račun prije stvaranja Grupe za dnevni rad
DocType: Assessment Result,Total Score,Ukupni rezultat
DocType: Crop Cycle,ISO 8601 standard,ISO 8601 standard
DocType: Journal Entry,Debit Note,Rashodi - napomena
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,You can only redeem max {0} points in this order.,U tom redoslijedu možete iskoristiti najviše {0} bodova.
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,Unesite API Consumer Secret
DocType: Stock Entry,As per Stock UOM,Kao po burzi UOM
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js,Not Expired,Nije istekao
DocType: Student Log,Achievement,dostignuće
DocType: Asset,Insurer,osiguravač
DocType: Batch,Source Document Type,Izvorni tip dokumenta
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Following course schedules were created,Izrađeni su sljedeći raspored tečajeva
DocType: Employee Onboarding,Employee Onboarding,Zaposlenik Onboarding
DocType: Journal Entry,Total Debit,Ukupno zaduženje
DocType: Travel Request Costing,Sponsored Amount,Sponzorirani iznos
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Zadane gotovih proizvoda Skladište
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Please select Patient,Odaberite Pacijent
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Sales Person,Prodajna osoba
DocType: Hotel Room Package,Amenities,Sadržaji
DocType: Accounts Settings,Automatically Fetch Payment Terms,Automatski preuzmi Uvjete plaćanja
DocType: QuickBooks Migrator,Undeposited Funds Account,Neraspoređeni račun sredstava
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Višestruki zadani način plaćanja nije dopušten
DocType: Sales Invoice,Loyalty Points Redemption,Otkup lojalnih bodova
,Appointment Analytics,Imenovanje Google Analytics
DocType: Lead,Blog Subscriber,Blog pretplatnik
DocType: Guardian,Alternate Number,Alternativni broj
DocType: Assessment Plan Criteria,Maximum Score,Maksimalni broj bodova
apps/erpnext/erpnext/config/settings.py,Create rules to restrict transactions based on values.,Napravi pravila za ograničavanje prometa na temelju vrijednosti.
DocType: Cash Flow Mapping Accounts,Cash Flow Mapping Accounts,Računi za mapiranje novčanog toka
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py, Group Roll No,Skupna grupa br
DocType: Quality Goal,Revision and Revised On,Revizija i revizija dana
DocType: Batch,Manufacturing Date,Datum proizvodnje
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Failed,Izrada pristojbe nije uspjela
DocType: Opening Invoice Creation Tool,Create Missing Party,Stvorite stranu koja nedostaje
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Ukupni proračun
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Ostavite prazno ako grupe studenata godišnje unesete
DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Ako je označeno, Ukupan broj. radnih dana će uključiti odmor, a to će smanjiti vrijednost plaća po danu"
apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Da biste omogućili primanje / isporuku, ažurirajte &quot;Preplata primanja / Dostava&quot; u Postavkama zaliha ili Stavka."
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 pomoću trenutnog ključa neće moći pristupiti, jeste li sigurni?"
DocType: Subscription Settings,Prorate,Proporcionalno podijeliti
DocType: Purchase Invoice,Total Advance,Ukupno predujma
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Template Code,Promijeni kod predloška
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Datum Pojam završetka ne može biti ranije od datuma Pojam Start. Ispravite datume i pokušajte ponovno.
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot Count,Broj kvote
DocType: Bank Statement Transaction Entry,Bank Statement,Izjava banke
DocType: Employee Benefit Claim,Max Amount Eligible,Maksimalni iznos koji ispunjava uvjete
,BOM Stock Report,BOM Stock Report
DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Ako nema dodijeljenog vremenskog intervala, komunikacija će upravljati ovom skupinom"
DocType: Stock Reconciliation Item,Quantity Difference,Količina razlika
DocType: Opportunity Item,Basic Rate,Osnovna stopa
DocType: GL Entry,Credit Amount,Kreditni iznos
,Electronic Invoice Register,Registar elektroničkih računa
DocType: Cheque Print Template,Signatory Position,potpisnik pozicija
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Set as Lost,Postavi kao Lost
DocType: Timesheet,Total Billable Hours,Ukupno naplatnih sati
DocType: Subscription,Number of days that the subscriber has to pay invoices generated by this subscription,Broj dana za koje pretplatnik mora platiti račune koje je generirala ova pretplata
DocType: Employee Benefit Application Detail,Employee Benefit Application Detail,Detalji o primanju zaposlenika
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Payment Receipt Note,Plaćanje Potvrda Napomena
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,This is based on transactions against this Customer. See timeline below for details,To se temelji na transakcijama protiv tog kupca. Pogledajte vremensku crtu ispod za detalje
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Create Material Request,Izradite materijalni zahtjev
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}",Datumi završetka i datumi koji nisu u važećem platnom roku ne mogu 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},Red {0}: Dodijeljeni iznos {1} mora biti manja ili jednaka količini unosa Plaćanje {2}
DocType: Program Enrollment Tool,New Academic Term,Novi akademski naziv
,Course wise Assessment Report,Izvješće o procjeni studija
DocType: Customer Feedback Template,Customer Feedback Template,Predložak za povratne informacije kupca
DocType: Purchase Invoice,Availed ITC State/UT Tax,Availed ITC State / UT porez
DocType: Tax Rule,Tax Rule,Porezni Pravilo
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Održavaj istu stopu tijekom cijelog prodajnog ciklusa
apps/erpnext/erpnext/hub_node/api.py,Please login as another user to register on Marketplace,Prijavite se kao drugi korisnik da biste se registrirali na tržištu
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Planirajte vrijeme za rezanje izvan radne stanice radnog vremena.
apps/erpnext/erpnext/public/js/pos/pos.html,Customers in Queue,Kupci u redu
DocType: Driver,Issuing Date,Datum izdavanja
DocType: Procedure Prescription,Appointment Booked,Rezervirano za sastanak
DocType: Student,Nationality,Nacionalnost
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure,Konfigurirati
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Submit this Work Order for further processing.,Pošaljite ovaj radni nalog za daljnju obradu.
,Items To Be Requested,Potraživani proizvodi
DocType: Company,Allow Account Creation Against Child Company,Omogući stvaranje računa protiv tvrtke Child
DocType: Company,Company Info,Podaci o tvrtki
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select or add new customer,Odaberite ili dodajte novi kupac
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Cost center is required to book an expense claim,Troška potrebno je rezervirati trošak zahtjev
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Application of Funds (Assets),Primjena sredstava ( aktiva )
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,This is based on the attendance of this Employee,To se temelji na prisustvo tog zaposlenog
DocType: Payment Request,Payment Request Type,Vrsta zahtjeva za plaćanje
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Mark Attendance,Označite prisustvo
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Debit Account,Duguje račun
DocType: Fiscal Year,Year Start Date,Početni datum u godini
DocType: Additional Salary,Employee Name,Ime zaposlenika
DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Stavka unosa narudžbe restorana
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,{0} bank transaction(s) created and {1} errors,{0} stvorene bankovne transakcije i {1} pogreške
DocType: Purchase Invoice,Rounded Total (Company Currency),Zaobljeni Ukupno (Društvo valuta)
apps/erpnext/erpnext/accounts/doctype/account/account.py,Cannot covert to Group because Account Type is selected.,Ne može se tajno u grupu jer je izabrana vrsta računa.
DocType: Quiz,Max Attempts,Maks pokušaji
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} has been modified. Please refresh.,{0} {1} je izmijenjen. Osvježi stranicu.
DocType: Leave Block List,Stop users from making Leave Applications on following days.,Prestani korisnike od izrade ostaviti aplikacija na sljedećim danima.
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.","Ako je neograničeno isteklo za Points lojalnost, zadržite trajanje isteka prazno ili 0."
DocType: Asset Maintenance Team,Maintenance Team Members,Održavanje članova tima
DocType: Loyalty Point Entry,Purchase Amount,Iznos narudžbe
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}",Nije moguće prikazati serijski broj {0} stavke {1} kao što je rezervirano \ da bi se ispunio prodajni nalog {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,Dobavljač Navod {0} stvorio
apps/erpnext/erpnext/accounts/report/financial_statements.py,End Year cannot be before Start Year,Godina završetka ne može biti prije Početak godine
DocType: Employee Benefit Application,Employee Benefits,Primanja zaposlenih
apps/erpnext/erpnext/projects/report/billing_summary.py,Employee ID,ID zaposlenika
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 jednaka količini za proizvod {0} u redku {1}
DocType: Work Order,Manufactured Qty,Proizvedena količina
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shares don't exist with the {0},Dionice ne postoje kod {0}
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Select Difference Account,Odaberite račun razlike
DocType: Sales Partner Type,Sales Partner Type,Vrsta prodajnog partnera
DocType: Shopify Webhook Detail,Webhook ID,Webhook ID
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Invoice Created,Izračun je izrađen
DocType: Asset,Out of Order,Izvanredno
DocType: Purchase Receipt Item,Accepted Quantity,Prihvaćena količina
DocType: Projects Settings,Ignore Workstation Time Overlap,Zanemari vrijeme preklapanja radne stanice
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please set a default Holiday List for Employee {0} or Company {1},Postavite zadani popis za odmor za zaposlenika {0} ili poduzeću {1}
apps/erpnext/erpnext/accounts/party.py,{0}: {1} does not exists,{0}: {1} Ne radi postoji
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch Numbers,Odaberite Batch Numbers
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To GSTIN,Za GSTIN
apps/erpnext/erpnext/config/accounting.py,Bills raised to Customers.,Mjenice podignuta na kupce.
DocType: Healthcare Settings,Invoice Appointments Automatically,Automatsko postavljanje računa
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,Varijabla na temelju oporezive 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},Redak Ne {0}: Iznos ne može biti veća od visine u tijeku protiv Rashodi Zahtjeva {1}. U tijeku Iznos je {2}
DocType: Patient Service Unit,Medical Administrator,Medicinski administrator
DocType: Assessment Plan,Schedule,Raspored
DocType: Account,Parent Account,Nadređeni račun
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,Salary Structure Assignment for Employee already exists,Struktura plaće zaposleniku već postoji
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Available,Dostupno
DocType: Quality Inspection Reading,Reading 3,Čitanje 3
DocType: Stock Entry,Source Warehouse Address,Izvorna skladišna adresa
DocType: GL Entry,Voucher Type,Bon Tip
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Future Payments,Buduće isplate
DocType: Amazon MWS Settings,Max Retry Limit,Maksimalni pokušaj ponovnog pokušaja
apps/erpnext/erpnext/accounts/page/pos/pos.js,Price List not found or disabled,Cjenik nije pronađen
DocType: Content Activity,Last Activity ,Zadnja aktivnost
DocType: Student Applicant,Approved,Odobren
DocType: Pricing Rule,Price,Cijena
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Employee relieved on {0} must be set as 'Left',Zaposlenik razriješen na {0} mora biti postavljen kao 'lijevo '
DocType: Guardian,Guardian,Čuvar
apps/erpnext/erpnext/support/doctype/issue/issue.js,All communications including and above this shall be moved into the new Issue,Sve komunikacije uključujući i iznad toga bit će premještene u novi Izdanje
DocType: Salary Detail,Tax on additional salary,Porez na dodatnu plaću
DocType: Item Alternative,Item Alternative,Stavka Alternativna
DocType: Healthcare Settings,Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,Računi zadanih dohodaka koji će se koristiti ako nisu postavljeni u Zdravstvenom liječniku za rezerviranje pristojbi za imenovanje.
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Total contribution percentage should be equal to 100,Ukupni postotak doprinosa trebao bi biti jednak 100
DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Stvorite nedostaje kupca ili dobavljača.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Appraisal {0} created for Employee {1} in the given date range,Procjena {0} stvorena za zaposlenika {1} u određenom razdoblju
DocType: Academic Term,Education,Obrazovanje
DocType: Payroll Entry,Salary Slips Created,Kreirano je plaća
DocType: Inpatient Record,Expected Discharge,Očekivani iskrcaj
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Del,del
DocType: Selling Settings,Campaign Naming By,Imenovanje kampanja po
DocType: Employee,Current Address Is,Trenutni Adresa je
apps/erpnext/erpnext/utilities/user_progress.py,Monthly Sales Target (,Mjesečni cilj prodaje (
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html,modified,promijenjen
DocType: Travel Request,Identification Document Number,Broj dokumenta za identifikaciju
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Optional. Sets company's default currency, if not specified.","Izborni. Postavlja tvrtke zadanu valutu, ako nije navedeno."
DocType: Sales Invoice,Customer GSTIN,Korisnik GSTIN
DocType: Crop Cycle,List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,Popis bolesti otkrivenih na terenu. Kada je odabrana automatski će dodati popis zadataka za rješavanje ove bolesti
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,BOM 1,BOM 1
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js,This is a root healthcare service unit and cannot be edited.,Ovo je jedinica za zdravstvenu zaštitu root i ne može se uređivati.
DocType: Asset Repair,Repair Status,Status popravka
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Requested Qty: Quantity requested for purchase, but not ordered.","Tražena količina : Količina zatražio za kupnju , ali ne i naređeno ."
,Subcontracted Item To Be Received,Podugovarački predmet koji se prima
apps/erpnext/erpnext/public/js/event.js,Add Sales Partners,Dodajte partnere za prodaju
apps/erpnext/erpnext/config/accounting.py,Accounting journal entries.,Knjigovodstvene temeljnice
DocType: Travel Request,Travel Request,Zahtjev za putovanje
DocType: Payment Reconciliation,System will fetch all the entries if limit value is zero.,Sustav će preuzeti sve unose ako je granična vrijednost jednaka nuli.
DocType: Delivery Note Item,Available Qty at From Warehouse,Dostupno Količina u iz skladišta
apps/erpnext/erpnext/hr/doctype/department_approver/department_approver.py,Please select Employee Record first.,Odaberite zaposlenika rekord prvi.
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as it is a Holiday.,Sudjelovanje nije poslano za {0} kao što je blagdan.
DocType: POS Profile,Account for Change Amount,Račun za promjene visine
DocType: QuickBooks Migrator,Connecting to QuickBooks,Povezivanje s QuickBooksom
DocType: Exchange Rate Revaluation,Total Gain/Loss,Ukupni dobitak / gubitak
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Pick List,Stvorite popis za odabir
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Red {0}: stranka / računa ne odgovara {1} / {2} u {3} {4}
DocType: Employee Promotion,Employee Promotion,Promocija zaposlenika
DocType: Maintenance Team Member,Maintenance Team Member,Odjel za tim za održavanje
DocType: Agriculture Analysis Criteria,Soil Analysis,Analiza tla
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,Unesite trošak računa
DocType: Quality Action Resolution,Problem,Problem
DocType: Account,Stock,Lager
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","Red # {0}: Referenca Tip dokumenta mora biti jedan od narudžbenice, fakture kupovine ili Journal Entry"
DocType: Employee,Current Address,Trenutna adresa
DocType: Item,"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Ako predmet je varijanta drugom stavku zatim opis, slika, cijena, porezi itd će biti postavljena od predloška, osim ako je izričito navedeno"
DocType: Production Plan Item,Make Work Order for Sub Assembly Items,Napravite radni nalog za predmete pod sastavljanja
DocType: Serial No,Purchase / Manufacture Details,Detalji nabave/proizvodnje
DocType: Assessment Group,Assessment Group,Grupa procjena
DocType: Stock Entry,Per Transferred,Po prijenosu
apps/erpnext/erpnext/config/help.py,Batch Inventory,Hrpa Inventar
DocType: Sales Invoice,GST Transporter ID,ID GST transportera
DocType: Procedure Prescription,Procedure Name,Naziv postupka
DocType: Employee,Contract End Date,Ugovor Datum završetka
DocType: Amazon MWS Settings,Seller ID,ID prodavatelja
DocType: Sales Order,Track this Sales Order against any Project,Prati ovu prodajni nalog protiv bilo Projekta
DocType: Bank Statement Transaction Entry,Bank Statement Transaction Entry,Unos transakcije bankovnih transakcija
DocType: Sales Invoice Item,Discount and Margin,Popusti i margina
DocType: Lab Test,Prescription,Recept
DocType: Company,Default Deferred Revenue Account,Zadani odgođeni račun prihoda
DocType: Project,Second Email,Druga e-pošta
DocType: Budget,Action if Annual Budget Exceeded on Actual,Postupak ako je godišnji proračun prekoračen na stvarnom
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Not Available,Nije dostupno
DocType: Pricing Rule,Min Qty,Min kol
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Disable Template,Onemogućite predložak
DocType: Bank Statement Transaction Invoice Item,Transaction Date,Transakcija Datum
DocType: Production Plan Item,Planned Qty,Planirani Kol
DocType: Project Template Task,Begin On (Days),Početak (dana)
DocType: Quality Action,Preventive,preventivan
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to Unregistered Persons,Isporuka za neregistrirane osobe
DocType: Company,Date of Incorporation,Datum ugradnje
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Total Tax,Ukupno porez
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Last Purchase Price,Zadnja kupovna cijena
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For Quantity (Manufactured Qty) is mandatory,Za Količina (Proizvedeno Kol) je obavezno
DocType: Stock Entry,Default Target Warehouse,Centralno skladište
DocType: Purchase Invoice,Net Total (Company Currency),Ukupno neto (valuta tvrtke)
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.,Godina Datum završetka ne može biti ranije od datuma Godina Start. Ispravite datume i pokušajte ponovno.
DocType: Purchase Order,Set Target Warehouse,Postavite Ciljni skladište
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} is not in Optional Holiday List,{0} nije u popisu slobodnih opcija
DocType: Amazon MWS Settings,JP,JP
DocType: BOM,Scrap Items,otpad Predmeti
DocType: Work Order,Actual Start Date,Stvarni datum početka
DocType: Sales Order,% of materials delivered against this Sales Order,% robe od ove narudžbe je isporučeno
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}","Preskakanje rasporeda plaća za sljedeće zaposlenike, jer postoje evidencije o rasporedu plaće protiv njih. {0}"
apps/erpnext/erpnext/config/manufacturing.py,Generate Material Requests (MRP) and Work Orders.,Generirajte materijalne zahtjeve (MRP) i radne naloge.
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Set default mode of payment,Postavite zadani način plaćanja
DocType: Stock Entry Detail,Against Stock Entry,Protiv unosa dionica
DocType: Grant Application,Withdrawn,povučen
DocType: Support Search Source,Support Search Source,Potražite izvor za podršku
apps/erpnext/erpnext/accounts/report/account_balance/account_balance.js,Chargeble,Chargeble
DocType: Project,Gross Margin %,Bruto marža %
DocType: BOM,With Operations,Uz operacije
DocType: Support Search Source,Post Route Key List,Popis ključeva za trasu popisa
apps/erpnext/erpnext/accounts/party.py,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Računovodstvenih unosa već su napravljene u valuti {0} za poduzeće {1}. Odaberite potraživanja ili dugovanja račun s valutom {0}.
DocType: Asset,Is Existing Asset,Je Postojeći Imovina
DocType: Salary Component,Statistical Component,Statistička komponenta
DocType: Warranty Claim,If different than customer address,Ako se razlikuje od kupaca adresu
DocType: Purchase Invoice,Without Payment of Tax,Bez plaćanja poreza
DocType: BOM Operation,BOM Operation,BOM operacija
DocType: Purchase Taxes and Charges,On Previous Row Amount,Na prethodnu Row visini
DocType: Options,Is Correct,Je točno
DocType: Item,Has Expiry Date,Ima datum isteka
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Transfer Asset,Prijenos imovine
apps/erpnext/erpnext/config/support.py,Issue Type.,Vrsta izdanja
DocType: POS Profile,POS Profile,POS profil
DocType: Training Event,Event Name,Naziv događaja
DocType: Healthcare Practitioner,Phone (Office),Telefon (ured)
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,"Cannot Submit, Employees left to mark attendance","Nije moguće poslati, zaposlenici ostaju označeni za pohađanje pohađanja"
DocType: Inpatient Record,Admission,ulaz
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Admissions for {0},Upisi 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.,Posljednja poznata uspješna sinkronizacija zaposlenika Checkin. Poništite ovo samo ako ste sigurni da su svi Zapisnici sinkronizirani sa svih lokacija. Molimo nemojte to modificirati ako niste sigurni.
apps/erpnext/erpnext/config/accounting.py,"Seasonality for setting budgets, targets etc.","Sezonska za postavljanje proračuna, ciljevi itd"
apps/erpnext/erpnext/www/all-products/index.html,No values,Nema vrijednosti
DocType: Supplier Scorecard Scoring Variable,Variable Name,Variable Name
apps/erpnext/erpnext/stock/get_item_details.py,"Item {0} is a template, please select one of its variants","Stavka {0} je predložak, odaberite jednu od njegovih varijanti"
DocType: Purchase Invoice Item,Deferred Expense,Odgođeni trošak
apps/erpnext/erpnext/public/js/hub/pages/Messages.vue,Back to Messages,Natrag na poruke
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 može biti prije nego što se zaposlenik pridružio datumu {1}
DocType: Asset,Asset Category,Kategorija Imovine
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Net pay cannot be negative,Neto plaća ne može biti negativna
DocType: Purchase Order,Advance Paid,Unaprijed plaćeni
DocType: Manufacturing Settings,Overproduction Percentage For Sales Order,Postotak prekomjerne proizvodnje za prodajni nalog
DocType: Item Group,Item Tax,Porez proizvoda
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material to Supplier,Materijal za dobavljača
DocType: Soil Texture,Loamy Sand,Loamy Sand
,Lost Opportunity,Izgubljena prilika
DocType: Accounts Settings,Determine Address Tax Category From,Odredite kategoriju adrese poreza od
DocType: Production Plan,Material Request Planning,Planiranje zahtjeva za materijal
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Excise Invoice,Trošarine Račun
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Treshold {0}% appears more than once,Prag {0}% se pojavljuje više od jednom
DocType: Expense Claim,Employees Email Id,Zaposlenici Email ID
DocType: Employee Attendance Tool,Marked Attendance,Označena posjećenost
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Current Liabilities,Kratkoročne obveze
apps/erpnext/erpnext/public/js/projects/timer.js,Timer exceeded the given hours.,Timer je premašio zadani broj sati.
apps/erpnext/erpnext/config/crm.py,Send mass SMS to your contacts,Pošalji grupne SMS poruke svojim kontaktima
DocType: Inpatient Record,A Positive,Pozitivan
DocType: Program,Program Name,Naziv programa
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Razmislite poreza ili pristojbi za
DocType: Driver,Driving License Category,Kategorija licence za vožnju
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Actual Qty is mandatory,Stvarni Količina je obavezno
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} trenutačno ima status dobavljača {1}, a narudžbenice za ovog dobavljača trebaju biti izdane s oprezom."
DocType: Asset Maintenance Team,Asset Maintenance Team,Tim za održavanje imovine
apps/erpnext/erpnext/setup/default_success_action.py,{0} has been submitted successfully,{0} uspješno je poslan
DocType: Loan,Loan Type,Vrsta kredita
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Credit Card,kreditna kartica
DocType: Quality Goal,Quality Goal,Cilj kvalitete
DocType: BOM,Item to be manufactured or repacked,Proizvod će biti proizveden ili prepakiran
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in condition: {0},Pogreška sintakse u stanju: {0}
DocType: Fee Structure,EDU-FST-.YYYY.-,EDU-FST-.YYYY.-
DocType: Employee Education,Major/Optional Subjects,Glavni / Izborni predmeti
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please Set Supplier Group in Buying Settings.,Postavite grupu dobavljača u Postavke kupnje.
DocType: Sales Invoice Item,Drop Ship,Drop Ship
DocType: Driver,Suspended,suspendirana
DocType: Training Event,Attendees,Sudionici
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Ovdje možete održavati obiteljske pojedinosti kao što su ime i okupacije roditelja, supružnika i djecu"
DocType: Academic Term,Term End Date,Pojam Datum završetka
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Porezi i naknade Umanjenja (Društvo valuta)
DocType: Item Group,General Settings,Opće postavke
DocType: Article,Article,Članak
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Od valute i valuta ne mogu biti isti
DocType: Taxable Salary Slab,Percent Deduction,Postotak odbitka
DocType: GL Entry,To Rename,Za preimenovanje
DocType: Stock Entry,Repack,Prepakiraj
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select to add Serial Number.,Odaberite za dodavanje serijskog broja.
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the customer '%s',Molimo postavite fiskalni kod za kupca &#39;% s&#39;
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select the Company first,Najprije odaberite tvrtku
DocType: Item Attribute,Numeric Values,Brojčane vrijednosti
apps/erpnext/erpnext/public/js/setup_wizard.js,Attach Logo,Pričvrstite Logo
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Levels,Stock Razine
DocType: Customer,Commission Rate,Komisija Stopa
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Successfully created payment entries,Uspješno stvorene stavke plaćanja
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Created {0} scorecards for {1} between: ,Izrađeno {0} bodovne kartice za {1} između:
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.py,Not permitted. Please disable the Procedure Template,Nije dopušteno. Isključite predložak postupka
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,"Payment Type must be one of Receive, Pay and Internal Transfer","Vrsta plaćanja mora biti jedan od primati, platiti i unutarnje prijenos"
DocType: Travel Itinerary,Preferred Area for Lodging,Povoljno područje za smještaj
apps/erpnext/erpnext/config/agriculture.py,Analytics,Analitika
DocType: Salary Detail,Additional Amount,Dodatni iznos
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",Stavka {0} nema serijski broj. Samo serijalizirane stavke \ mogu imati isporuku na temelju serijskog br
DocType: Vehicle,Model,Model
DocType: Work Order,Actual Operating Cost,Stvarni operativni trošak
DocType: Payment Entry,Cheque/Reference No,Ček / Referentni broj
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Fetch based on FIFO,Dohvaćanje na temelju FIFO
DocType: Soil Texture,Clay Loam,Clay Loam
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root cannot be edited.,Korijen ne može se mijenjati .
DocType: Item,Units of Measure,Mjerne jedinice
DocType: Employee Tax Exemption Declaration,Rented in Metro City,Iznajmljeno u Metro Cityu
DocType: Supplier,Default Tax Withholding Config,Zadana potvrda zadržavanja poreza
DocType: Manufacturing Settings,Allow Production on Holidays,Dopustite proizvodnje na odmor
DocType: Sales Invoice,Customer's Purchase Order Date,Kupca narudžbenice 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,Kapital
DocType: Asset,Default Finance Book,Zadana knjiga o financiranju
DocType: Shopping Cart Settings,Show Public Attachments,Prikaži javne privitke
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Edit Publishing Details,Uredite pojedinosti o objavljivanju
DocType: Packing Slip,Package Weight Details,Težina paketa - detalji
DocType: Leave Type,Is Compensatory,Je kompenzator
DocType: Restaurant Reservation,Reservation Time,Vrijeme rezervacije
DocType: Payment Gateway Account,Payment Gateway Account,Payment Gateway račun
DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Nakon završetka plaćanja preusmjeriti korisnika na odabranu stranicu.
DocType: Company,Existing Company,postojeće tvrtke
DocType: Healthcare Settings,Result Emailed,Rezultat je poslana e-poštom
DocType: Item Tax Template Detail,Item Tax Template Detail,Detalj predloška predloška poreza
apps/erpnext/erpnext/controllers/buying_controller.py,"Tax Category has been changed to ""Total"" because all the Items are non-stock items",Kategorija poreza promijenjena je u &quot;Ukupno&quot; jer su sve stavke nedopuštene stavke
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,To date can not be equal or less than from date,Do danas ne može biti jednak ili manji od datuma
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Nothing to change,Ništa se ne mijenja
apps/erpnext/erpnext/crm/doctype/lead/lead.py,A Lead requires either a person's name or an organization's name,Voditelj zahtijeva ili ime osobe ili ime organizacije
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please select a csv file,Odaberite CSV datoteku
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Error in some rows,Pogreška u nekim redovima
DocType: Holiday List,Total Holidays,Ukupno praznici
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Missing email template for dispatch. Please set one in Delivery Settings.,Nedostaje predložak e-pošte za slanje. Postavite jedan u Postavke isporuke.
DocType: Student Leave Application,Mark as Present,Označi kao sadašnja
DocType: Supplier Scorecard,Indicator Color,Boja indikatora
DocType: Purchase Order,To Receive and Bill,Za primanje i Bill
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Reqd by Date cannot be before Transaction Date,Redak # {0}: Reqd by Date ne može biti prije datuma transakcije
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Select Serial No,Odaberite serijski broj br
DocType: Pricing Rule,Is Cumulative,Je kumulativno
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Designer,Imenovatelj
apps/erpnext/erpnext/config/buying.py,Terms and Conditions Template,Uvjeti i odredbe - šprance
DocType: Delivery Trip,Delivery Details,Detalji isporuke
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js,Please fill in all the details to generate Assessment Result.,Molimo vas da popunite sve pojedinosti da biste stvorili rezultat procjene.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Cost Center is required in row {0} in Taxes table for type {1},Troška potrebno je u redu {0} poreza stolom za vrstu {1}
DocType: Terms and Conditions,Terms and Conditions Help,Uvjeti za pomoć
,Item-wise Purchase Register,Popis nabave po stavkama
DocType: Loyalty Point Entry,Expiry Date,Datum isteka
DocType: Healthcare Settings,Employee name and designation in print,Ime i oznaka zaposlenika u tisku
apps/erpnext/erpnext/config/buying.py,Supplier Addresses and Contacts,Supplier Adrese i kontakti
,accounts-browser,računi-preglednik
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Please select Category first,Molimo odaberite kategoriju prvi
apps/erpnext/erpnext/config/projects.py,Project master.,Projekt majstor.
DocType: Contract,Contract Terms,Uvjeti ugovora
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Continue Configuration,Nastavite s konfiguracijom
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Ne pokazati nikakav simbol kao $ iza valute.
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Maximum benefit amount of component {0} exceeds {1},Maksimalna naknada komponente {0} prelazi {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py, (Half Day),(Pola dana)
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Master Data,Obradi matične podatke
DocType: Payment Term,Credit Days,Kreditne Dani
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Please select Patient to get Lab Tests,Odaberite Pacijent da biste dobili laboratorijske testove
DocType: Exotel Settings,Exotel Settings,Postavke egzotela
DocType: Leave Ledger Entry,Is Carry Forward,Je Carry Naprijed
DocType: Shift Type,Working hours below which Absent is marked. (Zero to disable),Radno vrijeme ispod kojeg je označeno Odsutno. (Nula za onemogućavanje)
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Send a message,Pošalji poruku
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Get Items from BOM,Kreiraj proizvode od sastavnica (BOM)
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Lead Time Days,Potencijalni kupac - ukupno dana
DocType: Cash Flow Mapping,Is Income Tax Expense,Je li trošak poreza na dohodak
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Your order is out for delivery!,Vaša je narudžba izvan isporuke!
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Red # {0}: datum knjiženja moraju biti isti kao i datum kupnje {1} od {2} imovine
DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,Provjerite je li student boravio u Hostelu Instituta.
DocType: Course,Hero Image,Slika heroja
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Sales Orders in the above table,Unesite prodajni nalozi u gornjoj tablici
,Stock Summary,Stock Sažetak
apps/erpnext/erpnext/config/assets.py,Transfer an asset from one warehouse to another,Prijenos imovine s jednog skladišta na drugo
DocType: Vehicle,Petrol,Benzin
DocType: Employee Benefit Application,Remaining Benefits (Yearly),Preostale pogodnosti (godišnje)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Bill of Materials,Bill of Materials
DocType: Shift Type,The time after the shift start time when check-in is considered as late (in minutes).,Vrijeme nakon početnog vremena smjene kada se prijava smatra kasnim (u minutama).
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Red {0}: Stranka Tip i stranka je potrebno za potraživanja / obveze prema dobavljačima račun {1}
DocType: Employee,Leave Policy,Napusti pravila
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update Items,Ažuriraj stavke
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Ref Date,Ref Datum
DocType: Employee,Reason for Leaving,Razlog za odlazak
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,View call log,Pogledajte dnevnik poziva
DocType: BOM Operation,Operating Cost(Company Currency),Operativni trošak (Društvo valuta)
DocType: Loan Application,Rate of Interest,Kamatna stopa
DocType: Expense Claim Detail,Sanctioned Amount,Iznos kažnjeni
DocType: Item,Shelf Life In Days,Rok trajanja u danima
DocType: GL Entry,Is Opening,Je Otvaranje
DocType: Department,Expense Approvers,Provizori troškova
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Debit entry can not be linked with a {1},Red {0}: debitne unos ne može biti povezan s {1}
DocType: Journal Entry,Subscription Section,Odjeljak za pretplatu
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0} does not exist,Račun {0} ne postoji
DocType: Training Event,Training Program,Program treninga
DocType: Account,Cash,Gotovina
DocType: Sales Invoice,Unpaid and Discounted,Neplaćeno i sniženo
DocType: Employee,Short biography for website and other publications.,Kratka biografija za web stranice i drugih publikacija.
