apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Pension Funds,Penzioni fondovi
DocType: Supplier Quotation,Rounding Adjustment (Company Currency,Prilagodba zaokruživanja (Valuta kompanije
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Course is mandatory in row {0},Kurs je obavezan u redu {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Credit Account,Kreditni račun
DocType: Employee Tax Exemption Proof Submission,Submission Date,Datum podnošenja
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Template Code,Promijenite šifru predloška
DocType: Expense Claim,Total Sanctioned Amount,Ukupno sankcionisani iznos
DocType: Email Digest,New Expenses,Novi troškovi
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Healthcare Practitioner not available on {0},Zdravstveni radnik nije dostupan na {0}
DocType: Delivery Note,Transport Receipt No,Potvrda o prevozu br
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Administrative Officer,Administrativni službenik
DocType: Opportunity,Probability (%),Vjerovatnoća (%)
DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,WooCommerce Products,WooCommerce Proizvodi
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Account Pay Only,Account Pay Only
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Cess,Cess
apps/erpnext/erpnext/config/settings.py,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Postavite standardne vrijednosti kao što su kompanija, valuta, tekuća fiskalna godina, itd."
apps/erpnext/erpnext/config/projects.py,Time Tracking,Praćenje vremena
DocType: Employee Education,Under Graduate,Under Graduate
DocType: Request for Quotation Item,Supplier Part No,Broj dijela dobavljača
DocType: Journal Entry Account,Party Balance,Party Balance
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Source of Funds (Liabilities),Izvor sredstava (obaveza)
DocType: Payroll Period,Taxable Salary Slabs,Oporezive ploče plata
DocType: Quality Action,Quality Feedback,Quality Feedback
DocType: Support Settings,Support Settings,Postavke podrške
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Please enter Production Item first,Prvo unesite proizvodnu stavku
DocType: Quiz,Grading Basis,Grading Basis
DocType: Stock Entry Detail,Basic Amount,Basic Amount
DocType: Journal Entry,Pay To / Recd From,Pay To / Recd From
DocType: BOM,Scrap Material Cost,Troškovi materijala za otpad
DocType: Material Request Item,Received Quantity,Primljena količina
,Sales Person-wise Transaction Summary,Sažetak transakcija za osobu u prodaji
DocType: Work Order,Actual Operating Cost,Stvarni operativni troškovi
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html,Mode of Payments,Način plaćanja
DocType: Stock Entry,Send to Subcontractor,Pošalji podugovaraču
DocType: Purchase Invoice,Select Shipping Address,Izaberite Adresa za otpremu
DocType: Student,AB-,AB-
apps/erpnext/erpnext/projects/doctype/project/project.py,Project Summary for {0},Sažetak projekta za {0}
apps/erpnext/erpnext/regional/india/bank_remittance.py,"{0} is mandatory for generating remittance payments, set the field and try again","{0} je obavezan za generiranje uplata doznaka, postavite polje i pokušajte ponovo"
apps/erpnext/erpnext/public/js/hub/marketplace.js,Some emails are invalid,Neke poruke e-pošte su nevažeće
DocType: Asset,Calculate Depreciation,Izračunaj amortizaciju
DocType: Academic Term,Term Name,Naziv termina
DocType: Question,Question,Pitanje
DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Podkategorija Isključenja
apps/erpnext/erpnext/www/all-products/item_row.html,More Details,Više detalja
DocType: Salary Component,Earning,Sticanje
DocType: Restaurant Order Entry,Click Enter To Add,Kliknite na Enter to Add
DocType: Employee Group,Employee Group,Grupa zaposlenika
DocType: Quality Procedure,Processes,Procesi
DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Navedite devizni kurs za konverziju jedne valute u drugu
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 4,Raspon starenja 4
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Warehouse required for stock Item {0},Potrebna skladišta za zalihu Stavka {0}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Could not solve criteria score function for {0}. Make sure the formula is valid.,Nije moguće riješiti funkciju ocjene kriterija za {0}. Proverite da li je formula validna.
DocType: Bank Reconciliation,Include Reconciled Entries,Uključi usklađene unose
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Omogućite brzinu nulte procene
apps/erpnext/erpnext/templates/includes/product_list.js,Nothing more to show.,Ništa više za pokazati.
apps/erpnext/erpnext/controllers/buying_controller.py,"Tax Category has been changed to ""Total"" because all the Items are non-stock items",Poreska kategorija je promenjena u &quot;Ukupno&quot; jer su sve stavke ne-zaliha
DocType: Salary Detail,Tax on flexible benefit,Porez na fleksibilnu korist
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py,This is based on the Time Sheets created against this project,Ovo se zasniva na vremenskim tabelama kreiranim za ovaj projekat
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Rate,Buying Rate
DocType: Water Analysis,Type of Sample,Tip uzorka
DocType: Budget,Budget Accounts,Računi budžeta
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} quantity {1} cannot be a fraction,Serijska brojka {0} {1} ne može biti frakcija
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock In Hand,Stock In Hand
DocType: Workstation,Wages,Plate
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,No leave record found for employee {0} for {1},Nije pronađen zapis za zaposlenika {0} za {1}
DocType: Invoice Discounting,Accounts Receivable Unpaid Account,Neplaćeni račun potraživanja
DocType: GST Account,SGST Account,SGST Račun
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Datum polu-dana treba da bude između radnog datuma i datuma završetka posla
DocType: Employee Boarding Activity,Applicable in the case of Employee Onboarding,Primjenjivo u slučaju zapošljavanja zaposlenika
apps/erpnext/erpnext/controllers/buying_controller.py,Specified BOM {0} does not exist for Item {1},Navedena sastavnica {0} ne postoji za stavku {1}
apps/erpnext/erpnext/config/accounting.py,Company (not Customer or Supplier) master.,Preduzeće (ne kupac ili dobavljač).
DocType: Shopify Settings,Sales Invoice Series,Serija faktura prodaje
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Asset Movement record {0} created,Zapis pokreta snimljenog materijala {0} je kreiran
DocType: Lab Prescription,Test Created,Test Created
DocType: Academic Term,Term Start Date,Datum početka termina
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Appointment {0} and Sales Invoice {1} cancelled,Sastanak {0} i faktura prodaje {1} otkazana
DocType: Purchase Receipt,Vehicle Number,Broj vozila
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Your email address...,Tvoja e-mail adresa...
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js,Include Default Book Entries,Uključi zadane unose u knjigu
DocType: Activity Cost,Activity Type,Vrsta aktivnosti
DocType: Purchase Invoice,Get Advances Paid,Get Advances Paid
DocType: Company,Gain/Loss Account on Asset Disposal,Račun dobiti / gubitka na raspolaganju
DocType: GL Entry,Voucher No,Vaučer br
DocType: Item,Reorder level based on Warehouse,Promenite nivo na osnovu skladišta
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel",Zaustavljeni radni nalog se ne može poništiti
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 stavku {1}. Dali ste {2}.
DocType: Customer,Customer Primary Contact,Primarni kontakt kupca
DocType: Purchase Order Item Supplied,BOM Detail No,BOM Detail No
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Cash In Hand,Cash In Hand
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 datuma i datuma
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py,Lead must be set if Opportunity is made from Lead,Olovo mora biti postavljeno ako je Opportunity napravljen od Lead
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction can not be converted to group.,Račun sa postojećom transakcijom ne može se pretvoriti u grupu.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Timesheet {0} is already completed or cancelled,Timesheet {0} je već završen ili otkazan
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 uslovi i uslovi koji se mogu dodati u prodaju i kupovinu. Primjeri: 1. Valjanost ponude. 1. Uvjeti plaćanja (unaprijed, kredit, dio avansa itd.). 1. Što je ekstra (ili plaća Korisnik). 1. Upozorenje o sigurnosti / upotrebi. 1. Garancija ako postoji. 1. Politika povrata. 1. Uslovi isporuke, ako je primjenjivo. 1. Načini rješavanja sporova, odšteta, odgovornosti, itd. 1. Adresa i kontakt vaše kompanije."
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Status Notification,Ostavite obaveštenje o statusu
DocType: Designation Skill,Designation Skill,Oznaka Veština
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Količina potrebna za stavku {0} u redu {1}
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"To filter based on Party, select Party Type first","Da biste filtrirali bazu na partiji, prvo odaberite opciju Tip za partiju"
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,No Salary Structure assigned for Employee {0} on given date {1},Struktura plata nije dodeljena zaposlenom {0} na navedeni datum {1}
DocType: Prescription Duration,Number,Broj
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Odvojite grupni kurs za svaku seriju
DocType: Healthcare Settings,Require Lab Test Approval,Zahtevajte odobrenje laboratorijskog testa
DocType: Bank Reconciliation,Update Clearance Date,Datum ažuriranja ažuriranja
DocType: Chart of Accounts Importer,Import Chart of Accounts from a csv file,Uvezite grafikon računa iz CSV datoteke
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 zastarjela. Podesite privatnu aplikaciju, za više detalja pogledajte uputstvo za upotrebu"
DocType: Contract,Signed,Potpisano
DocType: Purchase Invoice,Terms and Conditions1,Uslovi i uslovi1
apps/erpnext/erpnext/hr/doctype/department_approver/department_approver.py,Please select Employee Record first.,Prvo odaberite Zapis zaposlenika.
apps/erpnext/erpnext/hr/doctype/hr_settings/hr_settings.py,Password policy for Salary Slips is not set,Politika lozinki za isplate plata nije postavljena
DocType: Assessment Result Tool,Result HTML,Rezultat HTML
DocType: Agriculture Task,Ignore holidays,Zanemari praznike
DocType: Linked Soil Texture,Linked Soil Texture,Povezana tekstura tla
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py,This is based on logs against this Vehicle. See timeline below for details,Ovo se zasniva na logovima protiv ovog vozila. Za detalje pogledajte vremensku liniju ispod
DocType: Payment Entry,ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-
DocType: Employee,Emergency Contact,Kontakt za hitne slučajeve
DocType: QuickBooks Migrator,Authorization URL,URL autorizacije
DocType: Attendance,On Leave,Na odlasku
DocType: Item,Show a slideshow at the top of the page,Prikažite slideshow na vrhu stranice
DocType: Cheque Print Template,Payer Settings,Payer Settings
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Set Tax Rule for shopping cart,Postavite porezno pravilo za korpe za kupovinu
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,In Production,In Production
DocType: Payment Entry,Payment References,Reference plaćanja
DocType: Fee Validity,Valid Till,Valid Till
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0}: From {0} of type {1},{0}: Od {0} tipa {1}
DocType: Request for Quotation Item,Project Name,ime projekta
DocType: Purchase Invoice Item,Stock Qty,Stock Qty
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Child Item ne bi trebao biti skup proizvoda. Molimo uklonite stavku `{0}` i spremite
DocType: Support Search Source,Response Result Key Path,Ključna putanja rezultata rezultata
DocType: Travel Request,Fully Sponsored,Fully Sponsored
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py,Not permitted. Please disable the Service Unit Type,Nije dozvoljeno. Isključite tip servisne jedinice
DocType: POS Profile,Offline POS Settings,Offline POS postavke
DocType: Supplier Scorecard Period,Calculations,Proračuni
DocType: Production Plan,Material Requested,Traženi materijal
DocType: Payment Reconciliation Payment,Reference Row,Referentni red
DocType: Leave Policy Detail,Annual Allocation,Godišnja dodjela
DocType: Buying Settings,Subcontract,Podugovor
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Valuation type charges can not marked as Inclusive,Troškovi za vrednovanje ne mogu biti označeni kao inkluzivni
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} does not belong to company: {2},Račun {0}: Roditeljski račun {1} ne pripada tvrtki: {2}
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Prijava nije uspela
apps/erpnext/erpnext/config/buying.py,Items and Pricing,Stavke i cijene
DocType: Payment Terms Template,Payment Terms Template,Uvjeti plaćanja
DocType: Employee,Previous Work Experience,Prethodno radno iskustvo
DocType: Assessment Plan,Program,Program
DocType: Antibiotic,Healthcare,Zdravstvo
DocType: Complaint,Complaint,Žalba
DocType: Shipping Rule,Restrict to Countries,Ograničite na zemlje
DocType: Hub Tracked Item,Item Manager,Item Manager
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Currency of the Closing Account must be {0},Valuta završnog računa mora biti {0}
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Budgets,Budžeti
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Opening Invoice Item,Otvaranje stavke fakture
DocType: Work Order,Plan material for sub-assemblies,Planirati materijal za podsklopove
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Hardware,Hardver
DocType: Budget,Action if Annual Budget Exceeded on MR,Akcija ako je godišnji budžet premašen na MR
DocType: Sales Invoice Advance,Advance Amount,Advance Amount
DocType: Accounting Dimension,Dimension Name,Ime dimenzije
DocType: Delivery Note Item,Against Sales Invoice Item,Protiv stavke fakture prodaje
DocType: Expense Claim,HR-EXP-.YYYY.-,HR-EXP-.YYYY.-
DocType: BOM Explosion Item,Include Item In Manufacturing,Uključi stavku u proizvodnji
DocType: Item Reorder,Check in (group),Prijava (grupa)
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Ne prikazujete nijedan simbol kao što je $ etc pored valuta.
DocType: Additional Salary,Salary Component Type,Tip komponente plata
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shareholder does not belong to this company,Akcionar ne pripada ovom društvu
DocType: Payment Term,Day(s) after the end of the invoice month,Dan (a) nakon kraja mjeseca fakture
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Vehicle Type,Tip vozila
DocType: Antibiotic,Healthcare Administrator,Administrator zdravstvene zaštite
DocType: Tax Withholding Rate,Single Transaction Threshold,Prag pojedinačne transakcije
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Broadcasting,Broadcasting
DocType: Support Search Source,Post Title Key,Post Title Key
DocType: Customer,Customer Primary Address,Primarna adresa klijenta
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select batches for batched item ,Molimo Vas da odaberete grupe za paketnu stavku
DocType: Pricing Rule,Min Qty,Min
DocType: Payment Entry,Payment Deductions or Loss,Odbitak plaćanja ili gubitak
DocType: Purchase Taxes and Charges,On Item Quantity,Na količini predmeta
apps/erpnext/erpnext/config/manufacturing.py,Replace BOM and update latest price in all BOMs,Zamijenite BOM i ažurirajte najnoviju cijenu u svim sastavnicama
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Both Trial Period Start Date and Trial Period End Date must be set,Moraju se postaviti i početni datum probnog perioda i datum završetka probnog perioda
apps/erpnext/erpnext/templates/pages/projects.html,No time sheets,Nema vremenskih listova
DocType: Bank Statement Settings,Statement Header Mapping,Mapiranje zaglavlja izjave
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Half Day,Označi pola dana
DocType: Stock Entry,Material Transfer for Manufacture,Prijenos materijala za proizvodnju
DocType: Supplier,Block Supplier,Block Supplier
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter Woocommerce Server URL,Unesite URL adrese Woocommerce servera
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Place,From Place
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,No contacts with email IDs found.,Nisu pronađeni kontakti sa ID-ovima e-pošte.
DocType: Clinical Procedure,Consumption Invoiced,Fakturirana potrošnja
DocType: Bin,Requested Quantity,Tražena količina
DocType: Student,Exit,Izlaz
DocType: Delivery Stop,Dispatch Information,Dispatch Information
DocType: BOM Scrap Item,Basic Amount (Company Currency),Osnovni iznos (valuta kompanije)
DocType: Selling Settings,Selling Settings,Prodajne postavke
apps/erpnext/erpnext/education/doctype/question/question.py,A question must have more than one options,Pitanje mora imati više od jedne opcije
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/public/js/hub/components/profile_dialog.js,About your company,O vašoj kompaniji
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} does not exist,Fiskalna godina {0} ne postoji
DocType: Attendance,Leave Application,Leave Application
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Maintenance Log,Dnevnik održavanja
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid Posting Time,Nevažeće vrijeme slanja
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Discount,Popust
DocType: Sales Invoice,Redeem Loyalty Points,Iskoristi bodove lojalnosti
DocType: Shopping Cart Settings,Quotation Series,Quotation Series
DocType: Guardian,Occupation,Zanimanje
DocType: Item,Opening Stock,Opening Stock
DocType: Supplier Scorecard,Supplier Score,Score Score
DocType: POS Profile,Only show Items from these Item Groups,Prikaži samo stavke iz ovih grupa stavki
DocType: Job Card Time Log,Time In Mins,Vrijeme u min
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Item {0} does not exist in the system or has expired,Stavka {0} ne postoji u sistemu ili je istekla
DocType: Pricing Rule,Price Discount Scheme,Cijene popusta
DocType: Vital Signs,Hyper,Hyper
apps/erpnext/erpnext/public/js/setup_wizard.js,What does it do?,Šta radi?
,Sales Invoice Trends,Trendovi u fakturi prodaje
DocType: Bank Reconciliation,Payment Entries,Platni unosi
DocType: Employee Education,Class / Percentage,Class / Percentage
,Electronic Invoice Register,Elektronski registar faktura
DocType: Shift Type,The number of occurrence after which the consequence is executed.,Broj događaja nakon kojeg se izvršava posljedica.
DocType: Sales Invoice,Is Return (Credit Note),Da li je povratak (kreditna napomena)
DocType: Price List,Price Not UOM Dependent,Price Not UOM Dependent
DocType: Lab Test Sample,Lab Test Sample,Lab Test Sample
DocType: Shopify Settings,status html,status html
DocType: Fiscal Year,"For e.g. 2012, 2012-13","Za npr. 2012, 2012-13"
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,disabled user,onemogućen korisnik
DocType: Amazon MWS Settings,ES,ES
DocType: Warehouse,Warehouse Type,Warehouse Type
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Quick Journal Entry,Quick Journal Entry
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Potrošeni iznos
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Already completed,Već je završeno
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Pending Amount,Iznos na čekanju
DocType: Supplier,Warn RFQs,Warn RFQs
DocType: Lab Prescription,Lab Prescription,Lab Prescription
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Redoslijed amortizacije {0}: Sljedeći datum amortizacije ne može biti prije datuma dostupnosti za upotrebu
DocType: Certification Application,USD,Američki dolar
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,"Asset {0} cannot be scrapped, as it is already {1}","Imovina {0} ne može biti otpisana, jer je već {1}"
DocType: Delivery Trip,Departure Time,Vrijeme odlaska
DocType: Donor,Donor Type,Donor Type
DocType: Company,Monthly Sales Target,Mjesečni cilj prodaje
DocType: Loyalty Point Entry Redemption,Redemption Date,Datum otkupa
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Approving User cannot be same as user the rule is Applicable To,Odobravanje korisnika ne može biti isto što i pravilo koje se primjenjuje na
DocType: Fee Schedule Student Group,Fee Schedule Student Group,Raspored naknada Studentska grupa
apps/erpnext/erpnext/projects/report/billing_summary.py, From Date can not be greater than To Date,Datum ne može biti veći od datuma
apps/erpnext/erpnext/public/js/queries.js,Please specify a {0},Navedite {0}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To GSTIN,To GSTIN
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Datum završetka termina ne može biti ranije od datuma početka termina. Ispravite datume i pokušajte ponovo.
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,No Employee Found,Nije pronađen nijedan zaposlenik
DocType: Employee Tax Exemption Declaration Category,Exemption Category,Kategorija izuzimanja
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Disbursement Entry,Kreirajte unos isplate
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Purpose must be one of {0},Svrha mora biti jedna od {0}
DocType: Content Activity,Last Activity ,Zadnja aktivnost
DocType: Crop Cycle,A link to all the Locations in which the Crop is growing,Veza sa svim lokacijama u kojima raste usjeva
apps/erpnext/erpnext/education/doctype/course_activity/course_activity.py,Course Enrollment {0} does not exists,Upis na kurs {0} ne postoji
apps/erpnext/erpnext/hr/doctype/leave_policy/leave_policy.py,Maximum leave allowed in the leave type {0} is {1},Maksimalno dopušteno odsustvo u tipu odsustva {0} je {1}
,Qty to Transfer,Količina za prijenos
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please identify/create Account (Group) for type - {0},Prepoznajte / kreirajte račun (grupu) za vrstu - {0}
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Please set default customer group and territory in Selling Settings,Molimo vas da postavite podrazumevanu grupu kupaca i teritoriju u postavkama prodaje
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,There isn't any item variant for the selected item,Ne postoji varijanta stavke za odabranu stavku
DocType: Contract,Contract Details,Detalji ugovora
DocType: Customer,"Select, to make the customer searchable with these fields","Odaberite, kako bi korisnik mogao pretraživati s ovim poljima"
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Actual,Total Actual
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Code,Promijeni kod
DocType: Crop,Planting Area,Područje sadnje
DocType: Leave Control Panel,Employee Grade (optional),Ocjena zaposlenika (opcionalno)
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Cost Center For Item with Item Code ',Centar troškova za stavku sa šifrom stavke &quot;
DocType: Stock Settings,Default Stock UOM,Standard Stock UOM
DocType: Workstation,Rent Cost,Rent Cost
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Result,Rezultat treninga
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order not created,Radni nalog nije kreiran
apps/erpnext/erpnext/utilities/user_progress.py,Meter,Meter
DocType: Course,Hero Image,Hero Image
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,No Items to pack,Nema stavki za pakovanje
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Delivery warehouse required for stock item {0},Potrebno skladište dostave za stavku zaliha {0}
apps/erpnext/erpnext/controllers/buying_controller.py,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Rezervirano skladište je obavezno za stavku {0} u isporučenim sirovinama
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Target Location is required for the asset {0},Ciljna lokacija je potrebna za imovinu {0}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,SGST Amount,SGST Iznos
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 Kreditu, nije vam dozvoljeno da postavite &quot;Stanje mora biti&quot; kao &quot;Zaduženje&quot;"
DocType: GSTR 3B Report,GSTR 3B Report,GSTR 3B Izvještaj
DocType: BOM Item,Rate & Amount,Rate &amp; Amount
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To is required,Obavezno je zaduženje
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Item Name,Naziv predmeta
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of New Purchase,Troškovi nove kupovine
DocType: Customer,Additional information regarding the customer.,Dodatne informacije o kupcu.
DocType: Quiz Result,Wrong,Pogrešno
apps/erpnext/erpnext/config/help.py,Batch Inventory,Batch Inventory
DocType: HR Settings,"The salary slip emailed to the employee will be password protected, the password will be generated based on the password policy.","Isplata plata poslata zaposlenom će biti zaštićena lozinkom, lozinka će biti generisana na osnovu politike lozinki."
DocType: Payment Entry,Received Amount,Primljeni iznos
DocType: Item,Is Sales Item,Je prodajna stavka
apps/erpnext/erpnext/accounts/doctype/payment_order/regional/india.js,Generate Text File,Generišite tekstualnu datoteku
DocType: Item,Variants,Varijante
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 biti distribuirani proporcionalno na osnovu količine ili iznosa stavke, prema vašem izboru"
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Pending activities for today,Predstojeće aktivnosti za danas
DocType: Quality Procedure Process,Quality Procedure Process,Proces kvaliteta postupka
DocType: Fee Schedule Program,Student Batch,Student Batch
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Valuation Rate required for Item in row {0},Stopa vrednovanja potrebna za stavku u redu {0}
DocType: BOM Operation,Base Hour Rate(Company Currency),Osnovna satnica (valuta kompanije)
DocType: Job Offer,Printing Details,Printing Details
DocType: Asset Repair,Manufacturing Manager,Voditelj proizvodnje
DocType: BOM,Job Card,Job Card
DocType: Subscription Settings,Prorate,Prorate
DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","ID korisnika sistema (prijava). Ako je postavljeno, postat će zadano za sve HR obrasce."
apps/erpnext/erpnext/public/js/pos/pos.html,All Item Groups,Sve grupe stavki
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Status,Izaberite Status
DocType: Subscription Plan,Fixed rate,Fiksna stopa
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Airline,Airline
DocType: Quotation,Term Details,Detalji termina
DocType: Vehicle,Acquisition Date,Datum sticanja
DocType: SMS Center,Send To,Poslati
apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py,Average Rate,Average Rate
DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Postavite količinu transakcija na osnovu serijskog ulaza
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Advance account currency should be same as company currency {0},Valuta računa avansa mora biti ista kao i valuta kompanije {0}
apps/erpnext/erpnext/portal/doctype/homepage/homepage.js,Customize Homepage Sections,Prilagodite odjeljke početne stranice
DocType: GSTR 3B Report,October,Oktobar
DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Sakrij poreski identifikator kupca iz transakcija prodaje
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! A GSTIN must have 15 characters.,Nevažeći GSTIN! GSTIN mora imati 15 znakova.
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Pricing Rule {0} is updated,Pravilo određivanja cijena {0} je ažurirano
DocType: Contract Fulfilment Checklist,Contract Fulfilment Checklist,Kontrolna lista za ispunjenje ugovora
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py,All Products,Svi proizvodi
apps/erpnext/erpnext/www/all-products/index.html,Product Search,Pretraživanje proizvoda
DocType: Salary Slip,Net Pay,Net Pay
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py,Total Invoiced Amt,Ukupno fakturirano Amt
DocType: Clinical Procedure,Consumables Invoice Separately,Potrošni materijal Faktura odvojeno
DocType: Shift Type,Working Hours Threshold for Absent,Prag radnog vremena za odsustvo
DocType: Appraisal,HR-APR-.YY.-.MM.,HR-APR-.YY.-.MM.
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Budget cannot be assigned against Group Account {0},Budžet ne može biti dodijeljen grupi računa {0}
DocType: Purchase Receipt Item,Rate and Amount,Stopa i iznos
DocType: Patient Appointment,Check availability,Provjera dostupnosti
apps/erpnext/erpnext/public/js/controllers/transaction.js,Cannot find Item with this barcode,Nije moguće pronaći stavku sa ovim barkodom
DocType: Hotel Settings,Default Invoice Naming Series,Određen forumom Invoice Naming Series
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 stavke <b>{2}</b> , šema <b>{3}</b> će se primijeniti na stavku."
DocType: Student Siblings,Student Siblings,Studentska braća i sestre
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Journal Entry {0} does not have account {1} or already matched against other voucher,Unos dnevnika {0} nema nalog {1} ili se već podudara sa drugim vaučerima
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/templates/includes/cart/cart_dropdown.html,Checkout,Provjeri
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Membership Details,Detalji o članstvu
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Customer Address,Postavite adresu klijenta
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 prodajete.
DocType: Account,Income,Prihod
DocType: Account,Rate at which this tax is applied,Stopa po kojoj se ovaj porez primjenjuje
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Payment Receipt Note,Napomena o primanju plaćanja
DocType: Asset Finance Book,In Percentage,In Percentage
apps/erpnext/erpnext/config/buying.py,Quotations received from Suppliers.,Ponude dobijene od dobavljača.
DocType: Journal Entry Account,Reference Due Date,Reference Due Date
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Lead Time Days,Dani vremena vođenja
DocType: Quality Goal,Revision and Revised On,Revizija i Revised On
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Purchase Order {1},{0} protiv Narudžbenice {1}
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py,Fee Records Created - {0},Snimljeni troškovi - {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Note: {0},Napomena: {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} has already been received,Serijski broj {0} je već primljen
DocType: HR Settings,Leave Settings,Leave Settings
DocType: Delivery Note,Issue Credit Note,Kreditna napomena o izdavanju
,Batch Item Expiry Status,Status isteka serije
apps/erpnext/erpnext/config/stock.py,Stock Transactions,Stock Transactions
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html,Event Location,Lokacija događaja
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Motion Picture & Video,Film i video
DocType: Crop,Row Spacing,Razmak između redova
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> Molimo vas da ispravno postavite svoj Kontni plan.
DocType: Cheque Print Template,Starting location from left edge,Početna lokacija s lijeve ivice
DocType: HR Settings,HR Settings,HR Settings
DocType: Healthcare Practitioner,Appointments,Sastanci
apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Kreiran je materijal {0}
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Planned Qty for Item {0} at row {1},Unesite Plansku količinu za stavku {0} u redu {1}
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch,Izaberite Batch
DocType: BOM,Item Description,Opis stavke
DocType: Account,Account Name,Ime računa
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Key,Unesite API Consumer Key
DocType: Products Settings,Products per Page,Proizvodi po stranici
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Duplicate {0} found in the table,Duplikat {0} pronađen u tablici
DocType: Global Defaults,Default Distance Unit,Default Distance Unit
DocType: Clinical Procedure,Consume Stock,Consume Stock
DocType: Appraisal Template Goal,Key Performance Area,Područje ključnih performansi
apps/erpnext/erpnext/selling/report/pending_so_items_for_purchase_request/pending_so_items_for_purchase_request.py,S.O. No.,SO No.
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,{0} not found for item {1},{0} nije pronađen za stavku {1}
DocType: Sales Invoice,Set Source Warehouse,Postavite skladište izvora
DocType: Healthcare Settings,Out Patient Settings,Out Patient Settings
DocType: Asset,Insurance End Date,Datum završetka osiguranja
DocType: Bank Account,Branch Code,Branch Code
apps/erpnext/erpnext/public/js/conf.js,User Forum,Forum korisnika
DocType: Landed Cost Item,Landed Cost Item,Stavka selene cijene
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The seller and the buyer cannot be the same,Prodavac i kupac ne mogu biti isti
DocType: Project,Copied From,Kopirano iz
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Available,Dostupno
DocType: Sales Person,Sales Person Targets,Prodajni ciljevi
DocType: BOM Operation,BOM Operation,Operacija BOM-a
DocType: Student,O-,O-
DocType: Repayment Schedule,Interest Amount,Iznos kamate
DocType: Water Analysis,Origin,Origin
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Add a new address,Dodajte novu adresu
DocType: POS Profile,Write Off Account,Napiši račun
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal/Price Quote,Prijedlog / cijena citat
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Associate,Associate
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Please input all required Result Value(s),Molimo unesite sve tražene vrijednosti rezultata
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Stavka narudžbenice je isporučena
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Item {0} is not a serialized Item,Stavka {0} nije serijalizirana stavka
DocType: GoCardless Mandate,GoCardless Customer,GoCardless Customer
DocType: Leave Encashment,Leave Balance,Leave Balance
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance Schedule {0} exists against {1},Raspored održavanja {0} postoji u odnosu na {1}
DocType: Assessment Plan,Supervisor Name,Ime supervizora
DocType: Selling Settings,Campaign Naming By,Campaign Naming By
DocType: Student Group Creation Tool Course,Course Code,Šifra predmeta
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Aerospace,Aerospace
DocType: Landed Cost Voucher,Distribute Charges Based On,Distribuirajte na bazi naplate
DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Kriterijumi za bodovanje dobavljača rezultata
DocType: Account,Stock,Stock
DocType: Landed Cost Item,Receipt Document Type,Vrsta dokumenta prijema
DocType: Territory,Classification of Customers by region,Klasifikacija kupaca po regionima
DocType: Hotel Room Amenity,Billable,Billable
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Government,Vlada
apps/erpnext/erpnext/utilities/activation.py,"Create Employee records to manage leaves, expense claims and payroll","Kreirajte evidenciju zaposlenika za upravljanje lišćem, potraživanjima troškova i platnim spiskom"
apps/erpnext/erpnext/config/help.py,Point-of-Sale,Mjestu prodaje
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner.py,User {0} is already assigned to Healthcare Practitioner {1},Korisnik {0} je već dodijeljen zdravstvenom radniku {1}
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Buying,Standardna kupovina
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Apprentice,Apprentice
apps/erpnext/erpnext/utilities/activation.py,Add Timesheets,Add Timesheets
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, on će biti uključen u ime računa kao prefiks"
apps/erpnext/erpnext/controllers/buying_controller.py,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Skladište dobavljača obavezno za podugovornu Potvrdu o kupovini
apps/erpnext/erpnext/hr/doctype/employee/employee.js,Please enter Preferred Contact Email,Unesite Preferred Contact Email
DocType: Vital Signs,Normal,Normalno
DocType: Customer,Customer POS Id,ID POS klijenta
DocType: Purchase Invoice Item,Weight Per Unit,Težina po jedinici
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,Child nodes can be only created under 'Group' type nodes,Dječji čvorovi mogu biti kreirani samo pod čvorovima tipa &#39;Grupa&#39;
DocType: Share Transfer,(including),(uključujući)
,Requested,Traženo
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is not a stock Item,Stavka {0} nije dionica
DocType: Journal Entry,Multi Currency,Multi Valuta
DocType: Payment Entry,Write Off Difference Amount,Napiši razliku Iznos razlike
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is disabled,Stavka {0} je onemogućena
DocType: Asset Maintenance Task,Last Completion Date,Poslednji datum završetka
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py,Fulfillment,Ispunjenje
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 upisan kao pozadinski posao. U slučaju bilo kakvog problema u obradi u pozadini, sistem će dodati komentar o grešci na ovom usklađivanju zaliha i vratiti se na fazu nacrta"
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Total Order Considered,Ukupan redosled razmatran
DocType: Delivery Trip,Optimize Route,Optimize Route
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.,Procenat popusta se može primijeniti ili na cjenovnik ili na cjenik.
DocType: Training Event,Trainer Email,Trainer Email
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Get from Patient Encounter,Dođi od susreta sa pacijentom
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Software Developer,Software Developer
DocType: Clinical Procedure Template,Sample Collection,Sample Collection
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',"Molimo vas da podijelite svoje povratne informacije sa obukom klikom na &#39;Povratna informacija treninga&#39;, a zatim &#39;Novo&#39; \ t"
DocType: QuickBooks Migrator,Connecting to QuickBooks,Povezivanje na QuickBooks
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Enrolling student,Upis učenika
DocType: Employee Advance,Claimed,Claimed
apps/erpnext/erpnext/config/hr.py,Leaves,Leaves
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Raspad plata na osnovu zarade i odbitka.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Structure Missing,Nedostaje struktura plata
DocType: Setup Progress Action,Action Field,Polje akcije
,Quotation Trends,Trendovi ponude
apps/erpnext/erpnext/config/integrations.py,Connect Amazon with ERPNext,Povežite Amazon sa ERPNext
DocType: Service Level Agreement,Response and Resolution Time,Vreme odgovora i rezolucije
DocType: Loyalty Program,Collection Tier,Collection Tier
DocType: Guardian,Guardian Of ,Guardian Of
DocType: Payment Request,Payment Gateway Details,Detalji Gateway plaćanja
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}
DocType: Item,Website Warehouse,Website Warehouse
DocType: Sales Invoice Item,Rate With Margin,Rate With Margin
apps/erpnext/erpnext/regional/india/utils.py,Salary Structure must be submitted before submission of Tax Ememption Declaration,Struktura plata mora se podnijeti prije podnošenja Deklaracije o poreskoj olakšici
apps/erpnext/erpnext/public/js/event.js,Add Leads,Add Leads
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reserve Warehouse,Reserve Warehouse
DocType: Payment Term,Payment Term Name,Naziv termina plaćanja
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,No Permission,No Permission
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Company...,Izaberite kompaniju ...
DocType: Stock Settings,Use Naming Series,Koristite Naming Series
DocType: Salary Component,Formula,Formula
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on Actual,Radnja ako je akumulirani mjesečni budžet premašen na stvarnom
DocType: Leave Type,Allow Encashment,Allow Encashment
apps/erpnext/erpnext/config/projects.py,Project activity / task.,Projektna aktivnost / zadatak.
DocType: Bank Statement Transaction Invoice Item,Bank Statement Transaction Invoice Item,Stavka fakture računa transakcije
DocType: Work Order,Total Operating Cost,Ukupni operativni troškovi
DocType: Employee Onboarding,Employee Onboarding Template,Predložak zaposlenika
DocType: Pricing Rule,Same Item,Same Item
apps/erpnext/erpnext/regional/india/bank_remittance.py,"Amount for a single transaction exceeds maximum allowed amount, create a separate payment order by splitting the transactions","Iznos za jednu transakciju prelazi maksimalni dozvoljeni iznos, kreiranjem posebnog platnog naloga razdvajanjem transakcija"
DocType: Payroll Entry,Salary Slips Created,Stvorena je plata
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,Lab Test(s) ,Laboratorijski testovi
DocType: Payment Request,Party Details,Detalji o partiji
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Purchased Items,Troškovi kupljenih artikala
apps/erpnext/erpnext/support/doctype/issue/issue.js,All communications including and above this shall be moved into the new Issue,Sva komunikacija koja uključuje i iznad toga će biti premještena u novo izdanje
DocType: Stock Entry,Material Consumption for Manufacture,Potrošnja materijala za proizvodnju
DocType: Item Website Specification,Table for Item that will be shown in Web Site,Tabela za stavku koja će biti prikazana na Web lokaciji
DocType: Restaurant Menu,Restaurant Menu,Meni restorana
DocType: Asset Movement,Purpose,Svrha
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,Salary Structure Assignment for Employee already exists,Dodjela strukture zarada zaposlenom već postoji
DocType: Clinical Procedure,Service Unit,Servisna jedinica
DocType: Travel Request,Identification Document Number,Broj identifikacijskog dokumenta
DocType: Stock Entry,Additional Costs,Dodatni troškovi
DocType: Employee Education,Employee Education,Obrazovanje zaposlenih
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.js,Number of positions cannot be less then current count of employees,Broj pozicija ne može biti manji od trenutnog broja zaposlenih
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Customer Groups,Sve korisničke grupe
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Price List,Kupovina cjenika
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Finished Good Item Code,Gotova šifra artikla
apps/erpnext/erpnext/controllers/accounts_controller.py,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Postoji više fiskalnih godina za datum {0}. Podesite preduzeće u fiskalnoj godini
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available for use date is required,Potreban je datum raspoloživ za upotrebu
DocType: Employee Training,Training Date,Datum obuke
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Reading Uploaded File
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material Request,Material Request
DocType: Payment Entry,Total Allocated Amount (Company Currency),Ukupni dodijeljeni iznos (valuta kompanije)
DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Restaurant Order Entry Item
DocType: Delivery Stop,Distance,Razdaljina
DocType: Amazon MWS Settings,Get financial breakup of Taxes and charges data by Amazon ,Nabavite finansijske podatke o porezima i naplati podataka od strane Amazona
DocType: Vehicle Service,Mileage,Kilometraža
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/public/js/pos/pos.html,Item Cart,Item Cart
apps/erpnext/erpnext/accounts/utils.py,Payment Entries {0} are un-linked,Unosi za plaćanje {0} nisu povezani
DocType: Email Digest,Open Notifications,Otvori obaveštenja
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Successfully created payment entries,Uspješno kreirani unosi plaćanja
DocType: Soil Analysis,Mg/K,Mg / K
DocType: Item,Has Serial No,Ima serijski br
DocType: Asset Maintenance,Manufacturing User,Manufacturing User
apps/erpnext/erpnext/accounts/doctype/account/account.js,Ledger,Ledger
DocType: Journal Entry Account,Loan,Zajam
DocType: Vehicle,Fuel UOM,Fuel UOM
DocType: Issue,Support,Podrška
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid Company for Inter Company Transaction.,Nevažeća kompanija za međubankarsku transakciju.
DocType: Company,Fixed Asset Depreciation Settings,Postavke amortizacije fiksne imovine
DocType: Employee,Department and Grade,Odjel i razred
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Cheques Required,Potrebni čekovi
DocType: Lead,Do Not Contact,Ne kontaktirajte
DocType: Sales Invoice,Update Billed Amount in Sales Order,Ažurirajte naplaćeni iznos u prodajnom nalogu
DocType: Travel Itinerary,Meal Preference,Meal Preference
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 pravila za određivanje cijena s najvišim prioritetom, primjenjuju se sljedeći interni prioriteti:"
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} is not active or does not exist,Zaposlenik {0} nije aktivan ili ne postoji
apps/erpnext/erpnext/config/accounting.py,List of all share transactions,Popis svih transakcija dionica
DocType: Item Default,Sales Defaults,Default Defaults
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}
DocType: Course Assessment Criteria,Weightage,Težina
DocType: Bank Statement Transaction Entry,Create New Payment/Journal Entry,Napravite novi unos plaćanja / dnevnika
DocType: Attendance,HR-ATT-.YYYY.-,HR-ATT-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Ako se na osnovu gore navedenih uslova nađu dva ili više Pravila za određivanje cijena, primjenjuje se Prioritet. Prioritet je broj između 0 i 20, dok je zadana vrijednost nula (prazno). Veći broj znači da će imati prednost ako postoje višestruka pravila za određivanje cijena sa istim uvjetima."
apps/erpnext/erpnext/controllers/selling_controller.py,Row {0}: Qty is mandatory,Red {0}: Količina je obavezna
DocType: Sales Invoice,Against Income Account,Protiv računa prihoda
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Red # {0}: Faktura kupovine ne može biti napravljena protiv postojeće imovine {1}
apps/erpnext/erpnext/config/buying.py,Rules for applying different promotional schemes.,Pravila za primjenu različitih promotivnih programa.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,UOM coversion factor required for UOM: {0} in Item: {1},Faktor pokrivanja UOM-a potreban za UOM: {0} u stavci: {1}
apps/erpnext/erpnext/buying/utils.py,Please enter quantity for Item {0},Unesite količinu za stavku {0}
DocType: Workstation,Electricity Cost,Cijena električne energije
DocType: Vehicle Service,Vehicle Service,Vehicle Service
apps/erpnext/erpnext/config/help.py,Making Stock Entries,Making Stock Entries
DocType: Bank Guarantee,Fixed Deposit Number,Broj fiksnog depozita
DocType: Vital Signs,Very Coated,Very Coated
DocType: Delivery Trip,Initial Email Notification Sent,Početno slanje obavijesti e-poštom
DocType: Production Plan,For Warehouse,Za skladište
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,"{0}: Employee email not found, hence email not sent","{0}: E-pošta zaposlenika nije pronađena, stoga e-pošta nije poslata"
DocType: Currency Exchange,From Currency,Iz valute
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Return / Debit Note,Povratna / debitna napomena
DocType: Homepage Section,"Order in which sections should appear. 0 is first, 1 is second and so on.","Red u kojem se odeljci pojavljuju. 0 je prvo, 1 je drugo i tako dalje."
apps/erpnext/erpnext/utilities/activation.py,Create Sales Orders to help you plan your work and deliver on-time,Napravite narudžbe za prodaju kako biste lakše planirali svoj rad i isporučili ga na vrijeme
apps/erpnext/erpnext/templates/includes/cart.js,Something went wrong!,Nešto je pošlo po zlu!
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Healthcare Service,Molimo Vas da odaberete Zdravstvenu službu
DocType: Leave Application,Apply / Approve Leaves,Primijeni / odobri lišće
DocType: Leave Block List,Applies to Company,Odnosi se na kompaniju
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Row {0}: Bill of Materials not found for the Item {1},Red {0}: Materijal koji nije pronađen za stavku {1}
DocType: Loan,Account Info,Informacije o računu
DocType: Item Attribute Value,Abbreviation,Skraćenica
DocType: Email Digest,Purchase Orders to Bill,Narudžbenice za Bill
DocType: Purchase Invoice,Total Net Weight,Ukupna neto težina
DocType: Authorization Rule,Approving Role (above authorized value),Uloga odobravanja (iznad dozvoljene vrijednosti)
DocType: Employee Advance,HR-EAD-.YYYY.-,HR-EAD-.YYYY.-
DocType: Job Applicant,Resume Attachment,Resume Attachment
DocType: Agriculture Analysis Criteria,Agriculture Manager,Manager za poljoprivredu
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batch Entries,Batch Entries
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,Molimo omogućite Primjenjivo na narudžbenici i primjenjive na stvarne troškove rezervacije
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Gain/Loss on Asset Disposal,Dobitak / gubitak na raspolaganju
DocType: Loan,Total Payment,Ukupno plaćanje
DocType: Asset,Total Number of Depreciations,Ukupan broj amortizacije
DocType: Asset,Fully Depreciated,Fully Depreciated
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Creating Accounts,Kreiranje računa
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant Settings,Postavka varijante stavke
DocType: Supplier Group,Supplier Group Name,Naziv grupe dobavljača
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,Sales Price List,Prodajni cenovnik
DocType: Email Digest,How frequently?,Koliko često?
DocType: Purchase Invoice,Supplier Warehouse,Skladište dobavljača
DocType: Salary Component,Only Tax Impact (Cannot Claim But Part of Taxable Income),Samo poreski uticaj (ne može se tvrditi da je deo oporezivog prihoda)
DocType: Item Default,Purchase Defaults,Default Defaults
DocType: Contract,Contract Template,Predložak ugovora
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Batch {1},Serijski broj {0} ne pripada Batch {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Pending Leaves,Pending Leaves
DocType: Student Applicant,Applied,Applied
DocType: Clinical Procedure,Consumption Details,Detalji potrošnje
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.html,Loading Payment System,Učitavanje platnog sistema
DocType: Assessment Plan,Maximum Assessment Score,Maximum Score Score
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Status Notification in HR Settings.,Molimo postavite zadani predložak za Obavijest o ostavljanju statusa u HR postavkama.
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Report Card,Studentska iskaznica
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Nature Of Supplies,Nature of Supplies
DocType: Shopify Settings,Last Sync Datetime,Last Sync Datetime
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Code {0} already exist,Kod {0} već postoji
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Based On Payment Terms,Na osnovu uslova plaćanja
DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Ova vrijednost se ažurira u Zadana prodajna cijena.
DocType: Special Test Template,Special Test Template,Specijalni predložak za testiranje
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Create Varijante
DocType: Item Default,Default Expense Account,Default Expense Account
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py,Please setup Students under Student Groups,Molimo vas da podesite učenike u okviru studentskih grupa
apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Oporezivi iznos
DocType: Lead,Lead Owner,Vodeći vlasnik
DocType: Share Transfer,Transfer,Transfer
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Search Item (Ctrl + i),Stavka pretraživanja (Ctrl + i)
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,{0} Result submittted,{0} Rezultat je poslan
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 datuma Do
DocType: Supplier,Supplier of Goods or Services.,Dobavljač robe ili usluga.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Ime novog računa. Napomena: Molimo vas da ne stvarate račune za kupce i dobavljače
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Student Group or Course Schedule is mandatory,Studentska grupa ili raspored kursa je obavezan
DocType: Tax Rule,Sales Tax Template,Šablon poreza na promet
DocType: BOM,Routing,Usmjeravanje
DocType: Payment Reconciliation,Payment Reconciliation,Usklađivanje plaćanja
apps/erpnext/erpnext/config/accounting.py,Match non-linked Invoices and Payments.,Odgovaraju nepovezanim fakturama i plaćanjima.
apps/erpnext/erpnext/utilities/user_progress.py,Opening Balances,Otvaranje stanja
DocType: Supplier,PAN,PAN
DocType: Work Order,Operation Cost,Operativni trošak
DocType: Bank Guarantee,Name of Beneficiary,Ime korisnika
apps/erpnext/erpnext/public/js/templates/address_list.html,New Address,New Address
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 su već planirale za {1} slobodnih radnih mjesta u proračunu od {2}. Kadrovski plan za {0} treba da rasporedi više slobodnih radnih mjesta i budžet za {3} nego što je planirano za njegove podružnice
DocType: Stock Entry,From BOM,From BOM
DocType: Program Enrollment Tool,Student Applicant,Student Applicant
DocType: Leave Application,Leave Balance Before Application,Ostavite ravnotežu prije primjene
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Expiry date is mandatory for selected item,Datum isteka je obavezan za odabranu stavku
DocType: Stock Entry,Default Target Warehouse,Default Target Warehouse
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Show Salary Slip,Prikaži isplatu plata
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py,Percentage Allocation should be equal to 100%,Raspodela procenta treba da bude 100%
DocType: Purchase Invoice Item,UOM Conversion Factor,UOM konverzijski faktor
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Stock cannot be updated against Purchase Receipt {0},Stock nije moguće ažurirati u odnosu na potvrdu o kupnji {0}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Item Row {0}: {1} {2} does not exist in above '{1}' table,Red retka {0}: {1} {2} ne postoji u tabeli iznad {{1} &#39;
DocType: Asset Maintenance Task,2 Yearly,2 Godišnje
DocType: Guardian Student,Guardian Student,Guardian Student
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 otvarajući račun u Kontni plan
DocType: Account,Include in gross,Uključi u bruto
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Serial Numbers,Izaberite Serijski brojevi
DocType: Tally Migration,UOMs,UOMs
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Red {0}: Partija / Račun se ne podudara s {1} / {2} u {3} {4}
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid reference {0} {1},Nevažeća referenca {0} {1}
DocType: Quality Action,Corrective/Preventive,Korektivna / preventivna
DocType: Work Order Operation,Work In Progress,Posao u izradi
DocType: Bank Reconciliation,Account Currency,Valuta računa
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,credit_note_amt,credit_note_amt
DocType: Setup Progress Action,Action Name,Naziv akcije
DocType: Employee,Health Insurance,Zdravstveno osiguranje
DocType: Student Group,Max Strength,Maksimalna snaga
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate customer group found in the cutomer group table,Udvostručena grupa kupaca pronađena u tablici grupnih cutomera
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}","Ostaviti se ne može primijeniti / otkazati prije {0}, jer je balans dopusta već prenesen u budućem zapisu za dodjelu dopusta {1}"
DocType: Promotional Scheme Price Discount,Min Amount,Min iznos
DocType: Sales Invoice Item,Rate With Margin (Company Currency),Stopa sa marginom (valuta kompanije)
DocType: Lead,Follow Up,Follow Up
DocType: Tax Rule,Shipping Country,Zemlja transporta
DocType: Delivery Note,Track this Delivery Note against any Project,Pratite ovu dostavnicu sa bilo kojim projektom
DocType: Company,Default Payroll Payable Account,Default Payroll Payable Account
DocType: Drug Prescription,Update Schedule,Raspored ažuriranja
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Updating estimated arrival times.,Ažuriranje predviđenog vremena dolaska.
DocType: Asset Category,Finance Book Detail,Finance Book Detail
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Serial No {0} does not belong to Delivery Note {1},Serijski broj {0} ne pripada napomeni za isporuku {1}
apps/erpnext/erpnext/regional/italy/utils.py,Please set Tax ID for the customer '%s',Postavite porezni broj za klijenta &quot;% s&quot;
DocType: Sales Partner,Logo,Logo
DocType: Leave Type,Include holidays within leaves as leaves,Uključite praznike u lišće kao lišće
DocType: Shift Assignment,Shift Request,Shift Request
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py,"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Ne može da se označi ispražnjena bolnička evidencija, postoje neobračunate fakture {0}"
DocType: QuickBooks Migrator,Scope,Scope
DocType: Purchase Invoice Item,Service Stop Date,Datum zaustavljanja usluge
DocType: Article,Publish Date,Datum objave
DocType: Student,O+,O +
DocType: BOM,Work Order,Radni nalog
DocType: Bank Statement Transaction Settings Item,Transaction,Transakcija
DocType: Workstation,per hour,na sat
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,This action will stop future billing. Are you sure you want to cancel this subscription?,Ova akcija će zaustaviti buduće naplate. Jeste li sigurni da želite otkazati ovu pretplatu?
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,State/UT Tax,Porez na državu / UT
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py,Scorecards,Scorecards
,Projected Quantity as Source,Predviđena količina kao izvor
DocType: Supplier Group,Parent Supplier Group,Grupa dobavljača roditelja
apps/erpnext/erpnext/controllers/accounts_controller.py,Rows with duplicate due dates in other rows were found: {0},Pronađeni su redovi s dupliciranim datumima u drugim redovima: {0}
DocType: Fees,EDU-FEE-.YYYY.-,EDU-FEE-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Chart Of Accounts Template,Predložak grafikona računa
DocType: Lead,Lead,Lead
DocType: Appraisal Template Goal,KRA,KRA
apps/erpnext/erpnext/utilities/user_progress.py,Setup Institution,Institucija instalacije
,Salary Register,Registar plata
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šeslojnog programa, korisnici će biti automatski dodijeljeni dotičnom nivou prema njihovim utrošenim troškovima"
DocType: Bank Reconciliation Detail,Posting Date,Datum objave
DocType: Upload Attendance,Attendance From Date,Prisustvo od datuma
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} su različiti.
DocType: GST Settings,GST Summary,GST Summary
DocType: Education Settings,Make Academic Term Mandatory,Obaviti akademski mandat
DocType: Vehicle,Odometer Value (Last),Vrednost kilometraže (zadnja)
apps/erpnext/erpnext/config/assets.py,Transfer an asset from one warehouse to another,Prenesite imovinu iz jednog skladišta u drugo
DocType: Room,Seating Capacity,Kapacitet sjedenja
DocType: Employee Benefit Application Detail,Employee Benefit Application Detail,Detalji o aplikaciji za zaposlene
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Employee {0} has already applied for {1} between {2} and {3} : ,Zaposleni {0} se već prijavio za {1} između {2} i {3}:
DocType: Asset Category Account,Capital Work In Progress Account,Kapitalni rad na računu napretka
DocType: Employee Benefit Claim,Benefit Type and Amount,Vrsta i iznos pogodnosti
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Please set default payable account for the company {0},Molimo vas da postavite nalog za plaćanje za tvrtku {0}
DocType: Daily Work Summary Group,Holiday List,Holiday List
DocType: Job Card,Total Time in Mins,Ukupno vrijeme u min
DocType: Shipping Rule,Shipping Amount,Količina isporuke
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Absent,Total Absent
DocType: Fee Validity,Reference Inv,Reference Inv
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Row {0}: {1} is required to create the Opening {2} Invoices,Red {0}: {1} je potreban za kreiranje otvaranja {2} faktura
DocType: Bank Account,Is Company Account,Je račun kompanije
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Do you want to notify all the customers by email?,Želite li obavijestiti sve kupce putem e-pošte?
DocType: Opening Invoice Creation Tool,Sales,Prodaja
DocType: Vital Signs,Tongue,Jezik
DocType: Journal Entry,Excise Entry,Entise Entry
apps/erpnext/erpnext/www/all-products/index.html,Clear filters,Obriši filtere
DocType: Delivery Trip,In Transit,U prolazu
apps/erpnext/erpnext/stock/doctype/item/item.py,Barcode {0} is not a valid {1} code,Barkod {0} nije važeći {1} kôd
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Balance for Account {0} must always be {1},Stanje za račun {0} mora uvijek biti {1}
apps/erpnext/erpnext/public/js/controllers/transaction.js,Invalid Blanket Order for the selected Customer and Item,Nevažeća narudžbenica za odabrani kupac i stavku
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, sistem će kreirati radni nalog za eksplodirane stavke prema kojima je sastavnica dostupna."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Product Bundle,Paket proizvoda
DocType: Exchange Rate Revaluation Account,New Exchange Rate,Novi kurs
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open To Do,Open To Do
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Receiver List is empty. Please create Receiver List,Lista prijemnika je prazna. Kreirajte listu prijemnika
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Current Liabilities,Tekuće obaveze
apps/erpnext/erpnext/templates/pages/demo.html,ERPNext Demo,ERPNext Demo
DocType: Patient,Other Risk Factors,Ostali faktori rizika
DocType: Item Attribute,To Range,To Range
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} applicable after {1} working days,{0} primjenjivo nakon {1} radnih dana
DocType: Task,Task Description,Opis zadatka
DocType: Bank Account,SWIFT Number,SWIFT broj
DocType: Accounts Settings,Show Payment Schedule in Print,Prikaži raspored plaćanja u Printu
DocType: Purchase Invoice,Apply Tax Withholding Amount,Primijeniti iznos zadržavanja poreza
DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Stanje dobavljača rezultata dobavljača
DocType: Quality Inspection Reading,Quality Inspection Reading,Čitanje inspekcije kvaliteta
DocType: Healthcare Settings,Valid number of days,Važeći broj dana
DocType: Production Plan Item,material_request_item,material_request_item
DocType: Installation Note,MAT-INS-.YYYY.-,MAT-INS-.YYYY.-
DocType: Healthcare Settings,Custom Signature in Print,Prilagođeni potpis u štampi
DocType: Patient Encounter,Procedures,Procedure
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Issues,Otvorena pitanja
DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Serija za unos amortizacije imovine (unos dnevnika)
DocType: Healthcare Service Unit,Occupancy Status,Status zauzetosti
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Privilege Leave,Privilege Leave
DocType: Subscription,Current Invoice End Date,Trenutni datum završetka fakture
DocType: Sample Collection,Collected Time,Collected Time
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please select BOM for Item in Row {0},Odaberite BOM za stavku u retku {0}
DocType: Department,Expense Approver,Expense Approver
DocType: Bank Statement Transaction Entry,New Transactions,Nove transakcije
apps/erpnext/erpnext/hr/report/loan_repayment/loan_repayment.py,Payable Amount,Plaćeni iznos
DocType: SMS Center,All Supplier Contact,Svi kontakti dobavljača
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Quotation {0} not of type {1},Ponuda {0} nije tipa {1}
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,Leave Type {0} is not encashable,Tip ostavljanja {0} nije moguće prebaciti
DocType: Contract,Fulfilment Status,Status ispunjenja
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Unsubscribe from this Email Digest,Otkažite pretplatu na ovu adresu e-pošte
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.py,{0} {1} created,Napravljeno je {0} {1}
DocType: Water Analysis,Person Responsible,Odgovorna osoba
DocType: Asset,Asset Category,Kategorija imovine
DocType: Stock Settings,Limit Percent,Limit Percent
DocType: Cash Flow Mapping Accounts,Cash Flow Mapping Accounts,Računi mapiranja novčanog toka
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Select Serial No,Izaberite Serijski broj
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Povratak prodaje
apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py,No record found,Nije pronađen nijedan zapis
DocType: Department,Expense Approvers,Odobreni troškovi
DocType: Purchase Invoice,Group same items,Grupirajte iste stavke
DocType: Company,Parent Company,Matično preduzeće
DocType: Daily Work Summary Group,Reminder,Podsetnik
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Bank Overdraft Account,Račun prekoračenja banaka
DocType: Journal Entry,Difference (Dr - Cr),Razlika (Dr - Cr)
apps/erpnext/erpnext/stock/doctype/item/item.py,"An Item Group exists with same name, please change the item name or rename the item group","Grupa proizvoda postoji sa istim imenom, promijenite naziv stavke ili preimenujte grupu stavki"
DocType: Student,B+,B +
apps/erpnext/erpnext/controllers/buying_controller.py,Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Sljedeća stavka {0} nije označena kao {1} stavka. Možete ih omogućiti kao {1} stavku iz matične stavke
DocType: Healthcare Service Unit,Allow Overlap,Allow Overlap
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 u rasponu od {1} do {2} u koracima od {3} za stavku {4}
DocType: Timesheet,Billing Details,Detalji o naplati
DocType: Quality Procedure Table,Quality Procedure Table,Tabela procedura kvaliteta
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} created,Kreiran je serijski broj {0}
DocType: Warehouse,Warehouse Detail,Warehouse Detail
DocType: Sales Order,To Deliver and Bill,Da isporuči i Bill
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Dodano detaljima
apps/erpnext/erpnext/public/js/hub/marketplace.js,Add Users to Marketplace,Dodajte korisnike na tržište
DocType: Healthcare Settings,Remind Before,Podsjeti prije
DocType: Healthcare Settings,Manage Customer,Manage Customer
DocType: Loyalty Program Collection,Tier Name,Tier Name
DocType: Manufacturing Settings,Manufacturing Settings,Proizvodne postavke
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,Taken,Taken
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select Start Date and End Date for Item {0},Odaberite Datum početka i Datum završetka za stavku {0}
DocType: Education Settings,Education Settings,Education Settings
DocType: Student Admission,Admission End Date,Datum završetka prijema
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} vredi stavku <b>{2}</b> , šema <b>{3}</b> će biti primenjena na stavku."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Please specify Company to proceed,Molimo navedite tvrtku za nastavak
DocType: Asset Maintenance Team,Asset Maintenance Team,Tim za održavanje imovine
DocType: Production Plan Material Request,Material Request Date,Datum zahtjeva za materijal
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Responsibilities,Odgovornosti
DocType: Project,Total Costing Amount (via Timesheets),Ukupni iznos troškova (putem timesheets)
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Uvoz stavki i UOM-ova
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Leaves per Year,Lišće godišnje
DocType: Student,Date of Leaving,Datum odlaska
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,Export E-Invoices,Izvoz E-računa
DocType: Healthcare Settings,Laboratory SMS Alerts,Laboratorijska SMS upozorenja
DocType: Program,Is Published,Is Published
DocType: Clinical Procedure,Healthcare Practitioner,Healthcare Practitioner
apps/erpnext/erpnext/stock/get_item_details.py,Item Price updated for {0} in Price List {1},Stavka Cijena ažurirana za {0} u cjeniku {1}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Boručna stavka {0} ne može biti ažurirana pomoću usklađivanja zaliha, umjesto toga koristite unos dionica"
DocType: Employee External Work History,Total Experience,Total Experience
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material to Supplier,Materijal za dobavljača
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Customer is required against Receivable account {2},{0} {1}: Korisnik je obavezan protiv računa potraživanja {2}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Healthcare Services,Zdravstvene usluge
DocType: Grading Scale Interval,Grade Code,Code Grade
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Sastanci i susreti sa pacijentima
,TDS Computation Summary,TDS Computation Summary
DocType: Shipping Rule,Shipping Rule Label,Oznaka pravila dostave
DocType: Buying Settings,Supplier Naming By,Imenovanje dobavljača
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Admissions for {0},Prijave za {0}
DocType: Loan,Loan Details,Detalji kredita
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} on Half day on {1},Zaposleni {0} na pola dana {1}
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_sub_category/employee_tax_exemption_sub_category.py,Max Exemption Amount cannot be greater than maximum exemption amount {0} of Tax Exemption Category {1},Maksimalni iznos izuzeća ne može biti veći od maksimalne iznosa izuzeća {0} od kategorije oslobođenja od poreza {1}
apps/erpnext/erpnext/hr/utils.py,Please set leave policy for employee {0} in Employee / Grade record,Postavite politiku ostavljanja za zaposlenika {0} u evidenciji o zaposleniku / razredu
DocType: Bank Reconciliation Detail,Cheque Number,Broj za provjeru
,Prospects Engaged But Not Converted,"Izgledi angažovani, ali nisu pretvoreni"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Liabilities,Obaveze po dionicama
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py,-Above,Iznad
DocType: Item Website Specification,Item Website Specification,Specifikacija Web lokacije
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 konzumirati kao što je rezervisana za popunjeni prodajni nalog {2}.
DocType: Vehicle,Electric,Electric
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 se pojavljuje više puta na temelju cjenika, dobavljača / kupca, valute, predmeta, UOM-a, broja i datuma."
DocType: Stock Ledger Entry,Stock Ledger Entry,Stock Ledger Entry
DocType: HR Settings,Email Salary Slip to Employee,Pošalji e-mail plaću za zaposlenika
DocType: Stock Entry,Delivery Note No,Napomena o isporuci br
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Timeslots,Add Timeslots
DocType: Packing Slip Item,Packing Slip Item,Jedinica pakovanja
DocType: Payroll Period,Standard Tax Exemption Amount,Standardni iznos oslobađanja od poreza
apps/erpnext/erpnext/config/help.py,Serialized Inventory,Serialized Inventory
DocType: Contract,Requires Fulfilment,Zahteva ispunjenje
DocType: Quality Inspection,MAT-QA-.YYYY.-,MAT-QA-.YYYY.-
DocType: Bank Statement Transaction Entry,Receivable Account,Račun potraživanja
DocType: Website Attribute,Website Attribute,Website Attribute
apps/erpnext/erpnext/public/js/templates/address_list.html,No address added yet.,Još nijedna adresa nije dodana.
DocType: Sales Order,Partly Billed,Delimično naplaćeno
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,Customer isn't enrolled in any Loyalty Program,Korisnik nije uključen u bilo koji program lojalnosti
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Jobs,Poslovi
DocType: Expense Claim,Approval Status,Status odobrenja
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Opening Qty,Opening Qty
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 strukture plata za sljedeće zaposlenike, jer postoje zapisi o rasporedu plaća. {0}"
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Datum završetka termina ne može biti kasnije od datuma završetka godine akademske godine na koju je termin povezan (akademska godina {}). Ispravite datume i pokušajte ponovo.
DocType: Purchase Order,% Billed,% Naplaćeno
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Variance,Total Variance
apps/erpnext/erpnext/support/doctype/issue/issue.js,Split Issue,Split Issue
DocType: Item Default,Default Supplier,Default Supplier
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Base,Base
apps/erpnext/erpnext/config/accounting.py,Share Management,Share Management
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Sales Order {0} is not valid,Prodajni nalog {0} nije važeći
DocType: Leave Control Panel,Branch (optional),Branch (opcionalno)
DocType: Bank Reconciliation Detail,Clearance Date,Datum odobrenja
DocType: Supplier Scorecard Period,Criteria,Kriteriji
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Podignite zahtev za materijal kada zaliha dostigne nivo re-order
,Campaign Efficiency,Efikasnost kampanje
apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Create Timesheet
DocType: Employee,Internal Work History,Interna radna istorija
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Select Target Warehouse,Izaberite Target Warehouse
DocType: Subscription Settings,Grace Period,Grace Period
DocType: Patient,Married,Oženjen
DocType: Work Order Item,Available Qty at Source Warehouse,Dostupan komad na skladištu izvora
DocType: Shipping Rule Country,Shipping Rule Country,Država Pravila Dostave
DocType: Delivery Stop,Email Sent To,Email Sent To
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Material Consumption,Potrošnja materijala
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Nothing to change,Ništa za promjenu
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,No Lab Test created,Nije napravljen laboratorijski test
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maksimalni uzorci - {0} su već zadržani za Batch {1} i stavku {2} u Batch {3}.
apps/erpnext/erpnext/setup/doctype/company/company.py,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Nije moguće promijeniti zadanu valutu tvrtke, jer postoje postojeće transakcije. Transakcije moraju biti otkazane da biste promenili podrazumevanu valutu."
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
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 dodjele tipa {0} za zaposlenika {1} u periodu
DocType: Stock Entry,Update Rate and Availability,Brzina ažuriranja i dostupnost
DocType: Item Variant Attribute,Item Variant Attribute,Atribut varijante stavke
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Dostupan broj partija iz skladišta
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Popust (%) na kursnu listu sa marginom
DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,Proverite da li Asset zahteva preventivno održavanje ili kalibraciju
DocType: Lab Test,Technician Name,Ime tehničara
DocType: Lab Test Groups,Normal Range,Normal Range
DocType: Item,Total Projected Qty,Ukupna projicirana količina
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Boms,Boms
DocType: Work Order,Actual Start Date,Stvarni datum početka
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,You are not present all day(s) between compensatory leave request days,Vi niste prisutni cijeli dan (a) između dana za kompenzacijsko odsustvo
apps/erpnext/erpnext/config/accounting.py,Tree of financial accounts.,Stablo finansijskih računa.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Indirect Income,Indirektni prihodi
DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,Rezervacija za hotelsku sobu
DocType: Course Scheduling Tool,Course Start Date,Datum početka kursa
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Sell,Sell
DocType: Support Search Source,Post Route String,Post Route String
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Electrical,Električni
DocType: Journal Entry,Total Debit,Total Debit
DocType: Guardian,Guardian,Guardian
DocType: Share Transfer,Transfer Type,Tip prenosa
apps/erpnext/erpnext/config/crm.py,Database of potential customers.,Baza potencijalnih kupaca.
DocType: Skill,Skill Name,Ime veštine
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js,Print Report Card,Print Report Card
DocType: Soil Texture,Ternary Plot,Ternary Plot
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Support Tickets,Support Tickets
DocType: Asset Category Account,Fixed Asset Account,Račun fiksnih sredstava
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Latest,Najnoviji
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Pošaljite isplatu plate
DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Brzina pulsa odraslih je između 50 i 80 otkucaja u minuti.
DocType: Program Enrollment Course,Program Enrollment Course,Program upisa programa
,IRS 1099,IRS 1099
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set the series to be used.,Podesite seriju koja će se koristiti.
DocType: Delivery Trip,Distance UOM,Udaljenost UOM
DocType: Accounting Dimension,Mandatory For Balance Sheet,Obavezno za bilans stanja
DocType: Payment Entry,Total Allocated Amount,Ukupni dodijeljeni iznos
DocType: Sales Invoice,Get Advances Received,Dobili napredak
DocType: Shift Type,Last Sync of Checkin,Last Sync of Checkin
DocType: Student,B-,B-
DocType: Purchase Invoice Item,Item Tax Amount Included in Value,Stavka Iznos poreza uključen u vrijednost
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}: Faktura {1} je nevažeća, može biti otkazana / ne postoji. Unesite važeću fakturu"
DocType: Subscription Plan,Subscription Plan,Plan pretplate
DocType: Student,Blood Group,Krvna grupa
apps/erpnext/erpnext/config/healthcare.py,Masters,Masters
DocType: Crop,Crop Spacing UOM,Izrezivanje razmaka UOM
DocType: Shift Type,The time after the shift start time when check-in is considered as late (in minutes).,"Vrijeme nakon početka smjene, kada se check-in smatra zakašnjenjem (u minutama)."
apps/erpnext/erpnext/templates/pages/home.html,Explore,Istražiti
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,No outstanding invoices found,Nisu pronađene nepodmirene fakture
DocType: Promotional Scheme,Product Discount Slabs,Ploče s popustima za proizvode
DocType: Hotel Room Package,Amenities,Amenities
DocType: Lab Test Groups,Add Test,Dodaj test
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Cannot return more than {1} for Item {2},Red # {0}: Nije moguće vratiti više od {1} za stavku {2}
DocType: Student Leave Application,Student Leave Application,Application Leave Student
apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py,Repayment amount {} should be greater than monthly interest amount {},Iznos otplate {} treba biti veći od mjesečnog iznosa kamate {}
DocType: Maintenance Schedule Item,Maintenance Schedule Item,Raspored održavanja Stavka
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS profil potreban za POS ulaz
DocType: Education Settings,Enable LMS,Omogući LMS
DocType: POS Closing Voucher,Sales Invoices Summary,Sažetak faktura prodaje
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Benefit,Benefit
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Balance Sheet account,Kredit Za račun mora biti račun stanja
DocType: Video,Duration,Trajanje
DocType: Lab Test Template,Descriptive,Opisni
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select Price List,Odaberite Cjenik
DocType: Payment Reconciliation,From Invoice Date,Od datuma fakture
DocType: Education Settings,Validate Batch for Students in Student Group,Potvrdite seriju za studente u studentskoj grupi
DocType: Leave Policy,Leave Allocations,Leave Allocations
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js,Score cannot be greater than Maximum Score,Rezultat ne može biti veći od maksimalnog rezultata
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,BOM is not specified for subcontracting item {0} at row {1},BOM nije naveden za stavku podugovaranja {0} u redu {1}
DocType: Item,Automatically Create New Batch,Automatski kreirajte novi paket
DocType: Restaurant Menu,Price List (Auto created),Cenovnik (automatski kreiran)
DocType: Customer,Credit Limit and Payment Terms,Kreditni limit i uvjeti plaćanja
apps/erpnext/erpnext/stock/doctype/item/item.js,Show Variants,Show Varijante
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Molimo vas da postavite &#39;Gain / Gubitak računa na raspolaganje imovinom&#39; u kompaniji {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Slip of employee {0} already created for time sheet {1},Isplata zarade zaposlenog {0} već kreirana za vremenski list {1}
apps/erpnext/erpnext/config/projects.py,Timesheet for tasks.,Timesheet za zadatke.
DocType: Purchase Invoice,Rounded Total (Company Currency),Zaokruženo ukupno (valuta kompanije)
apps/erpnext/erpnext/config/website.py,Settings for website product listing,Postavke za popis proizvoda na web-lokaciji
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Successfully Set Supplier,Uspješno postavljen dobavljač
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 sporazuma ne može biti veći od ili jednak završnom datumu.
,Item Prices,Cijene predmeta
DocType: Products Settings,Product Page,Stranica proizvoda
DocType: Amazon MWS Settings,Market Place ID,ID tržišta
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Production Order has been {0},Proizvodna narudžba je bila {0}
DocType: Employee Benefit Application,Employee Benefit Application,Aplikacija za beneficije zaposlenih
DocType: BOM Item,Item operation,Operacija stavke
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Received,Delimično primljeno
DocType: Landed Cost Voucher,MAT-LCV-.YYYY.-,MAT-LCV-.YYYY.-
DocType: Employee Advance,Due Advance Amount,Iznos predujma
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,Ukupno dodijeljeni listovi {0} ne mogu biti manji od već odobrenih listova {1} za period
DocType: Email Digest,New Purchase Orders,Nove narudžbenice
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Item: {0} does not exist in the system,Stavka: {0} ne postoji u sistemu
DocType: Loan Application,Loan Info,Info o zajmu
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Pokušajte planirati operacije za X dana unaprijed.
DocType: Serial No,Is Cancelled,Otkazano je
DocType: Request for Quotation,For individual supplier,Za pojedinačnog dobavljača
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Min Qty can not be greater than Max Qty,Min. Količina ne može biti veća od Max Qty
DocType: Soil Texture,Loamy Sand,Loamy Sand
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Red {0}: Plaćanje prema prodaji / narudžbenici uvijek treba označiti kao unaprijed
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 serija postavljena i serijski broj se ne spominje u transakcijama, tada će se automatski kreirati broj serije na osnovu ove serije. Ako uvijek želite eksplicitno spomenuti Batch No za ovu stavku, ostavite ovo polje prazno. Napomena: ova postavka će imati prioritet u odnosu na Prefiks serije Imenovanja u postavkama zaliha."
apps/erpnext/erpnext/config/healthcare.py,Consultation,Konsultacije
DocType: Item,Item Defaults,Default Defaults
DocType: Sales Invoice,Total Commission,Total Commission
DocType: Hotel Room,Hotel Room,Hotelska soba
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,{0} hours,{0} sati
apps/erpnext/erpnext/controllers/buying_controller.py,Serial no is mandatory for the item {0},Serijski broj je obavezan za stavku {0}
DocType: Company,Standard Template,Standard Template
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The number of shares and the share numbers are inconsistent,Broj dionica i broj dionica su nedosljedni
DocType: Project,Start and End Dates,Početni i završni datumi
DocType: Supplier Scorecard,Notify Employee,Notify Employee
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Software,Softver
DocType: Program,Allow Self Enroll,Allow Self Enroll
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Expenses,Stock Expenses
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference No is mandatory if you entered Reference Date,Referentni broj je obavezan ako ste unijeli referentni datum
DocType: Training Event,Workshop,Radionica
DocType: Stock Settings,Auto insert Price List rate if missing,Automatsko ubacivanje Cijena liste ako nedostaje
DocType: Course Content,Course Content,Sadržaj kursa
DocType: Purchase Order Item,Material Request Item,Stavka zahtjeva materijala
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Svrha posete održavanju
DocType: Designation,Skills,Vještine
DocType: Asset,Out of Order,Ne radi
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Available {0},Dostupno {0}
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js,Select Customer,Izaberite Kupca
DocType: Projects Settings,Ignore Workstation Time Overlap,Zanemari preklapanje radnog vremena
DocType: Shareholder,Hidden list maintaining the list of contacts linked to Shareholder,Skrivena lista održava listu kontakata povezanih sa dioničarima
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Same item has been entered multiple times,Ista stavka je unesena više puta
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} is under maintenance contract upto {1},Serijski broj {0} je pod ugovorom o održavanju do {1}
DocType: Bin,FCFS Rate,FCFS Rate
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Negative Quantity is not allowed,Negativna količina nije dozvoljena
DocType: Quotation Item,Planning,Planiranje
DocType: Marketplace Settings,Marketplace URL (to hide and update label),URL tržišta (za skrivanje i ažuriranje oznake)
DocType: Item Group,Parent Item Group,Grupa roditelja
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Avg. Buying Price List Rate,Avg. Kupovna cijena
,Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC]
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,Row #{0}: Timings conflicts with row {1},Red # {0}: Vremenski razmaci su u sukobu s retkom {1}
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customers,Ponovi klijente
DocType: Fee Schedule,Fee Schedule,Tarifa
DocType: Quality Inspection Reading,Reading 10,Čitanje 10
apps/erpnext/erpnext/config/hr.py,Setting up Employees,Postavljanje zaposlenih
DocType: Selling Settings,Settings for Selling Module,Postavke za prodajni modul
DocType: Payment Reconciliation,Reconcile,Reconcile
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 različitosti mora biti račun vrste imovine / odgovornosti, budući da je ovaj unos dionica uvodni unos"
apps/erpnext/erpnext/accounts/report/financial_statements.py,End Year cannot be before Start Year,Kraj godine ne može biti prije početka godine
DocType: Task,Parent Task,Parent Task
DocType: Attendance,Attendance Request,Zahtev za prisustvovanje
DocType: Item,Moving Average,Moving Average
DocType: Employee Attendance Tool,Unmarked Attendance,Neoznačeno prisustvo
DocType: Homepage Section,Number of Columns,Broj stupaca
DocType: Issue Priority,Issue Priority,Prioritet problema
DocType: Holiday List,Add Weekly Holidays,Add Weekly Holidays
DocType: Shopify Log,Shopify Log,Shopify Log
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Salary Slip,Napravite ispis plata
DocType: Customs Tariff Number,Customs Tariff Number,Carinski tarifni broj
DocType: Job Offer Term,Value / Description,Vrijednost / opis
DocType: Warranty Claim,Issue Date,Datum izdavanja
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 niti jedan paket koji ispunjava ovaj zahtjev
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py,Cannot create Retention Bonus for left Employees,Ne može se stvoriti bonus za zadržavanje za lijeve zaposlenike
DocType: Employee Checkin,Location / Device ID,Lokacija / ID uređaja
DocType: Purchase Order,To Receive,Primiti
apps/erpnext/erpnext/accounts/page/pos/pos.js,You are in offline mode. You will not be able to reload until you have network.,Nalazite se u izvanmrežnom načinu rada. Nećete moći ponovo učitati sve dok ne dobijete mrežu.
DocType: Course Activity,Enrollment,Upis
DocType: Lab Test Template,Lab Test Template,Lab Test Template
,Employee Birthday,Rođendan zaposlenika
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Max: {0},Max: {0}
apps/erpnext/erpnext/regional/italy/utils.py,E-Invoicing Information Missing,Informacije o elektronskom fakturiranju nedostaju
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No material request created,Nije napravljen nikakav zahtjev za materijal
DocType: Loan,Total Amount Paid,Ukupno plaćeni iznos
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,All these items have already been invoiced,Sve ove stavke su već fakturirane
DocType: Training Event,Trainer Name,Ime trenera
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Project Manager,Project Manager
DocType: Travel Itinerary,Non Diary,Non Diary
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shares don't exist with the {0},Dionice ne postoje sa {0}
DocType: Lab Test,Test Group,Test Grupa
DocType: Subscription,Number of days that the subscriber has to pay invoices generated by this subscription,Broj dana kada pretplatnik mora platiti fakture generirane ovom pretplatom
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,Please set Unrealized Exchange Gain/Loss Account in Company {0},Molimo postavite nerealizirani račun dobiti i gubitka na burzi u poduzeću {0}
DocType: Payroll Entry,Select Payment Account to make Bank Entry,Odaberite Račun za plaćanje da biste napravili unos banke
DocType: Supplier Scorecard,Scoring Setup,Scoring Setup
DocType: Salary Slip,Total Interest Amount,Ukupni iznos kamata
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},Početni datum fiskalne godine i datum završetka fiskalne godine već su postavljeni u fiskalnoj godini {0}
apps/erpnext/erpnext/projects/report/billing_summary.py,Billable Hours,Billable Hours
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge with Existing Account,Spajanje sa postojećim računom
DocType: Lead,Lost Quotation,Lost Quotation
DocType: Email Digest,Note: Email will not be sent to disabled users,Napomena: E-pošta neće biti poslana korisnicima s invaliditetom
apps/erpnext/erpnext/config/settings.py,"Create and manage daily, weekly and monthly email digests.","Kreirajte i upravljajte dnevnim, nedeljnim i mesečnim pregledima e-pošte."
DocType: Academic Term,Academic Year,Akademska godina
DocType: Sales Stage,Stage Name,Naziv faze
DocType: SMS Center,All Employee (Active),Svi zaposleni (aktivni)
DocType: Accounting Dimension,Accounting Dimension,Dimenzije računovodstva
DocType: Project,Customer Details,Detalji o kupcu
DocType: Buying Settings,Default Supplier Group,Default Supplier Group
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please cancel Purchase Receipt {0} first,Molimo prvo poništite Potvrdu o kupnji {0}
apps/erpnext/erpnext/controllers/accounts_controller.py,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Naknada tipa &#39;Actual&#39; u redu {0} ne može biti uključena u stavku Rate Rate
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Business Development Manager,Menadžer za razvoj poslovanja
DocType: Agriculture Task,Urgent,Hitno
DocType: Shipping Rule Condition,From Value,From Value
DocType: Asset Maintenance Task,Next Due Date,Next Due Date
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Buy,Buy
apps/erpnext/erpnext/projects/doctype/task/task.py,Progress % for a task cannot be more than 100.,Napredak% za zadatak ne može biti veći od 100.
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: Item,Website Item Groups,Group Item Groups
DocType: Certified Consultant,Certified Consultant,Certified Consultant
DocType: Driving License Category,Class,Klasa
DocType: Asset,Sold,Sold
apps/erpnext/erpnext/accounts/party.py,There can only be 1 Account per Company in {0} {1},U {0} {1} može biti samo jedan račun po kompaniji
DocType: GL Entry,Against,Protiv
DocType: Company,Default Deferred Expense Account,Default Deferred Expense Account
DocType: Stock Settings,Auto Material Request,Auto Material Request
DocType: Marketplace Settings,Sync in Progress,Sync in Progress
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 utvrđeno da se plaća podnosi za gore odabrane kriterije ILI listić plata koji je već dostavljen
apps/erpnext/erpnext/config/settings.py,Create rules to restrict transactions based on values.,Kreirajte pravila za ograničavanje transakcija na osnovu vrijednosti.
DocType: Products Settings,Enable Field Filters,Omogući filtere polja
DocType: Loan,Loan Amount,Iznos kredita
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Miscellaneous Expenses,Razni troškovi
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the public administration '%s',Molimo vas da postavite fiskalni kod za javnu upravu &quot;% s&quot;
apps/erpnext/erpnext/config/retail.py,Setup mode of POS (Online / Offline),Način postavljanja POS-a (Online / Offline)
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Korisnik {0} nema podrazumevani POS profil. Proverite Default at Row {1} za ovog korisnika.
DocType: Department,Leave Block List,Ostavite blok listu
apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html,Select Patient,Izaberite Pacijent
DocType: Attendance,Leave Type,Leave Type
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Creating student groups,Kreiranje studentskih grupa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Plants and Machineries,Postrojenja i strojevi
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Not Marked,Not Marked
DocType: Bank Statement Transaction Invoice Item,Purchase Invoice,Faktura kupovine
DocType: GL Entry,Is Opening,Is Opening
DocType: Accounts Settings,Accounts Settings,Podešavanja naloga
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Actual Qty: Quantity available in the warehouse.,Stvarna količina: Količina dostupna u skladištu.
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expires On,Ističe na
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Accounting Entry for Asset,Računovodstveni unos za imovinu
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Raspored kursa
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cost Center with existing transactions can not be converted to ledger,Centar troškova s postojećim transakcijama ne može se pretvoriti u knjigu
,Bank Clearance Summary,Sažetak bankarskog odobrenja
DocType: SMS Center,SMS Center,SMS centar
DocType: Pricing Rule,Threshold for Suggestion,Prag za sugestiju
DocType: Stock Entry,Sales Invoice No,Broj fakture prodaje br
DocType: Project Update,Project Update,Project Update
DocType: Student Sibling,Student ID,Student ID
,Pending SO Items For Purchase Request,Stavke na čekanju za zahtev za kupovinu
DocType: Task,Timeline,Timeline
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,The Loyalty Program isn't valid for the selected company,Program vjernosti nije važeći za odabranu kompaniju
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfiguriraj {0}
DocType: Employee,Contact Details,Kontaktni detalji
apps/erpnext/erpnext/utilities/user_progress.py,Classrooms/ Laboratories etc where lectures can be scheduled.,Učionice / laboratorije itd. Gde se mogu zakazati predavanja.
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Cannot cancel because submitted Stock Entry {0} exists,Ne može se otkazati jer postoji poslata stavka za unos dionica {0}
DocType: Exchange Rate Revaluation Account,Balance In Account Currency,Stanje u valuti računa
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Close the POS,Zatvorite POS
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"For {0}, only credit accounts can be linked against another debit entry",Za {0} samo kreditni računi mogu biti povezani s drugim debitnim unosom
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Pharmaceutical,Pharmaceutical
DocType: Program Enrollment,Boarding Student,Boarding Student
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js,Total Contribution Amount: {0},Ukupan iznos doprinosa: {0}
DocType: Item Alternative,Two-way,Dvosmjerno
DocType: Appraisal,Appraisal,Procjena
apps/erpnext/erpnext/controllers/trends.py,Fiscal Year: {0} does not exists,Fiskalna godina: {0} ne postoji
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Create Employee,Create Employee
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Structures have been assigned successfully,Strukture su uspješno dodijeljene
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Expenses,Direktni troškovi
DocType: Support Search Source,Result Route Field,Rezultat Polje rute
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,There is not enough leave balance for Leave Type {0},Nema dovoljno preostalog balansa za vrstu ostavljanja {0}
DocType: Material Request Plan Item,Actual Qty,Actual Qty
DocType: Purchase Invoice,Supplier Invoice Date,Datum fakture dobavljača
DocType: Depreciation Schedule,Finance Book Id,Finance Book Id
DocType: Exchange Rate Revaluation Account,Current Exchange Rate,Current Exchange Rate
DocType: Account,Equity,Equity
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}: Vrsta referentnog dokumenta mora biti jedna od prodajnog naloga, fakture prodaje ili unosa dnevnika"
apps/erpnext/erpnext/utilities/user_progress.py,Explore Sales Cycle,Istražite ciklus prodaje
DocType: Shopify Log,Request Data,Request Data
DocType: Quality Procedure,Quality Procedure,Procedura kvaliteta
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Email sent to supplier {0},E-pošta poslata dobavljaču {0}
,Course wise Assessment Report,Izvještaj o procjeni
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Automotive,Automotive
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 ili jednak iznosu nepodmirene fakture {2}
DocType: Student Report Generation Tool,Total Parents Teacher Meeting,Sastanak nastavnika za sve roditelje
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0} : Operation is required against the raw material item {1},Red {0}: Potrebna je operacija prema sirovinskoj stavci {1}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Posting timestamp must be after {0},Vremenska oznaka knjiženja mora biti nakon {0}
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Please mention the Lead Name in Lead {0},Navedite ime olova u olovu {0}
DocType: Employee,You can enter any date manually,Možete uneti bilo koji datum ručno
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Stavka pomirenja zaliha
DocType: Shift Type,Early Exit Consequence,Ranija izlazna posljedica
DocType: Item Group,General Settings,General Settings
apps/erpnext/erpnext/accounts/party.py,Due Date cannot be before Posting / Supplier Invoice Date,Datum dospijeća ne može biti prije knjiženja / datuma fakture dobavljača
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the name of the Beneficiary before submittting.,Unesite ime Korisnika prije podnošenja.
apps/erpnext/erpnext/config/healthcare.py,Record Patient Vitals,Zabilježite pacijentove vitale
DocType: Shopping Cart Settings,Show Configure Button,Prikaži dugme Konfiguriraj
DocType: Industry Type,Industry Type,Tip industrije
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Nije moguće izabrati vrstu naplate kao &quot;Na prethodni iznos reda&quot; ili &quot;Na prethodni redak ukupno&quot; za prvi red
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shares already exist,Dionice već postoje
DocType: Work Order Item,Available Qty at WIP Warehouse,Dostupno u WIP skladištu
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Resolve error and upload again.,Rješavanje greške i ponovno učitavanje.
DocType: Travel Request,Copy of Invitation/Announcement,Kopija poziva / najave
DocType: Healthcare Service Unit,Healthcare Service Unit,Služba za zdravstvenu zaštitu
apps/erpnext/erpnext/controllers/trends.py,Total(Qty),Ukupno (Kol)
DocType: Employee,Health Insurance No,Zdravstveno osiguranje br
DocType: Supplier Scorecard Scoring Standing,Max Grade,Max Grade
DocType: Department Approver,Approver,Odobrava
,Sales Order Trends,Trendovi prodajnog naloga
DocType: Asset Repair,Repair Cost,Cost Repair
apps/erpnext/erpnext/accounts/general_ledger.py,Please mention Round Off Account in Company,Molimo navedite Round Off račun u kompaniji
DocType: Payroll Entry,Select Payroll Period,Odaberite Period isplate
DocType: Price List,Price List Name,Naziv cjenika
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,You can only submit Leave Encashment for a valid encashment amount,Možete samo da podnesete „Ostavi inkasiranje“ za važeći iznos naplate
DocType: Pricing Rule,"Higher the number, higher the priority","Veći broj, veći prioritet"
DocType: Designation,Required Skills,Required Skills
DocType: Marketplace Settings,Disable Marketplace,Disable Marketplace
DocType: Budget,Action if Annual Budget Exceeded on Actual,Akcija ako je godišnji budžet premašen na stvarni
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as {1} on leave.,Prisustvovanje nije predato za {0} kao {1} na odsustvu.
DocType: Pricing Rule,Promotional Scheme Id,Id promotivne šeme
apps/erpnext/erpnext/projects/doctype/project/project.py,End date of task <b>{0}</b> cannot be greater than <b>{1}</b> expected end date <b>{2}</b>,Datum završetka zadatka <b>{0}</b> ne može biti veći od <b>{1}</b> očekivanog datuma završetka <b>{2}</b>
DocType: Driver,License Details,Detalji o licenci
DocType: Cash Flow Mapper,e.g Adjustments for:,npr. podešavanja za:
DocType: Selling Settings,Default Quotation Validity Days,Default Quotation Validity Days
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,"Bank Account, From Date and To Date are Mandatory","Bankovni račun, od datuma do datuma su obavezni"
DocType: Travel Request Costing,Expense Type,Expense Type
DocType: Account,Auditor,Revizor
apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html,Payment Confirmation,Potvrda plaćanja
,Available Stock for Packing Items,Raspoloživa zaliha za pakovanje
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please remove this Invoice {0} from C-Form {1},Uklonite ovaj račun {0} iz C-obrasca {1}
DocType: Shift Type,Every Valid Check-in and Check-out,Svaka validna prijava i odjava
DocType: Support Search Source,Query Route String,Niz upita za rutu
DocType: Customer Feedback Template,Customer Feedback Template,Obrazac za povratne informacije o klijentima
apps/erpnext/erpnext/config/selling.py,Quotes to Leads or Customers.,Citati za vode ili klijente.
DocType: Driver,Transporter,Transporter
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Slip of employee {0} already created for this period,Isplata zarade zaposlenog {0} je već kreirana za ovaj period
apps/erpnext/erpnext/controllers/selling_controller.py,To {0} | {1} {2},U {0} | {1} {2}
DocType: Leave Block List Date,Block Date,Datum blokiranja
DocType: Sales Team,Contact No.,Kontakt
DocType: Manufacturing Settings,Overproduction Percentage For Work Order,Postotak prekomjerne proizvodnje za radni nalog
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Enroll,Upišite se
DocType: Quotation Lost Reason,Quotation Lost Reason,Quotation Lost Reason
,Employee Billing Summary,Sažetak naplate za zaposlene
apps/erpnext/erpnext/config/settings.py,Country wise default Address Templates,Podrazumevani predlošci adresa za zemlju
DocType: Cost Center,Parent Cost Center,Matični troškovni centar
DocType: Pricing Rule,Apply Rule On Item Group,Primijeni pravilo o grupi artikala
apps/erpnext/erpnext/utilities/user_progress.py,Example: Basic Mathematics,Primjer: Osnovna matematika
DocType: Expense Claim,Total Amount Reimbursed,Ukupno nadoknađeni iznos
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Validity period of this quotation has ended.,Period valjanosti ove ponude je završen.
,Item-wise Sales History,Istorija prodaje
DocType: Employee,Personal Email,Personal Email
DocType: Bank Reconciliation Detail,Cheque Date,Datum provjere
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Previous Financial Year is not closed,Prethodna finansijska godina nije zatvorena
DocType: Lead,Next Contact Date,Datum sljedećeg kontakta
DocType: Membership,Membership,Članstvo
DocType: Buying Settings,Default Buying Price List,Default Buying Price List
DocType: Asset,Depreciation Method,Metoda amortizacije
DocType: Travel Request,Travel Request,Zahtjev za putovanje
apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,Stvorene su {0} varijante.
DocType: Healthcare Settings,Avoid Confirmation,Izbegavajte potvrdu
DocType: Serial No,Under AMC,Pod AMC
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}","Potrebna skladišta na redu broj {0}, postavite zadano skladište za stavku {1} za tvrtku {2}"
DocType: Authorization Control,Authorization Control,Kontrola autorizacije
,Daily Work Summary Replies,Dnevni rad Sažetak odgovora
apps/erpnext/erpnext/projects/doctype/project/project.py,You have been invited to collaborate on the project: {0},Pozvani ste da sarađujete na projektu: {0}
DocType: Issue,Response By Variance,Response By Variance
DocType: Item,Sales Details,Sales Details
apps/erpnext/erpnext/config/settings.py,Letter Heads for print templates.,Letter Heads za predloške za ispis.
DocType: Salary Detail,Tax on additional salary,Porez na dodatnu platu
apps/erpnext/erpnext/public/js/setup_wizard.js,Attach Logo,Priloži logotip
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,For row {0}: Enter Planned Qty,Za redak {0}: Unesite planiranu količinu
DocType: Asset Settings,Calculate Prorated Depreciation Schedule Based on Fiscal Year,Izračunajte proporcionalni raspored amortizacije na osnovu fiskalne godine
apps/erpnext/erpnext/config/crm.py,Logs for maintaining sms delivery status,Zapisi za održavanje statusa slanja SMS-a
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Current Job Openings,Current Job Openings
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Pravilo određivanja cijena se prvo bira na osnovu polja &quot;Primijeni na&quot;, koje može biti Grupa, Grupa predmeta ili Marka."
DocType: Purchase Receipt,Add / Edit Taxes and Charges,Dodajte / uredite poreze i naknade
DocType: Item,Supply Raw Materials for Purchase,Nabavka sirovina za nabavku
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal Writing,Pisanje predloga
DocType: Landed Cost Item,Purchase Receipt Item,Stavka računa kupovine
DocType: Production Plan,Get Sales Orders,Nabavite narudžbe prodaje
DocType: Pricing Rule,Selling,Prodaja
DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Sprječavanje narudžbenica
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Print and Stationery,Print and Stationery
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Buying,Pravilo dostave se primjenjuje samo za kupovinu
apps/erpnext/erpnext/templates/includes/product_list.js,No products found.,Nema pronađenih proizvoda.
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,Red {0}: postavite porez na oslobođenje od poreza u porezima na promet i naknadama
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Group: ,Grupa za procenu:
DocType: Tally Migration,Parties,Stranke
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Show exploded view,Prikaži eksplodirani prikaz
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,No Delivery Note selected for Customer {},Nije odabrana isporuka za klijenta {}
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,End on,End on
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 veću vrijednost nego Grand Total.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Designer,Dizajner
DocType: QuickBooks Migrator,Default Warehouse,Default Warehouse
DocType: Company,Default Cash Account,Default Cash Account
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please enter Reference date,Unesite referentni datum
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Item {0} must be a stock Item,Stavka {0} mora biti dionica
DocType: POS Profile,Print Format for Online,Format ispisa za Online
,Employee Leave Balance,Zaposleni ostavi ravnotežu
DocType: Projects Settings,Ignore User Time Overlap,Zanemari preklapanje vremena korisnika
DocType: Stock Entry,As per Stock UOM,Po zalihama UOM
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cost Center with existing transactions can not be converted to group,Centar troškova s postojećim transakcijama ne može se pretvoriti u grupu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,cannot be greater than 100,ne može biti veća od 100
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Please Delivery Note first,Molimo vas da prvo pošaljete dostavnicu
DocType: Leave Type,Leave Type Name,Ostavite ime tipa
DocType: Homepage Featured Product,Homepage Featured Product,Početna stranica Istaknuti proizvod
DocType: Assessment Plan,Examiner Name,Ime ispitivača
,Hotel Room Occupancy,Upotreba hotelske sobe
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Telecommunications,Telekomunikacije
DocType: Certification Application,Certification Application,Aplikacija za sertifikaciju
apps/erpnext/erpnext/stock/doctype/item/item.py,Website Image should be a public file or website URL,Slika web-lokacije mora biti javna datoteka ili URL web-lokacije
apps/erpnext/erpnext/utilities/user_progress.py,Your Suppliers,Vaši dobavljači
DocType: Appraisal Goal,Weightage (%),Težina (%)
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inter-State Supplies,Interdržavni pribor
DocType: Fees,Send Payment Request,Pošaljite zahtjev za plaćanje
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} is not added in the table,{0} se ne dodaje u tabelu
apps/erpnext/erpnext/utilities/activation.py,Create Student,Kreirajte Student
apps/erpnext/erpnext/config/projects.py,Gantt chart of all tasks.,Gantov dijagram svih zadataka.
DocType: Department,Leave Approvers,Leave Approvers
DocType: BOM,Materials Required (Exploded),Potrebni materijali (eksplodirani)
DocType: Loan,Repay Over Number of Periods,Povrati preko perioda
DocType: Account,Receivable,Potraživanja
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py,Price List must be applicable for Buying or Selling,Cenovnik mora biti primjenjiv za kupovinu ili prodaju
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Resend Payment Email,Ponovno pošalji e-poruku za plaćanje
apps/erpnext/erpnext/regional/italy/utils.py,Please set {0} for address {1},Postavite {0} za adresu {1}
DocType: Stock Entry,Default Source Warehouse,Default Source Warehouse
DocType: Timesheet Detail,Bill,Bill
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplicirani broj role za studenta {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Batch {0} of Item {1} has expired.,Serija {0} stavke {1} je istekla.
DocType: Lab Test,Approved Date,Odobreni datum
DocType: Item Group,Item Tax,Porez na stavku
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Cannot transfer Employee with status Left,Nije moguće prenijeti zaposlenika sa statusom lijevo
DocType: BOM,Total Cost,Ukupni troškovi
DocType: Request for Quotation Supplier,Quote Status,Quote Status
DocType: Employee Education,Qualification,Kvalifikacija
DocType: Complaint,Complaints,Reklamacije
DocType: Item,Is Purchase Item,Je kupovna stavka
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Purchase Receipt,Potvrda o kupnji
DocType: Subscription,Trial Period Start Date,Početni datum probnog perioda
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Credit Balance,Stanje kredita
DocType: Employee Benefit Application,Payroll Period,Period obračuna zarade
apps/erpnext/erpnext/config/buying.py,Supplier database.,Baza podataka dobavljača.
DocType: Tax Rule,Tax Type,Tip poreza
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Move Item,Move Item
DocType: Job Opening,Description of a Job Opening,Opis otvaranja posla
apps/erpnext/erpnext/utilities/activation.py,Create Users,Create Users
DocType: Global Defaults,Current Fiscal Year,Trenutna fiskalna godina
DocType: Item,Hub Warehouse,Hub Warehouse
DocType: Purchase Invoice,Tax Breakup,Tax Breakup
DocType: Job Card,Material Transferred,Preneseni materijal
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Nemate ovlaštenje za dodavanje ili ažuriranje unosa prije {0}
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date of Birth cannot be greater than today.,Datum rođenja ne može biti veći od danas.
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čina moraju biti isti
DocType: Company,Exception Budget Approver Role,Izuzetak Uloga budžetskog odobrenja
DocType: Fee Schedule,In Process,U procesu
DocType: Daily Work Summary Group,Send Emails At,Pošalji e-poštu At
apps/erpnext/erpnext/public/js/hub/hub_call.js,Marketplace Error,Greška na tržištu
DocType: Salary Slip,Working Days,Radni dani
DocType: Bank Guarantee,Margin Money,Margin Money
DocType: Chapter,Chapter,Poglavlje
DocType: Purchase Receipt Item Supplied,Current Stock,Current Stock
DocType: Employee,History In Company,History In Company
DocType: Purchase Invoice Item,Manufacturer,Proizvođač
apps/erpnext/erpnext/healthcare/setup.py,Moderate Sensitivity,Moderate Sensitivity
DocType: Compensatory Leave Request,Leave Allocation,Leave Allocation
DocType: Timesheet,Timesheet,Timesheet
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation already used for another company,Skraćenica koja se već koristi za drugu kompaniju
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: Purchase Order,Advance Paid,Advance Paid
DocType: Supplier Scorecard,Load All Criteria,Učitaj sve kriterije
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Serial Numbers in row {0} does not match with Delivery Note,Serijski brojevi u redu {0} se ne podudaraju s napomenom o isporuci
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Creditors,Kreditori
DocType: Warranty Claim,Raised By,Raised By
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Reference No and Reference Date is mandatory for Bank transaction,Referentni broj i referentni datum su obavezni za transakciju Banke
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 faktor sakupljanja na osnovu ukupno potrošenog. Ali faktor konverzije za otkup će uvek biti isti za sve nivoe.
DocType: Purchase Invoice Item,Batch No,Serijski br
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Executive Search,Executive Search
DocType: Company,Stock Adjustment Account,Račun usklađivanja dionica
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Gross Profit %,Bruto dobit%
DocType: Lead,Request Type,Type Request
DocType: Patient Appointment,Reminded,Podsjećam
DocType: Accounts Settings,Billing Address,Adresa računa
DocType: Student Leave Application,Mark as Present,Označi kao prisutno
DocType: Landed Cost Voucher,Landed Cost Voucher,Voucher za zemljišne troškove
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 bi trebalo biti veće od maksimalnog radnog vremena {0}
apps/erpnext/erpnext/config/selling.py,Customer Addresses And Contacts,Adrese i kontakti kupaca
DocType: Project,Task Progress,Task Progress
DocType: Journal Entry,Opening Entry,Otvaranje unosa
DocType: Bank Guarantee,Charges Incurred,Naplata troškova
DocType: Shift Type,Working Hours Calculation Based On,Kalkulacija radnih sati na osnovu
DocType: Work Order,Material Transferred for Manufacturing,Preneseni materijal za proizvodnju
DocType: Products Settings,Hide Variants,Sakrij varijante
DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Onemogućite planiranje kapaciteta i praćenje vremena
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Izračunat će se u transakciji.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} is required for 'Balance Sheet' account {1}.,{0} je potreban za račun &#39;Bilans stanja&#39; {1}.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} not allowed to transact with {1}. Please change the Company.,{0} nije dozvoljeno obavljati transakcije sa {1}. Molimo promijenite tvrtku.
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}","Prema postavkama za kupovinu ako je kupovina potrebna == &#39;DA&#39;, onda za kreiranje fakture kupovine, korisnik treba da kreira račun za kupovinu prvo za stavku {0}"
DocType: Delivery Trip,Delivery Details,Detalji dostave
DocType: Inpatient Record,Discharge Scheduled,Discharge Scheduled
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,"Reference: {0}, Item Code: {1} and Customer: {2}","Referenca: {0}, šifra artikla: {1} i klijent: {2}"
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Caution,Oprez
DocType: Project User,View attachments,Prikaži priloge
DocType: Manufacturing Settings,Allow Production on Holidays,Dozvolite proizvodnju na praznicima
apps/erpnext/erpnext/config/accounting.py,Update Bank Transaction Dates,Ažurirajte datume bankovnih transakcija
DocType: Quality Inspection Reading,Reading 4,Čitanje 4
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Item {0} has no Serial No. Only serilialized items \
						can have delivery based on Serial No",Stavka {0} nema serijski broj Samo isporučene stavke mogu imati isporuku na osnovu serijskog broja
DocType: Program Course,Program Course,Programski kurs
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefonski troškovi
DocType: Patient,Widow,Udovica
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Number of Interaction,Broj interakcija
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}","Pravila višestrukih cijena postoje s istim kriterijima, razriješite sukob dodjeljivanjem prioriteta. Pravila cijena: {0}"
apps/erpnext/erpnext/config/accounting.py,Cost Center and Budgeting,Centar troškova i budžetiranje
,Ordered Items To Be Delivered,Naručene stavke koje treba isporučiti
DocType: Homepage Section Card,Homepage Section Card,Homepage Section Card
DocType: Account,Depreciation,Amortizacija
DocType: Guardian,Interests,Interesi
DocType: Purchase Receipt Item Supplied,Consumed Qty,Potrošena količina
DocType: Education Settings,Education Manager,Education Manager
DocType: Employee Checkin,Shift Actual Start,Shift Actual Start
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Planirajte dnevnike vremena izvan radnog vremena radne stanice.
apps/erpnext/erpnext/public/js/utils.js,Loyalty Points: {0},Bodovi lojalnosti: {0}
DocType: Healthcare Settings,Registration Message,Registration Message
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Select an account to print in account currency,Izaberite nalog za štampanje u valuti računa
apps/erpnext/erpnext/accounts/page/pos/pos.js,Serial no item cannot be a fraction,Serijska stavka ne može biti dio
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 jer postoji unos dionica za ovo skladište.
apps/erpnext/erpnext/templates/pages/cart.html,See past quotations,Pogledajte prethodne citate
apps/erpnext/erpnext/www/all-products/index.html,Prev,Prev
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Unit of Measure,Jedinica mjere
DocType: Lab Test,Test Template,Test Template
DocType: Fertilizer,Fertilizer Contents,Sadržaj đubriva
DocType: Quality Meeting Minutes,Minute,Minute
apps/erpnext/erpnext/controllers/accounts_controller.py,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Red # {0}: Svojstvo {1} ne može se poslati, već je {2}"
DocType: Task,Actual Time (in Hours),Stvarno vrijeme (u satima)
DocType: Period Closing Voucher,Closing Account Head,Završni šef računa
DocType: Purchase Invoice,Shipping Rule,Pravilo dostave
DocType: Shipping Rule,Net Weight,Neto težina
apps/erpnext/erpnext/public/js/setup_wizard.js,Please enter valid Financial Year Start and End Dates,Unesite važeći datum početka i završetka finansijske godine
DocType: POS Closing Voucher Invoices,Quantity of Items,Količina artikala
DocType: Warehouse,PIN,PIN
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab testing datetime cannot be before collection datetime,Datetime testiranje laboratorijskog testa ne može biti prije datuma prikupljanja
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Invoice already created for all billing hours,Faktura je već kreirana za sve obračunske sate
DocType: Sales Partner,Contact Desc,Contact Desc
DocType: Purchase Invoice,Pricing Rules,Pravila o cijenama
apps/erpnext/erpnext/stock/doctype/item/item.py,"As there are existing transactions against item {0}, you can not change the value of {1}","Budući da postoje postojeće transakcije protiv stavke {0}, ne možete promijeniti vrijednost {1}"
DocType: Hub Tracked Item,Image List,Lista slika
DocType: Item Variant Settings,Allow Rename Attribute Value,Dopusti promjenu vrijednosti atributa
apps/erpnext/erpnext/templates/generators/bom.html,Time(in mins),Vrijeme (u min)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Basic,Basic
DocType: Loan,Interest Income Account,Račun prihoda od kamata
DocType: Shipping Rule Condition,A condition for a Shipping Rule,Uslov za Pravilo dostave
DocType: Payroll Period Date,Payroll Period Date,Datum obračuna zarade
DocType: Employee,Employment Type,Tip zaposlenja
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Select POS Profile,Izaberite POS profil
DocType: Support Settings,Get Latest Query,Nabavite najnoviji upit
DocType: Employee Incentive,Employee Incentive,Podsticaj za zaposlene
DocType: Service Level,Priorities,Prioriteti
apps/erpnext/erpnext/config/website.py,Add cards or custom sections on homepage,Dodajte kartice ili prilagođene sekcije na početnu stranicu
DocType: Homepage,Hero Section Based On,Hero Section Based On
DocType: Project,Total Purchase Cost (via Purchase Invoice),Ukupni troškovi nabavke (putem fakture kupovine)
DocType: Staffing Plan Detail,Total Estimated Cost,Ukupna procjena troškova
DocType: Item,"Sales, Purchase, Accounting Defaults","Prodaja, kupovina, zadane postavke računovodstva"
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Requesting payment against {0} {1} for amount {2},Zahtjev za plaćanje u iznosu od {0} {1} za iznos {2}
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Please set the Item Code first,Prvo postavite šifru predmeta
DocType: Payment Term,Due Date Based On,Završni datum na osnovu
DocType: Quality Inspection,Incoming,Dolazni
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Ordered,Delimično naručeno
DocType: Delivery Note,Customer's Purchase Order No,Narudžbenica narudžbenice br
apps/erpnext/erpnext/public/js/utils.js,Select Alternate Item,Odaberite Alternativni element
DocType: Employee,Applicable Holiday List,Prihvatljiva lista praznika
DocType: Hub Tracked Item,Hub Tracked Item,Hub Tracked Item
DocType: Vehicle Log,Service Details,Detalji usluge
DocType: Program,Is Featured,Is Featured
DocType: HR Settings,Don't send Employee Birthday Reminders,Ne šalji podsjetnike za rođendan zaposlenika
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Održavajte istu stopu tokom prodajnog ciklusa
DocType: Program Enrollment,Transportation,Transport
DocType: Patient Appointment,Date TIme,Date TIme
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Odaberite količinu u redu
DocType: Employee Benefit Application Detail,Earning Component,Komponenta zarade
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Please select Company first,Prvo izaberite preduzeće
DocType: Item,Publish Item to hub.erpnext.com,Objavi stavku na hub.erpnext.com
apps/erpnext/erpnext/projects/doctype/project/project.py,Join,Join
DocType: BOM,Set rate of sub-assembly item based on BOM,Postavite brzinu stavke podsklopa na osnovu sastavnice
DocType: Vehicle,Wheels,Wheels
DocType: Product Bundle,"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 

The package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".

For Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.

Note: BOM = Bill of Materials","Zbirna grupa ** stavki ** u drugu ** stavku **. Ovo je korisno ako pakujete određene stavke ** u paket i održavate zalihe upakiranih ** stavki **, a ne agregat ** stavka **. Paket ** Item ** će imati &quot;Je li Stock&quot; kao &quot;No&quot; i &quot;Is Sales Item&quot; kao &quot;Yes&quot;. Na primer: Ako prodajete laptopove i ruksake zasebno i ako imate posebnu cenu ako kupac kupi oba, onda će laptop + ruksak biti nova stavka proizvoda. Napomena: BOM = Materijal"
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 &quot;{0}&quot; već postoji za {1} &#39;{2}&#39; i račun &#39;{3}&#39; za fiskalnu godinu {4}
DocType: Asset,Purchase Receipt Amount,Iznos računa za kupovinu
DocType: Issue,Ongoing,U toku
DocType: Service Level Agreement,Agreement Details,Detalji ugovora
DocType: Purchase Invoice,Posting Time,Vrijeme slanja
DocType: Loyalty Program,Loyalty Program Name,Naziv programa lojalnosti
DocType: Patient,Dormant,Neaktivan
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,{0}: From {1},{0}: Od {1}
DocType: Chart of Accounts Importer,Attach custom Chart of Accounts file,Priložite datoteku prilagođenog grafikona računa
apps/erpnext/erpnext/config/help.py,Item Variants,Item Varijante
DocType: Maintenance Visit,Fully Completed,Fully Completed
DocType: Bank Statement Transaction Invoice Item,Transaction Date,Datum transakcije
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,No data for this period,Nema podataka za ovaj period
DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,Default račun će se automatski ažurirati u POS računu kada se odabere ovaj režim.
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation cannot have more than 5 characters,Skraćenica kompanije ne može imati više od 5 znakova
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting_list.js,Canceled,Otkazano
apps/erpnext/erpnext/utilities/user_progress.py,Customers and Suppliers,Kupci i dobavljači
,To Produce,Za proizvodnju
DocType: Location,Is Container,Is Container
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Research & Development,istraživanje i razvoj
DocType: QuickBooks Migrator,Application Settings,Postavke aplikacije
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Production Order cannot be raised against a Item Template,Proizvodni nalog se ne može podići protiv šablona predmeta
DocType: Work Order,Manufacture against Material Request,Proizvodnja protiv zahtjeva za materijal
DocType: Blanket Order Item,Ordered Quantity,Naručena količina
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Red # {0}: Odbijena skladišta je obavezna za odbijenu stavku {1}
,Received Items To Be Billed,Primljene stavke za naplatu
DocType: Attendance,Working Hours,Radni sati
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py,Payment Mode,Način plaćanja
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Purchase Order Items not received on time,Stavke narudžbenice nisu primljene na vrijeme
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Duration in Days,Trajanje u danima
DocType: Customer,Sales Team Details,Detalji o prodajnom timu
DocType: BOM Update Tool,Replace,Zamijeni
DocType: Training Event,Event Name,Naziv događaja
DocType: SMS Center,Receiver List,Lista prijemnika
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Cr,Cr
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Are you sure you want to cancel this appointment?,Jeste li sigurni da želite da otkažete ovaj sastanak?
DocType: Invoice Discounting,Accounts Receivable Credit Account,Kreditni račun potraživanja
DocType: Naming Series,Prefix,Prefiks
DocType: Work Order Operation,Actual Operation Time,Stvarno vrijeme rada
DocType: Purchase Invoice Item,Net Rate,Net Rate
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Neto promjena u gotovini
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.py,Set warehouse for Procedure {0} ,Postavi skladište za postupak {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Block Invoice,Blokiranje fakture
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} does not exist,Račun {0}: Roditeljski račun {1} ne postoji
DocType: HR Settings,Encrypt Salary Slips in Emails,Šifriranje plata u e-porukama
DocType: Supplier Scorecard Scoring Criteria,Score,Score
DocType: Delivery Note,Driver Name,Ime vozača
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select Incharge Person's name,Molimo odaberite ime osobe za naplatu
DocType: Employee Training,Training,Trening
apps/erpnext/erpnext/config/stock.py,Stock Reports,Stock Reports
apps/erpnext/erpnext/stock/doctype/item/item.py,Conversion factor for default Unit of Measure must be 1 in row {0},Faktor konverzije za zadanu jedinicu mjere mora biti 1 u redu {0}
DocType: Course Scheduling Tool,Course Scheduling Tool,Alat za planiranje kursa
,Finished Goods,Gotovih proizvoda
DocType: Sales Invoice Item,Customer Warehouse (Optional),Skladište za klijente (opcionalno)
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Master Data,Glavni podaci o sinhronizaciji
DocType: Lead,Address & Contact,Adresa i kontakt
DocType: Bank Reconciliation,To Date,Izlaziti s
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Error in some rows,Greška u nekim redovima
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py,Lab Tests and Vital Signs,Laboratorijski testovi i Vitalni Znaci
apps/erpnext/erpnext/config/accounting.py,Tax Rule for transactions.,Poresko pravilo za transakcije.
DocType: Stock Settings,Show Barcode Field,Prikaži polje barkoda
DocType: Packing Slip Item,DN Detail,DN Detail
DocType: Vital Signs,Fluid,Fluid
DocType: GST Settings,B2C Limit,B2C Limit
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Electronic Equipments,Elektronska oprema
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Cannot find active Leave Period,Nije moguće pronaći aktivni period odlaska
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Create Maintenance Visit,Kreirajte posjetu za održavanje
DocType: Healthcare Service Unit Type,Change In Item,Promjena u stavci
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,{0} Students have been enrolled,{0} Studenti su upisani
DocType: Vehicle Service,Inspection,Inspekcija
DocType: Location,Area,Površina
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Summary for this week and pending activities,Sažetak za ovu sedmicu i aktivnosti na čekanju
DocType: Asset Maintenance Task,Maintenance Task,Zadatak održavanja
DocType: Subscription,Current Invoice Start Date,Trenutni datum početka računa
DocType: Purchase Invoice Item,Item,Stavka
DocType: Program Enrollment Tool,Get Students From,Nabavite studente iz
DocType: Amazon MWS Settings,Always synch your products from Amazon MWS before synching the Orders details,Uvijek usklađujte svoje proizvode s Amazon MWS prije sinkronizacije detalja narudžbi
DocType: Leave Block List,Leave Block List Name,Ostavite ime blok-liste
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,"Could not update stock, invoice contains drop shipping item.","Nije moguće ažurirati zalihe, faktura sadrži pošiljku za isporuku."
DocType: Asset Maintenance Log,Completion Date,datum završetka
DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,Stopa po kojoj se valuta dobavljača pretvara u osnovnu valutu kompanije
DocType: Leave Control Panel,Leave Control Panel,Ostavite kontrolnu tablu
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,Ukupne primjenjive naknade u tablici stavki računa za kupnju moraju biti iste kao i ukupni porezi i naknade
DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,In Words će biti vidljive kada sačuvate Napomena o isporuci.
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Suppliies made to Composition Taxable Persons,Dobavljači napravljeni u skladu sa poreskim obveznicima
DocType: Bin,Reserved Qty for Production,Rezervisana količina za proizvodnju
DocType: Asset,Quality Manager,Quality Manager
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.","Konfigurišite polja stavki kao što su UOM, Grupa predmeta, Opis i broj sati."
apps/erpnext/erpnext/hr/doctype/department/department_tree.js,New Department,New Department
DocType: Employee,Job Applicant,Job Applicant
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Create Invoices,Napravite fakture
DocType: Purchase Invoice Item,Purchase Order Item,Stavka narudžbenice
apps/erpnext/erpnext/config/settings.py,Data Import and Export,Uvoz i izvoz podataka
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Please contact to the user who have Sales Master Manager {0} role,Obratite se korisniku koji ima ulogu Sales Master Managera {0}
apps/erpnext/erpnext/projects/doctype/project_type/project_type.py,You cannot delete Project Type 'External',Ne možete izbrisati tip projekta &#39;External&#39;
DocType: Account,Temporary,Privremeno
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Column Labels : ,Oznake stupaca:
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Employee A/C Number,Broj A / C zaposlenika
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date should be before Closing Date,Datum otvaranja treba da bude pre datuma zatvaranja
DocType: Packed Item,Parent Detail docname,Parent Detail docname
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Detalje o pomirenju banke
DocType: Tax Withholding Rate,Cumulative Transaction Threshold,Kumulativni prag transakcije
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 je interval &quot;Dani&quot; i broj intervala naplate 3, fakture će se generirati svaka 3 dana"
apps/erpnext/erpnext/projects/doctype/task/task.py,'Actual Start Date' can not be greater than 'Actual End Date',&#39;Stvarni datum početka&#39; ne može biti veći od &#39;Stvarni datum završetka&#39;
DocType: Payment Entry Reference,Payment Entry Reference,Referenca za unos plaćanja
DocType: Salary Component Account,Salary Component Account,Račun komponenti plata
DocType: Supplier,Default Payable Accounts,Default Payable Accounts
DocType: Purchase Invoice,In Words,In Words
DocType: Journal Entry Account,Purchase Order,Narudžbenica
DocType: Journal Entry,Entry Type,Vrsta unosa
apps/erpnext/erpnext/config/healthcare.py,Laboratory,Laboratorija
DocType: Purchase Order,To Bill,Za Billa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Utility Expenses,Utrošni troškovi
DocType: Manufacturing Settings,Time Between Operations (in mins),Vrijeme između operacija (u min)
DocType: GSTR 3B Report,May,May
apps/erpnext/erpnext/accounts/utils.py,"Payment Gateway Account not created, please create one manually.","Račun za Gateway plaćanja nije kreiran, kreirajte ga ručno."
DocType: Opening Invoice Creation Tool,Purchase,Kupovina
DocType: Program Enrollment,School House,School House
apps/erpnext/erpnext/public/js/setup_wizard.js,Please select at least one domain.,Odaberite barem jedan domen.
apps/erpnext/erpnext/projects/doctype/project/project.py,Daily Project Summary for {0},Dnevni sažetak projekta za {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py,All Territories,Sve teritorije
DocType: Asset Repair,Failure Date,Failure Date
DocType: Training Event,Attendees,Učesnici
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Total Outstanding,Total Outstanding
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Amount of TDS Deducted,Iznos TDS-a
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 obavezan za uplatu
DocType: Company,Registration Details,Detalji o registraciji
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Calculated Bank Statement balance,Izračunati bilans stanja na računu
apps/erpnext/erpnext/hub_node/api.py,Only users with {0} role can register on Marketplace,Samo korisnici sa {0} ulogom mogu se registrirati na Marketplace-u
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, molimo navedite račun u evidenciji skladišta ili postavite zadani račun inventara u tvrtki {1}."
DocType: Inpatient Record,Admission,Prijem
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py,This is based on the attendance of this Student,Ovo se zasniva na prisustvu ovog studenta
DocType: SMS Center,Create Receiver List,Kreirajte listu prijemnika
DocType: Leave Type,Max Leaves Allowed,Max Leaves Allowed
DocType: Salary Detail,Component,Komponenta
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Leave and Attendance,Odlazak i prisustvo
DocType: Sales Invoice Timesheet,Billing Amount,Iznos naplate
DocType: BOM Website Item,BOM Website Item,BOM Website Item
DocType: Purchase Invoice,Rounded Total,Rounded Total
DocType: Production Plan,Production Plan,Plan proizvodnje
DocType: Asset Maintenance Log,Actions performed,Izvršene akcije
DocType: Purchase Invoice,Set Accepted Warehouse,Postavi Prihvaćeno skladište
apps/erpnext/erpnext/config/buying.py,Rules for applying pricing and discount.,Pravila za primjenu cijena i popusta.
DocType: Supplier,Statutory info and other general information about your Supplier,Zakonske informacije i ostale opšte informacije o Vašem dobavljaču
DocType: Item Default,Default Selling Cost Center,Default Selling Cost Center
DocType: Sales Partner,Address & Contacts,Adresa i kontakti
DocType: Subscriber,Subscriber,Pretplatnik
apps/erpnext/erpnext/utilities/bot.py,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / Item / {0}) nema na skladištu
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Please select Posting Date first,Prvo odaberite Datum knjiženja
DocType: Supplier,Mention if non-standard payable account,Navedite ako je nestandardni platni račun
DocType: Training Event,Advance,Advance
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,"Root Type for ""{0}"" must be one of the Asset, Liability, Income, Expense and Equity","Tip korena za &quot;{0}&quot; mora biti jedan od sredstava, odgovornosti, prihoda, rashoda i kapitala"
DocType: Project,% Complete Method,% Complete Metoda
DocType: Detected Disease,Tasks Created,Tasks Created
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 aktivna za ovu stavku ili njen predložak
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Commission Rate %,Stopa provizije%
DocType: Service Level Priority,Response Time,Vrijeme odziva
DocType: Woocommerce Settings,Woocommerce Settings,Woocommerce Settings
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Quantity must be positive,Količina mora biti pozitivna
DocType: Contract,CRM,CRM
DocType: Purchase Taxes and Charges,Parenttype,Parenttype
DocType: Tax Rule,Billing State,Država naplate
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Quantity for Item {0} must be less than {1},Količina za stavku {0} mora biti manja od {1}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Transfer Material,Materijal za prijenos
DocType: Shipping Rule,Shipping Account,Shipping Account
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Approval Notification in HR Settings.,Molimo postavite zadani predložak za Leave Approval Notification u HR Settings.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Television,Televizija
apps/erpnext/erpnext/controllers/stock_controller.py,Quality Inspection required for Item {0},Potrebna inspekcija kvaliteta za stavku {0}
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Debit ({0}),Zaduženje ({0})
DocType: Healthcare Practitioner,Inpatient Visit Charge,Naknada u bolničkom posjetu
DocType: Bank Statement Settings,Transaction Data Mapping,Mapiranje podataka o transakcijama
apps/erpnext/erpnext/crm/doctype/lead/lead.py,A Lead requires either a person's name or an organization's name,Olovo zahtijeva ili ime osobe ili ime organizacije
DocType: Student,Guardians,Čuvari
apps/erpnext/erpnext/public/js/stock_analytics.js,Select Brand...,Izaberite brend ...
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Middle Income,Middle Income
DocType: Shipping Rule,Calculate Based On,Izračunajte na osnovu
apps/erpnext/erpnext/stock/doctype/item/item.py,Barcode {0} already used in Item {1},Barkod {0} koji se već koristi u stavci {1}
DocType: Lead,Campaign Name,Naziv kampanje
DocType: Purchase Invoice,Rejected Warehouse,Odbijeno skladište
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} mora biti dostavljen
DocType: Expense Claim Advance,Expense Claim Advance,Advance Claim Claim
DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Prilagodba zaokruživanja (valuta kompanije)
DocType: Item,Publish in Hub,Objavi u Hub-u
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,GSTIN,GSTIN
DocType: GSTR 3B Report,August,August
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter Purchase Receipt first,Prvo unesite Potvrda o kupnji
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Start Year,Start Year
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Target ({}),Cilj ({})
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set Default Payroll Payable Account in Company {0},Molimo postavite Default Payroll Payable Payable Account u preduzeću {0}
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html,Sales Summary,Sažetak prodaje
DocType: Purchase Invoice,In Words (Company Currency),In Words (Valuta Kompanije)
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Navedite valutu u kompaniji
DocType: Pricing Rule,Price,Price
DocType: Material Request Item,Min Order Qty,Min
DocType: Agriculture Task,Holiday Management,Holiday Management
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,Omogućite podrazumevani dolazni račun pre kreiranja Dnevne radne grupe
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.,Možete izabrati najviše jednu opciju iz liste potvrdnih okvira.
DocType: Program Enrollment,Public Transport,Javni prijevoz
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 Batch {1} i stavku {2}.
DocType: Item,Max Sample Quantity,Maksimalna količina uzorka
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Source and target warehouse must be different,Izvorno i ciljno skladište mora biti različito
DocType: Employee Benefit Application,Benefits Applied,Benefits Applied
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Against Journal Entry {0} does not have any unmatched {1} entry,Protiv unosa dnevnika {0} nema unata bez podudaranja {1}
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 dozvoljeni u imenovanju serija"
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Price or product discount slabs are required,Potrebne su ploče s popustom za cijenu ili proizvod
apps/erpnext/erpnext/utilities/user_progress.py,Set a Target,Postavite cilj
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Attendance Record {0} exists against Student {1},Zapisnik o prisustvu {0} postoji protiv studenta {1}
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Date of Transaction,Datum transakcije
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Cancel Subscription,Otkaži pretplatu
apps/erpnext/erpnext/support/doctype/issue/issue.py,Couldn't Set Service Level Agreement {0}.,Nije moguće postaviti sporazum o razini usluge {0}.
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Net Salary Amount,Iznos neto zarade
DocType: Account,Liability,Odgovornost
DocType: Employee,Bank A/C No.,Bank A / C No.
DocType: Inpatient Record,Discharge Note,Discharge Note
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on MR,Akcija ako je akumulirani mjesečni budžet premašen na MR
DocType: Asset Movement,Asset Movement,Pokret imovine
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Automatsko kreiranje kreditne beleške nije moguće, uklonite kvačicu iz &quot;Napomena o izdavanju kredita&quot; i pošaljite ponovo"
DocType: Supplier Scorecard,Per Month,Mjesečno
DocType: Routing,Routing Name,Ime rute
DocType: Disease,Common Name,Common Name
DocType: Education Settings,LMS Title,LMS Title
apps/erpnext/erpnext/config/non_profit.py,Loan Management,Upravljanje kreditima
DocType: Clinical Procedure,Consumable Total Amount,Potrošni ukupni iznos
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Enable Template,Omogući predložak
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Customer LPO,Customer LPO
apps/erpnext/erpnext/stock/doctype/item/item.py,Website Image {0} attached to Item {1} cannot be found,Slika web-lokacije {0} priložena stavci {1} ne može se pronaći
DocType: Asset Maintenance Log,Planned,Planirano
DocType: Asset,Custodian,Skrbnik
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Filter based on Cost Center is only applicable if Budget Against is selected as Cost Center,Filtriranje na osnovu centra troška je primjenjivo samo ako je proračun protivno odabran kao mjesto troška
,Quoted Item Comparison,Uporedna usporedba artikala
DocType: Journal Entry Account,Employee Advance,Unapređenje zaposlenih
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward supplies liable to reverse charge (other than 1 & 2 above),Unutrašnje isporuke koje podležu obrnutoj naplati (osim gore navedenih 1 i 2)
DocType: Quotation,Shopping Cart,Kolica za kupovinu
apps/erpnext/erpnext/hr/doctype/employee/employee.py,User {0} does not exist,Korisnik {0} ne postoji
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Loans and Advances (Assets),Krediti i avansi (imovina)
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}: Molimo vas da označite &#39;Je li unaprijed&#39; na računu {1} ako je to unos unaprijed.
DocType: Leave Control Panel,Designation (optional),Oznaka (opcionalno)
DocType: Salary Slip,Total Principal Amount,Ukupni iznos glavnice
DocType: Opportunity,Customer / Lead Address,Adresa klijenta / vode
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Soap & Detergent,Sapun i deterdžent
,Purchase Analytics,Kupite Analytics
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Opportunity,Opportunity
DocType: Employee,Prefered Contact Email,Preferred Contact Email
apps/erpnext/erpnext/config/help.py,Opening Accounting Balance,Otvaranje salda računovodstva
DocType: POS Profile,[Select],[Select]
DocType: Stock Reconciliation,MAT-RECO-.YYYY.-,MAT-RECO-.YYYY.-
DocType: Tally Migration,Master Data,Glavni podaci
DocType: Certification Application,Yet to appear,Ipak se pojaviti
apps/erpnext/erpnext/public/js/pos/pos.html,Customers in Queue,Kupci u redu
DocType: Supplier,Supplier Details,Detalji o dobavljaču
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,No gain or loss in the exchange rate,Nema dobitka ili gubitka u kursu
,GSTR-1,GSTR-1
DocType: Timesheet,Total Billable Hours,Ukupno plaćeni sati
DocType: Supplier,Represents Company,Represents Company
DocType: POS Profile,Company Address,Adresa kompanije
,Lead Name,Lead Name
apps/erpnext/erpnext/config/agriculture.py,Diseases & Fertilizers,Bolesti i đubriva
apps/erpnext/erpnext/stock/get_item_details.py,Item {0} must be a Sub-contracted Item,Stavka {0} mora biti podugovorena stavka
DocType: Landed Cost Voucher,Purchase Receipt Items,Kupite stavke računa
DocType: Production Plan,Ignore Existing Projected Quantity,Zanemari postojeću projiciranu količinu
DocType: Assessment Plan,Supervisor,Supervizor
DocType: Salary Detail,Salary Detail,Detalj plata
DocType: Budget,Budget Against,Budget Against
DocType: Student Report Generation Tool,Add Letterhead,Add Letterhead
apps/erpnext/erpnext/config/buying.py,Templates of supplier scorecard criteria.,Predlošci kriterijuma ocjene dobavljača.
DocType: Asset,Default Finance Book,Default Finance Book
apps/erpnext/erpnext/stock/get_item_details.py,Please specify Company,Navedite kompaniju
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Total contribution percentage should be equal to 100,Ukupan postotak doprinosa treba biti jednak 100
DocType: GoCardless Settings,Webhooks Secret,Webhooks Secret
,Asset Depreciations and Balances,Amortizacija i stanje sredstava
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch Qty,New Batch Qty
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of goods,Uvoz robe
DocType: Purchase Order Item Supplied,Raw Material Item Code,Šifra artikla sirovine
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Purchase Invoice {0} is already submitted,Faktura kupovine {0} je već poslana
DocType: Fees,Student Email,Student Email
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Get Items from Healthcare Services,Nabavite artikle iz zdravstvenih usluga
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Stock Entry {0} is not submitted,Unos dionica {0} nije dostavljen
DocType: Item Attribute Value,Item Attribute Value,Vrijednost atributa stavke
DocType: Volunteer,Volunteer Skills,Volunteer Skills
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Cannot enroll more than {0} students for this student group.,Ne može se upisati više od {0} učenika za ovu studentsku grupu.
DocType: Travel Request,Costing Details,Detalji kalkulacije
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Sales Invoice {0} has already been submitted,Faktura prodaje {0} je već poslana
DocType: Journal Entry,Accounting Entries,Računovodstveni unosi
DocType: Payment Entry,Internal Transfer,Interni transfer
DocType: Sales Invoice Item,Stock Details,Stock Details
DocType: Leave Type,Is Carry Forward,Is Carry Forward
DocType: Lead,Product Enquiry,Upit o proizvodu
DocType: Purchase Order,PUR-ORD-.YYYY.-,PUR-ORD-.YYYY.-
DocType: Supplier Scorecard,Evaluation Period,Period evaluacije
DocType: Volunteer Skill,Volunteer Skill,Volunteer Skill
DocType: Purchase Order,Order Confirmation No,Potvrda narudžbe br
,POS,POS
DocType: Training Event,Self-Study,Self-Study
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Above,Iznad
DocType: Setup Progress Action,Action Doctype,Action Doctype
DocType: POS Profile,Allow Print Before Pay,Omogući štampanje pre plaćanja
DocType: Production Plan,Select Items to Manufacture,Izaberite stavke za proizvodnju
DocType: Leave Application,Leave Approver Name,Ostavite ime odobrenja
DocType: Shareholder,Shareholder,Akcionar
apps/erpnext/erpnext/config/selling.py,Default settings for selling transactions.,Podrazumevane postavke za transakcije prodaje.
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Please select Student Admission which is mandatory for the paid student applicant,Molimo odaberite Prijem studenata koji je obavezan za plaćenog studenta
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select BOM,Izaberite BOM
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 preklopljenih slotova?"
DocType: Stock Entry,Customer or Supplier Details,Detalji kupca ili dobavljača
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Debit Account,Debit račun
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Trial Period End Date Cannot be before Trial Period Start Date,Datum završetka probnog perioda Ne može biti prije početka probnog perioda
DocType: Employee,Rented,Iznajmljeno
DocType: Employee Group Table,Employee Group Table,Tabela grupe zaposlenika
DocType: Contract,HR Manager,menadzer ljudskih resursa
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Details of Outward Supplies and inward supplies liable to reverse charge,Detalji o spoljnim snabdevanjima i unutrašnjim snabdevanjima koja podležu obrnutoj naplati
DocType: Payment Entry,Cheque/Reference No,Provjera / referenca br
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js,Assessment Result,Rezultat ocjenjivanja
apps/erpnext/erpnext/public/js/templates/contact_list.html,New Contact,Novi kontakt
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Opportunities,Mogućnosti
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Neto gotovina iz poslovanja
DocType: Leave Encashment,Leave Encashment,Leave Encashment
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Source warehouse is mandatory for row {0},Izvorno skladište je obavezno za red {0}
DocType: Amazon MWS Settings,After Date,Nakon datuma
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Available (whether in full op part),ITC Raspoloživo (bilo u punom op dijelu)
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: Activity Type is mandatory.,Red {0}: Vrsta aktivnosti je obavezna.
DocType: Lead,Consultant,Konsultant
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Select an employee to get the employee advance.,Izaberite zaposlenog da biste dobili avans zaposlenika.
apps/erpnext/erpnext/assets/doctype/asset/asset.py,"Asset cannot be cancelled, as it is already {0}","Sredstvo se ne može otkazati, jer je već {0}"
apps/erpnext/erpnext/setup/doctype/company/company.js,Wrong Password,Pogrešna lozinka
DocType: Item,STO-ITEM-.YYYY.-,STO-ITEM-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Number / Name,Ažurirajte broj računa / ime
DocType: Accounts Settings,Use Custom Cash Flow Format,Koristite Custom Cash Flow Format
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices,Otvaranje faktura
DocType: Stock Entry,Send to Warehouse,Pošalji u skladište
DocType: Training Event,Event Status,Status događaja
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Total completed qty must be greater than zero,Ukupna završena količina mora biti veća od nule
DocType: Account,Chargeable,Chargeable
DocType: Volunteer,Anytime,Anytime
,Student Batch-Wise Attendance,Pohađanje studentske serije
DocType: Normal Test Template,Normal Test Template,Normalni test šablon
apps/erpnext/erpnext/config/accounting.py,Tree of financial Cost Centers.,Stablo finansijskih troškovnih centara.
DocType: Work Order Operation,"in Minutes
Updated via 'Time Log'",u minutima ažurirano putem &#39;Dnevnika vremena&#39;
DocType: Bin,Bin,Bin
DocType: Payment Reconciliation Invoice,Invoice Number,Broj fakture
DocType: Delivery Trip,Fulfillment User,Fulfillment User
DocType: Work Order Operation,Planned End Time,Planirano vrijeme završetka
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Section Code,Šifra sekcije
DocType: Project,Monitor Progress,Monitor Progress
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select Batch No,Izaberite Serijski br
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Payroll Number,Broj plata
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Include UOM,Uključi UOM
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Unosi u knjigu zaliha i GL ulazi se objavljuju za odabrane potvrde o kupnji
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Update Print Format,Ažuriraj format ispisa
DocType: Student,Siblings,Braća i sestre
DocType: Purchase Invoice,Hold Invoice,Zadržite fakturu
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Invalid reference {1},Red {0}: nevažeća referenca {1}
,Profitability Analysis,Analiza profitabilnosti
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,New Account Name,Novi naziv računa
DocType: Employee Benefit Claim,Expense Proof,Expense Proof
DocType: Restaurant Order Entry Item,Served,Served
DocType: Loan,Member,Član
DocType: Practitioner Service Unit Schedule,Practitioner Service Unit Schedule,Raspored usluga jedinice za praktičare
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Wire Transfer,Žični prenos
DocType: Quality Review Objective,Quality Review Objective,Cilj pregleda kvaliteta
DocType: Bank Reconciliation Detail,Against Account,Protiv računa
DocType: Projects Settings,Projects Settings,Postavke projekata
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html,Actual Qty {0} / Waiting Qty {1},Stvarna količina {0} / količina čekanja {1}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} cannot be a Group,{0} {1}: Račun {2} ne može biti grupa
DocType: Prescription Duration,Prescription Duration,Trajanje recepta
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Debit entry can not be linked with a {1},Red {0}: debitna stavka se ne može povezati s {1}
DocType: Program,Intro Video,Intro Video
DocType: Purchase Invoice,Is Paid,Is Paid
DocType: Account,Debit,Debit
,Item Balance (Simple),Stanje stavke (jednostavno)
apps/erpnext/erpnext/utilities/activation.py,Purchase orders help you plan and follow up on your purchases,Narudžbenice vam pomažu u planiranju i praćenju kupovine
DocType: Project,Project Type,Project Type
DocType: Program Enrollment Tool Student,Student Batch Name,Ime studentske serije
,Qty to Receive,Količina za primanje
DocType: Agriculture Task,Previous Business Day,Prethodni radni dan
DocType: Travel Request Costing,Sponsored Amount,Sponsored Amount
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Please wait 3 days before resending the reminder.,Pričekajte 3 dana prije slanja podsjetnika.
DocType: Sales Invoice Item,Qty as per Stock UOM,Količina po zalihi UOM
DocType: Opening Invoice Creation Tool Item,Quantity,Količina
DocType: Delivery Stop,Estimated Arrival,Procijenjeni dolazak
,Trial Balance for Party,Probni balans za stranku
DocType: Employee Separation,Employee Separation Template,Šablon za razdvajanje zaposlenih
DocType: Quality Objective,Unit,Jedinica
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Maximum benefit amount of component {0} exceeds {1},Maksimalni iznos naknade komponente {0} premašuje {1}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Venture Capital,Venture Capital
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 treba da bude godinu dana nakon datuma početka fiskalne godine
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Daily Reminders,Daily Reminders
DocType: Item,Default Sales Unit of Measure,Određen forumom Sales Unit of Measure
apps/erpnext/erpnext/regional/report/gst_itemised_sales_register/gst_itemised_sales_register.js,Company GSTIN,Kompanija GSTIN
DocType: Asset Finance Book,Rate of Depreciation,Stopa amortizacije
DocType: Support Search Source,Post Description Key,Post Description Key
DocType: Loyalty Program Collection,Minimum Total Spent,Minimalno ukupno potrošeno
DocType: Supplier Scorecard Period,Period Score,Period Score
apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py,Can't create standard criteria. Please rename the criteria,Ne mogu da kreiram standardne kriterijume. Molimo preimenujte kriterije
DocType: Travel Itinerary,Arrival Datetime,Dolazak Datetime
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py,Student LMS Activity,Student LMS Activity
DocType: Stock Reconciliation Item,Quantity Difference,Quantity Difference
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: Sales Invoice Timesheet,Timesheet Detail,Detajl timesheet
DocType: Employee Skill,Proficiency,Proficiency
DocType: SMS Log,Sent To,Sent To
DocType: Item,Hub Publishing Details,Detalji izdavanja publikacije
apps/erpnext/erpnext/utilities/activation.py,"Student Batches help you track attendance, assessments and fees for students","Studentske serije pomažu vam da pratite pohađanje, procjene i naknade za studente"
DocType: Employee Tax Exemption Declaration Category,Declared Amount,Deklarisani iznos
DocType: Selling Settings,Auto close Opportunity after 15 days,Automatsko zatvaranje mogućnosti nakon 15 dana
DocType: Share Transfer,Issue,Problem
DocType: Volunteer,Availability Timeslot,Availability Timeslot
DocType: Program,Program Abbreviation,Skraćenica programa
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Start Date,Datum početka projekta
DocType: Purchase Invoice,Additional DIscount Amount,Dodatni iznos DIscount
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 tabeli &#39;Isporučeni materijali&#39; u narudžbenici {1}
DocType: BOM,Manage cost of operations,Upravljanje troškovima operacija
apps/erpnext/erpnext/accounts/doctype/account/account.py,You are not authorized to set Frozen value,Niste ovlašteni da postavljate vrijednost Frozen
DocType: Contract,Lapsed,Lapsed
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Investments,Investicije
DocType: Inpatient Record,Date of Birth,Datum rođenja
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 sa ulogama System Manager-a i Item Manager-a za registraciju na Marketplace-u.
DocType: Item Attribute,Item Attribute Values,Vrijednosti atributa stavke
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please save the patient first,Prvo sačuvajte pacijenta
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Half Day Date should be between From Date and To Date,Datum polu-dana treba da bude između datuma i datuma
DocType: Inpatient Record,Expected Discharge,Expected Discharge
DocType: Travel Request,Travel Type,Tip putovanja
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Customer is required,Korisnik je obavezan
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Nevažeća količina navedena za stavku {0}. Količina bi trebala biti veća od 0.
apps/erpnext/erpnext/education/doctype/instructor/instructor.js,As Supervisor,Kao supervizor
DocType: Payroll Entry,Employees,Zaposleni
DocType: Sales Order,Billing Status,Status naplate
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Please select Category first,Prvo izaberite kategoriju
apps/erpnext/erpnext/config/manufacturing.py,BOM Browser,BOM Browser
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Create Student Groups,Kreirajte grupe studenata
DocType: Work Order Operation,In Minutes,In Minutes
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Net Pay cannot be less than 0,Neto plata ne može biti manja od 0
DocType: Maintenance Schedule,Schedules,Rasporedi
DocType: Employee Training,Employee Training,Obuka za zaposlene
DocType: Loan,Rate of Interest (%) / Year,Kamatna stopa (%) / godina
DocType: Normal Test Items,Require Result Value,Potrebna vrijednost rezultata
DocType: Loan,Loan Type,Tip kredita
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Item Code required at Row No {0},Šifra artikla potrebna u redu broj {0}
DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikacija paketa za isporuku (za štampu)
DocType: Assessment Plan,Assessment Name,Naziv procjene
DocType: Travel Itinerary,Departure Datetime,Odlazak Datetime
DocType: Delivery Note Item,From Warehouse,Iz skladišta
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} against {2} {3},Iznos {0} {1} u odnosu na {2} {3}
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variant,Napravite varijantu
DocType: Contract Template,Fulfilment Terms and Conditions,Odredbe i uvjeti ispunjenja
apps/erpnext/erpnext/setup/doctype/company/company.js,Date of Commencement should be greater than Date of Incorporation,Datum početka treba da bude veći od datuma osnivanja
DocType: Pricing Rule,Price or Product Discount,Cijena ili popust na proizvode
DocType: Quality Inspection Reading,Reading 1,Čitanje 1
DocType: Student Admission Program,Maximum Age,Maksimalna starost
DocType: Payroll Period,Payroll Periods,Periodi plata
apps/erpnext/erpnext/buying/report/subcontracted_raw_materials_to_be_transferred/subcontracted_raw_materials_to_be_transferred.py,Transferred Quantity,Transferred Quantity
DocType: Marketplace Settings,Marketplace Settings,Marketplace Settings
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Nalozi za kupnju nisu dozvoljeni za {0} zbog stanja bodova {1}.
apps/erpnext/erpnext/stock/get_item_details.py,Price List not selected,Cenovnik nije izabran
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 prema prazničnoj listi: {0}
DocType: Customer,"Reselect, if the chosen address is edited after save",Ponovo odaberite ako se izabrana adresa uređuje nakon spremanja
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.,Podrazumevana jedinica mjere za stavku {0} ne može se direktno promijeniti jer ste već izvršili neku transakciju s drugom UOM-om. Potrebno je da kreirate novu stavku da biste koristili različitu Default UOM.
apps/erpnext/erpnext/stock/doctype/item/item.js,Changing Customer Group for the selected Customer is not allowed.,Promjena grupe korisnika za odabranog kupca nije dopuštena.
DocType: Serial No,Creation Document Type,Vrsta dokumenta kreiranja
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Dostupno u seriji
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Invoice Grand Total,Faktura Grand Total
apps/erpnext/erpnext/setup/doctype/territory/territory.js,This is a root territory and cannot be edited.,Ovo je korijenska teritorija i ne može se uređivati.
DocType: Patient,Surgical History,Surgical History
apps/erpnext/erpnext/config/quality_management.py,Tree of Quality Procedures.,Drvo procedura kvaliteta.
DocType: Bank Account,Contact HTML,Kontaktirajte HTML
,Employee Information,Informacije o zaposlenima
DocType: Assessment Plan,Examiner,Ispitivač
DocType: Employee Tax Exemption Proof Submission Detail,Actual Amount,Stvarni iznos
DocType: Contract,Fulfilled,Ispunjen
apps/erpnext/erpnext/controllers/buying_controller.py,Row {0}: Enter location for the asset item {1},Red {0}: unesite lokaciju za stavku imovine {1}
DocType: Project Task,View Timesheet,View Timesheet
DocType: Purchase Invoice,Taxes and Charges Calculation,Obračun poreza i naknada
DocType: Setup Progress Action,Action Document,Action Document
DocType: Clinical Procedure,Procedure Prescription,Prescription procedure
DocType: Guardian,Guardian Name,Ime čuvara
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Successfully Reconciled,Uspešno sravnjeno
DocType: Accounting Period,Period Name,Period Name
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,"Molimo, izvucite artikle iz isporuke"
DocType: Content Question,Content Question,Content Question
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html,In Stock: ,In Stock: \ t
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Please save before assigning task.,Molimo Vas da sačuvate pre dodeljivanja zadatka.
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py,Company is manadatory for company account,Kompanija je podređena računu kompanije
DocType: Sales Order Item,Delivery Warehouse,Delivery Warehouse
DocType: Shopify Settings,Enable Shopify,Omogući Shopify
DocType: Patient,Additional information regarding the patient,Dodatne informacije o pacijentu
DocType: Landed Cost Voucher,Purchase Receipts,Potvrde o kupnji
apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js,New Employee,New Employee
DocType: Purchase Invoice,Update Auto Repeat Reference,Update Auto Repeat Reference
DocType: Fees,Fees,Naknade
DocType: Student Group,Student Group Name,Ime grupe učenika
DocType: Supplier Scorecard Scoring Standing,Employee,Zaposleni
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available-for-use Date should be after purchase date,Datum dostupnosti za upotrebu treba da bude nakon datuma kupovine
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Please define grade for Threshold 0%,Molimo vas da definišete ocenu za Threshold 0%
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Aplikacije koje koriste trenutni ključ neće moći pristupiti, jeste li sigurni?"
DocType: Quality Meeting,Minutes,Minutes
DocType: Quiz Result,Correct,Tačno
DocType: Employee Tax Exemption Declaration,Total Declared Amount,Ukupni prijavljeni iznos
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py,Material,Materijal
DocType: Appointment Type,Is Inpatient,Is Inpatient
DocType: Leave Encashment,Encashment Amount,Iznos naplate
DocType: BOM,Conversion Rate,Stopa konverzije
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,CEO,CEO
apps/erpnext/erpnext/projects/doctype/project/project.js,Set tasks in this project as cancelled?,Postavite zadatke u ovom projektu kao otkazane?
DocType: Bin,Reserved Qty for sub contract,Rezervisana količina za podugovor
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Create Payment Entry,Kreirajte unos plaćanja
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js,Submit Proof,Submit Proof
DocType: Payment Term,Credit Months,Mjeseci kredita
DocType: Bank Guarantee,Providing,Providing
DocType: Sales Invoice,Total Billing Amount,Ukupan iznos naplate
DocType: Maintenance Visit,Maintenance Visit,Maintenance Visit
DocType: Item,Country of Origin,Zemlja porijekla
DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Kriteriji analize poljoprivrede
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Additional Salary Component Exists.,Dodatna komponenta plaća postoji.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Grocery,Namirnica
DocType: Restaurant Table,Minimum Seating,Minimum Seating
DocType: Vital Signs,Furry,Furry
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"Can not filter based on Account, if grouped by Account","Nije moguće filtrirati na osnovu računa, ako je grupisano po računu"
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Bank Entries,Bank Entries
DocType: Soil Texture,Sandy Clay Loam,Sandy Clay Loam
DocType: Crop Cycle,LInked Analysis,LInked Analysis
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Valid From Date must be lesser than Valid Upto Date.,Važeći datum mora biti manji od važećeg datuma.
DocType: Additional Salary,Salary Component,Komponenta plata
DocType: Asset Maintenance Team,Maintenance Team Members,Članovi tima za održavanje
DocType: Student Admission Program,Minimum Age,Minimalna starost
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Available Selling,Available Selling
DocType: Purchase Invoice,Taxes and Charges Deducted,Porezi i naknade odbijene
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Lab Test,Napravite laboratorijski test
DocType: Hotel Settings,Hotel Settings,Hotel Settings
DocType: Naming Series,Select Transaction,Izaberite Transakcija
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Declare Lost,Declare Lost
DocType: Warranty Claim,If different than customer address,Ako se razlikuje od adrese korisnika
DocType: Chart of Accounts Importer,Chart Tree,Stablo grafikona
DocType: Contract,Contract,Ugovor
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,Please select the Multiple Tier Program type for more than one collection rules.,Molimo izaberite tip višestrukog programa za više pravila prikupljanja.
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,{0} for {1},{0} za {1}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For Quantity (Manufactured Qty) is mandatory,Za količinu (proizvedena količina) je obavezno
apps/erpnext/erpnext/public/js/setup_wizard.js,"e.g. ""Primary School"" or ""University""",npr. &quot;Osnovna škola&quot; ili &quot;Univerzitet&quot;
DocType: Pricing Rule,Apply Multiple Pricing Rules,Primijeni višestruka pravila za cijene
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py,Review Invitation Sent,Pozivnica za pregled je poslata
DocType: Item,No of Months,Broj mjeseci
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serijski brojevi potrebni za serijsku stavku {0}
apps/erpnext/erpnext/config/manufacturing.py,Bill of Materials (BOM),Sastavnica (BOM)
DocType: Accounts Settings,Allow Stale Exchange Rates,Allow Stale valuta
DocType: BOM,Website Description,Website Description
DocType: POS Closing Voucher,Expense Details,Detalji troškova
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,From Range has to be less than To Range,Iz dometa mora biti manji od To Range
DocType: Homepage,Products to be shown on website homepage,Proizvodi koji će biti prikazani na početnoj stranici web lokacije
DocType: Tally Migration,Is Master Data Processed,Obrađuje se glavni podatak
DocType: Item Price,Quantity  that must be bought or sold per UOM,Količina koja se mora kupiti ili prodati po UOM-u
DocType: Project,Total Sales Amount (via Sales Order),Ukupni iznos prodaje (putem prodajnog naloga)
apps/erpnext/erpnext/utilities/user_progress.py,Box,Box
DocType: QuickBooks Migrator,Default Cost Center,Default Cost Center
DocType: Purchase Order Item,Billed Amt,Billed Amt
apps/erpnext/erpnext/accounts/utils.py,Please set default {0} in Company {1},Unesite {0} u tvrtku {1}
DocType: Cheque Print Template,Distance from left edge,Udaljenost od lijevog ruba
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Tačka 4
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}",Plaćeni avans od {0} {1} ne može biti veći od Grand Total {2}
DocType: Account,Income Account,Račun prihoda
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py,All Warehouses,All Warehouses
DocType: Contract,Signee Details,Signee Details
DocType: Shift Type,Allow check-out after shift end time (in minutes),Omogući odjavu nakon završetka smjene (u minutima)
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py,Procurement,Nabavka
DocType: Item Group,Check this if you want to show in website,Označite ovo ako želite prikazati na web stranici
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Fiscal Year {0} not found,Fiskalna godina {0} nije pronađena
DocType: Bank Statement Settings,Bank Statement Settings,Postavke bankovnog izvoda
DocType: Quality Procedure Process,Link existing Quality Procedure.,Veza postojeće procedure kvaliteta.
apps/erpnext/erpnext/config/getting_started.py,Import Chart Of Accounts from CSV / Excel files,Uvezite grafikon računa iz CSV / Excel datoteka
DocType: Appraisal Goal,Score (0-5),Ocena (0-5)
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute {0} selected multiple times in Attributes Table,Atribut {0} je izabran više puta u tabeli atributa
DocType: Purchase Invoice,Debit Note Issued,Izdata je zadužnica
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 gdje je &quot;Je li stavka&quot; &quot;Ne&quot; i &quot;Je li prodajna stavka&quot; je &quot;Da&quot; i nema drugog paketa proizvoda
apps/erpnext/erpnext/hr/utils.py,Employee {0} of grade {1} have no default leave policy,Zaposlenik {0} razreda {1} nema pravilnik o zadanom ostavljanju
DocType: Leave Policy Detail,Leave Policy Detail,Ostavite detaljnu politiku
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Warehouse not found in the system,Skladište nije pronađeno u sistemu
DocType: Healthcare Practitioner,OP Consulting Charge,OP Consulting Charge
DocType: Bank Statement Transaction Payment Item,Invoices,Fakture
DocType: Currency Exchange,Currency Exchange,Mjenjačnica
DocType: Payroll Entry,Fortnightly,Fortnightly
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} not in stock,Serijski broj {0} nije na zalihi
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: Woocommerce Settings,Creation User,Creation User
apps/erpnext/erpnext/config/crm.py,"Record of all communications of type email, phone, chat, visit, etc.","Snimanje svih komunikacija tipa e-pošte, telefona, razgovora, posjeta, itd."
DocType: Asset Settings,Asset Settings,Asset Settings
DocType: Compensatory Leave Request,Worked On Holiday,Radio je na odmoru
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/stock/doctype/item/item.py,Item {0} is cancelled,Stavka {0} je otkazana
DocType: Course Scheduling Tool,Course End Date,Datum završetka kursa
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py,Opportunity From field is mandatory,Polje Opportunity From je obavezno
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Warning: Leave application contains following block dates,Upozorenje: Napusti aplikaciju sadrži sljedeće blok datume
DocType: Asset Maintenance Task,Preventive Maintenance,Preventivno održavanje
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Abbreviation,Kratica Instituta
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Račun različitosti mora biti račun vrste imovine / odgovornosti, budući da je ovo usklađivanje dionica uvodni unos"
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Contract End Date must be greater than Date of Joining,Datum završetka ugovora mora biti veći od datuma pridruživanja
DocType: Employee Grade,Default Leave Policy,Default Leave Policy
DocType: Daily Work Summary Group,Select Users,Izaberite Korisnici
DocType: Workstation,Net Hour Rate,Neto sat vremena
DocType: Clinical Procedure,Age,Age
DocType: Travel Request,Event Details,Detalji o događaju
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Accumulated Monthly,Accumulated Monthly
apps/erpnext/erpnext/projects/doctype/project/project.js,Save the document first.,Prvo sačuvajte dokument.
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Update Cost,Trošak ažuriranja
DocType: Sales Order,Fully Delivered,Fully Delivered
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter company first,Prvo unesite firmu
apps/erpnext/erpnext/config/selling.py,Confirmed orders from Customers.,Potvrđene narudžbe od kupaca.
DocType: Dosage Strength,Dosage Strength,Snaga doziranja
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Fill the form and save it,Popunite obrazac i sačuvajte ga
DocType: Program Enrollment Tool,Enrollment Details,Detalji o upisu
DocType: Subscription Invoice,Subscription Invoice,Račun pretplate
DocType: Leave Allocation,Total Leaves Encashed,Total Leaves Incashed
DocType: Quality Inspection,Verified By,Verified By
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invoices,Get Invoices
DocType: Invoice Discounting,Settled,Rešeno
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Re-open,Ponovo otvorite
DocType: Period Closing Voucher,Closing Fiscal Year,Završna fiskalna godina
DocType: Purchase Invoice,Release Date,Datum izdavanja
DocType: Purchase Invoice,Advances,Advances
DocType: Shipping Rule,Specify conditions to calculate shipping amount,Navedite uslove za izračunavanje iznosa otpreme
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Technology,Tehnologija
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Može uputiti redak samo ako je tip naplate &quot;Na prethodni redak iznos&quot; ili &quot;Prethodni redak ukupno&quot;
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, Ukupno br. Radnih dana će uključivati praznike, a to će smanjiti vrijednost Plata po danu"
DocType: Location,Location Name,Location Name
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Korisnički račun {2} ne pripada kompaniji {3}
DocType: Employee Benefit Application,Remaining Benefits (Yearly),Preostale koristi (godišnje)
DocType: Asset Finance Book,Depreciation Start Date,Datum početka amortizacije
DocType: Activity Cost,Billing Rate,Stopa naplate
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Warning: Another {0} # {1} exists against stock entry {2},Upozorenje: Još jedna {0} # {1} postoji protiv stavke zaliha {2}
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Please enable Google Maps Settings to estimate and optimize routes,Omogućite Google Maps Settings za procjenu i optimizaciju ruta
DocType: Purchase Invoice Item,Page Break,Page Break
DocType: Supplier Scorecard Criteria,Max Score,Max Score
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Repayment Start Date cannot be before Disbursement Date.,Datum početka otplate ne može biti prije datuma isplate.
DocType: Support Search Source,Support Search Source,Support Search Source
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Financial Services,Finansijske usluge
DocType: Volunteer,Availability,Dostupnost
apps/erpnext/erpnext/config/quality_management.py,Tree of Procedures,Tree of Procedures
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Dozvoli da se stavka dodaje više puta u transakciji
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} nije dostavljen
DocType: Work Order,Backflush raw materials from work-in-progress warehouse,Ispraznite sirovine iz skladišta u toku
DocType: Maintenance Team Member,Maintenance Team Member,Član tima za održavanje
apps/erpnext/erpnext/config/accounting.py,Setup custom dimensions for accounting,Podešavanje prilagođenih dimenzija za računovodstvo
DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,Minimalna udaljenost između redova biljaka za optimalan rast
DocType: Employee Health Insurance,Health Insurance Name,Ime zdravstvenog osiguranja
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Assets,Stock Assets
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,"Dodatni troškovni centri mogu se napraviti u okviru Grupe, ali unosi se mogu vršiti protiv ne-grupa"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Upper Income,Upper Income
DocType: Company,Discount Allowed Account,Account Allowed Account
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Restart Subscription,Restart Subscription
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,You can not change rate if BOM mentioned agianst any item,Ne možete promjeniti stopu ako BOM spominje bilo koju stavku
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 Marketplace-u
DocType: Asset,Insurance Details,Detalji osiguranja
DocType: Subscription,Past Due Date,Past Due Date
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 upto {0} slobodnih radnih mjesta i budžet {1} za {2} prema planu osoblja {3} za matičnu kompaniju {4}.
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,No GST No. found for the Company.,Za kompaniju nije pronađen GST broj.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Pin Code,Iz Pin koda
DocType: Contract,Signed On,Signed On
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Računovodstveni unos za {2} može biti samo u valuti: {3}
DocType: Assessment Criteria,Assessment Criteria,Kriteriji ocjenjivanja
DocType: Lab Test Template,Is Billable,Is Billable
DocType: Naming Series,User must always select,Korisnik mora uvijek odabrati
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Compensatory leave request days not in valid holidays,Zahtjev za kompenzacijsko odsustvo nije važeći
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py,Sum of points for all goals should be 100. It is {0},Zbroj bodova za sve ciljeve treba biti 100. To je {0}
DocType: BOM,Scrap Items,Scrap Items
DocType: Special Test Template,Result Component,Komponenta rezultata
apps/erpnext/erpnext/regional/india/utils.py,Please mention Basic and HRA component in Company,Navedite osnovnu i HRA komponentu u kompaniji
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,{0} does not belong to Company {1},{0} ne pripada kompaniji {1}
DocType: Attendance Request,Half Day Date,Datum polu-dana
DocType: Delivery Note,Billing Address Name,Naziv adrese za naplatu
,GST Itemised Purchase Register,GST Registrovana kupovina
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Alternate Item,Alternativna stavka
DocType: Certification Application,Name of Applicant,Ime podnosioca
DocType: Leave Type,Earned Leave,Earned Leave
DocType: GSTR 3B Report,June,June
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Row {0}: Cost center is required for an item {1},Red {0}: Mjesto troška je potrebno za stavku {1}
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Can be approved by {0},Može biti odobren od strane {0}
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 unesena više od jednom u tabeli faktora konverzije
DocType: Purchase Invoice Item,Net Rate (Company Currency),Neto stopa (valuta kompanije)
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,All BOMs,Sve BOM-ove
DocType: Department,Days for which Holidays are blocked for this department.,Dani za koje su praznici blokirani za ovo odjeljenje.
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,"Cannot Submit, Employees left to mark attendance","Ne može se poslati, Zaposlenici su ostavljeni da obilježe prisustvo"
DocType: BOM,Quality Inspection Template,Predložak za provjeru kvalitete
DocType: Plant Analysis,Result Datetime,Rezultat Datetime
DocType: Purchase Taxes and Charges,Valuation,Vrednovanje
,Student Monthly Attendance Sheet,Mjesečni pregled učenika
DocType: Academic Term,Term End Date,Datum završetka termina
DocType: Pricing Rule Detail,Child Docname,Child Docname
apps/erpnext/erpnext/public/js/setup_wizard.js,Services,Usluge
apps/erpnext/erpnext/controllers/accounts_controller.py,Cannot set quantity less than received quantity,Nije moguće postaviti količinu manju od primljene količine
DocType: Purchase Order Item,Supplier Part Number,Broj dijela dobavljača
DocType: Lab Test Template,Standard Selling Rate,Standardna stopa prodaje
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/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 sa ulogama System Manager i Item Manager da biste dodali korisnike na Marketplace.
DocType: Asset Finance Book,Asset Finance Book,Book Finance Book
DocType: Quality Goal Objective,Quality Goal Objective,Cilj cilja kvaliteta
DocType: Employee Transfer,Employee Transfer,Transfer zaposlenih
,Sales Funnel,Prodajni tok
DocType: Agriculture Analysis Criteria,Water Analysis,Analiza vode
DocType: Shift Type,Begin check-in before shift start time (in minutes),Započnite prijavu prije početka smjene (u minutama)
DocType: Accounts Settings,Accounts Frozen Upto,Računi Frozen Upto
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js,There is nothing to edit.,Nema ništa za uređivanje.
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","Rad {0} duži od bilo kojeg raspoloživog radnog vremena na radnoj stanici {1}, razbiti operaciju u više operacija"
DocType: Item Variant Settings,Do not update variants on save,Nemojte ažurirati varijante prilikom spremanja
DocType: Grading Scale Interval,Threshold,Prag
DocType: Timesheet,% Amount Billed,% Iznos naplate
DocType: Warranty Claim,Resolved By,Rešeno By
apps/erpnext/erpnext/utilities/user_progress.py,"Add users to your organization, other than yourself.","Dodajte korisnike u svoju organizaciju, osim sebe."
DocType: Global Defaults,Default Company,Default Company
DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Novčani račun će se koristiti za kreiranje fakture prodaje
apps/erpnext/erpnext/controllers/selling_controller.py,Sales Order {0} is {1},Prodajni nalog {0} je {1}
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,Delay in payment (Days),Odlaganje plaćanja (Dani)
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Enter depreciation details,Unesite detalje amortizacije
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Customer PO,Korisnička PO
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 prodajnog naloga
apps/erpnext/erpnext/controllers/accounts_controller.py,Item quantity can not be zero,Količina artikla ne može biti nula
apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Nevažeći atribut
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},Odaberite BOM protiv stavke {0}
DocType: Bank Statement Transaction Invoice Item,Invoice Type,Tip fakture
DocType: Price List,Price List Master,Cjenovnik Master
,Lost Opportunity,Izgubljena prilika
DocType: Maintenance Visit,Maintenance Date,Datum održavanja
DocType: Volunteer,Afternoon,Popodne
DocType: Vital Signs,Nutrition Values,Nutrition Values
DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Prisustvo groznice (temp&gt; 38,5 ° C / 101,3 ° F ili produžena temp&gt; 38 ° C / 100,4 ° F)"
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Postavite Sistem za imenovanje zaposlenika u ljudskim resursima&gt; Postavke ljudskih resursa
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Reversed,ITC Reversed
DocType: Project,Collect Progress,Collect Progress
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Energy,Energija
,Items To Be Requested,Stavke koje se traže
DocType: Soil Analysis,Ca/K,Ca / K
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order already created for all items with BOM,Radni nalog je već kreiran za sve stavke sa BOM
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Billed Amount,Iznos naplate
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Uneseno trenutno očitavanje odometra treba da bude veće od početnog kilometrača vozila {0}
DocType: Employee Transfer Property,Employee Transfer Property,Property Transfer Property
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Pending Activities,Aktivnosti na čekanju
apps/erpnext/erpnext/utilities/user_progress.py,List a few of your customers. They could be organizations or individuals.,Navedite nekoliko vaših klijenata. To mogu biti organizacije ili pojedinci.
DocType: Bank Guarantee,Bank Account Info,Informacije o bankovnom računu
DocType: Quality Goal,Weekday,Weekday
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Name,Guardian1 Name
DocType: Salary Component,Variable Based On Taxable Salary,Varijabilna na osnovu oporezive plate
DocType: Accounting Period,Accounting Period,Računovodstveni period
DocType: Company,Standard Working Hours,Standardno radno vrijeme
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,In Stock,In Stock
DocType: Amazon MWS Settings,Market Place Account Group,Grupa računa tržišta
DocType: Stock Reconciliation Item,Before reconciliation,Pre pomirenja
DocType: Fee Component,Fees Category,Kategorije naknada
DocType: Sales Order,%  Delivered,% Isporučeno
DocType: Sales Invoice,Redemption Cost Center,Centar za troškove isplate
DocType: Vital Signs,Respiratory rate,Respiratorna stopa
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Get Students From,Obavezno polje - Odvedi studente
DocType: Item Group,Item Classification,Klasifikacija predmeta
DocType: Asset,Is Existing Asset,Postoji postojeća imovina
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,Cancel Material Visits {0} before cancelling this Maintenance Visit,Otkazivanje materijala Posjeta {0} prije otkazivanja ove posjete održavanja
DocType: Workstation,Workstation Name,Naziv radne stanice
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Red # {0}: Status mora biti {1} za sniženje dostavnice {2}
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Material Transfer,Transfer materijala
DocType: Delivery Note,% Installed,% Installed
DocType: Agriculture Task,Agriculture Task,Zadatak poljoprivrede
DocType: Dosage Form,Dosage Form,Dosage Form
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Select the program first,Najprije odaberite program
DocType: Project,Expected Start Date,Očekivani datum početka
DocType: Share Transfer,Share Transfer,Deljenje transfera
apps/erpnext/erpnext/config/hr.py,Leave Management,Leave Management
DocType: Loan Application,Total Payable Interest,Ukupna kamata koja se plaća
DocType: Employee,Current Address,Trenutna adresa
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Cannot {0} {1} {2} without any negative outstanding invoice,Nije moguće {0} {1} {2} bez negativne nepodmirene fakture
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Transaction not allowed against stopped Work Order {0},Transakcija nije dozvoljena protiv zaustavljenog radnog naloga {0}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to ledger.,Skladišta sa postojećom transakcijom ne mogu se pretvoriti u knjigu.
DocType: Payroll Entry,Deduct Tax For Unsubmitted Tax Exemption Proof,Porez na odbitak za nepotvrđeni dokaz o oslobađanju od poreza
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date updated,Datum odobrenja je ažuriran
DocType: Delivery Trip,Delivery Stops,Dostava se zaustavlja
DocType: Setup Progress,Setup Progress,Postavljanje napretka
,Ordered Items To Be Billed,Naređene stavke za naplatu
DocType: Taxable Salary Slab,To Amount,To Amount
DocType: Purchase Invoice,Is Return (Debit Note),Da li je povratak (zaduženje)
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Kupac&gt; Korisnička grupa&gt; Teritorija
apps/erpnext/erpnext/config/desktop.py,Getting Started,Počinjemo
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge,Spoji
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Nije moguće promijeniti datum početka fiskalne godine i datum završetka fiskalne godine nakon spremanja fiskalne godine.
DocType: Production Plan,Get Material Request,Nabavite zahtjev za materijal
DocType: C-Form Invoice Detail,Invoice No,Faktura br
DocType: Pricing Rule,Max Qty,Max Qty
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 manji ili jednak iznosu upisa za uplatu {2}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Piecework
DocType: Sales Invoice Item,Drop Ship,Drop Ship
DocType: Hub User,Hub User,Korisnik Hub-a
DocType: Lab Test Template,No Result,Nema rezultata
DocType: Bank Statement Transaction Entry,Match Transaction to Invoices,Uskladite transakciju sa fakturama
DocType: Sales Invoice,Commission,Komisija
DocType: Sales Invoice Item,Sales Order Item,Stavka prodajnog naloga
DocType: Maintenance Schedule Detail,Actual Date,Stvarni datum
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance start date can not be before delivery date for Serial No {0},Datum početka održavanja ne može biti prije datuma isporuke za serijski broj {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Exchange Rate is mandatory,Red {0}: Tečaj je obavezan
DocType: Purchase Invoice,Select Supplier Address,Izaberite adresu dobavljača
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Available quantity is {0}, you need {1}","Dostupna količina je {0}, trebate {1}"
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Secret,Unesite tajnu API potrošača
DocType: Program Enrollment Fee,Program Enrollment Fee,Naknada za upis programa
DocType: Employee Checkin,Shift Actual End,Shift Actual End
DocType: Serial No,Warranty Expiry Date,Datum isteka garancije
DocType: Hotel Room Pricing,Hotel Room Pricing,Cijene hotelskih soba
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Outward taxable supplies(other than zero rated, nil rated and exempted","Spoljne oporezive isporuke (osim nultih, nultih i oslobođenih)"
DocType: Issue,Resolution By,Resolution By
DocType: Loyalty Program,Customer Territory,Teritorija korisnika
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication,Last Communication
DocType: Timesheet,Total Billed Hours,Ukupan broj obračunskih sati
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Current invoice {0} is missing,Nedostaje trenutna faktura {0}
DocType: Healthcare Settings,Patient Registration,Registracija pacijenata
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice No exists in Purchase Invoice {0},Broj fakture dobavljača postoji u fakturi kupovine {0}
DocType: Service Day,Workday,Radni dan
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,No Items added to cart,Nema stavki u košaricu
DocType: Target Detail,Target Qty,Target Qty
apps/erpnext/erpnext/stock/doctype/item/item.py,"To merge, following properties must be same for both items","Za spajanje, sljedeća svojstva moraju biti ista za obje stavke"
DocType: Drug Prescription,Drug Prescription,Drug Prescription
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Buildings,Zgrade
DocType: Student Applicant,Application Date,Datum prijave
DocType: Assessment Result,Result,Rezultat
DocType: Leave Block List,Leave Block List Allowed,Ostavite blokiranu listu dopuštenu
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 koja se koristi u {1} {2}
DocType: Purchase Order Item,Blanket Order,Blanket Order
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance for employee {0} is already marked,Pohađanje zaposlenika {0} je već označeno
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py,Assessment Result record {0} already exists.,Zapis rezultata procjene {0} već postoji.
DocType: Purchase Invoice,Rounding Adjustment,Podešavanje zaokruživanja
DocType: Quality Review Table,Quality Review Table,Tabela pregleda kvaliteta
DocType: Member,Membership Expiry Date,Datum isteka članstva
DocType: Asset Finance Book,Expected Value After Useful Life,Očekivana vrijednost nakon korisnog života
DocType: GSTR 3B Report,November,Novembar
DocType: Loan Application,Rate of Interest,Kamatna stopa
DocType: Bank Statement Transaction Payment Item,Bank Statement Transaction Payment Item,Stavka plaćanja transakcije u banci
DocType: Restaurant Reservation,Waitlisted,Waitlisted
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: HR Settings,Leave Status Notification Template,Ostavite šablon za obaveštenje o statusu
DocType: Salary Slip,Leave Without Pay,Ostavi bez plaćanja
DocType: Clinical Procedure Item,Actual Qty (at source/target),Stvarni broj (na izvoru / meti)
DocType: Purchase Invoice,Tax ID,Tax ID
apps/erpnext/erpnext/templates/pages/cart.html,See past orders,Pogledajte prethodne narudžbe
DocType: Stock Reconciliation Item,Current Qty,Current Qty
apps/erpnext/erpnext/buying/utils.py,UOM Conversion factor is required in row {0},UOM konverzijski faktor je potreban u redu {0}
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges",Tablica s detaljima o porezima preuzeta iz glavne stavke kao niz i pohranjena u ovom polju. Koristi se za poreze i naknade
DocType: Appraisal Goal,Key Responsibility Area,Ključna oblast odgovornosti
DocType: Purchase Receipt Item,Sample Quantity,Sample Quantity
DocType: Journal Entry Account,Expense Claim,Expense Claim
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date and Closing Date should be within same Fiscal Year,Datum otvaranja i datum zatvaranja treba da budu u istoj fiskalnoj godini
DocType: Soil Texture,Silt Composition (%),Sastav mulja (%)
DocType: Tax Withholding Rate,Tax Withholding Rate,Stopa zadržavanja poreza
DocType: Restaurant,Default Tax Template,Default Tax Template
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Transfer Asset,Transfer Asset
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp/Lead %,Opp / Lead% \ t
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please cancel Purchase Invoice {0} first,Molimo prvo poništite fakturu kupovine {0}
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Complete Job,Complete Job
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Select Possible Supplier,Odaberite Mogući dobavljač
DocType: POS Profile,Customer Groups,Korisničke grupe
DocType: Hub Tracked Item,Hub Category,Hub Category
apps/erpnext/erpnext/utilities/activation.py,"Quotations are proposals, bids you have sent to your customers","Ponude su ponude, ponude koje ste poslali svojim klijentima"
DocType: Quality Inspection Reading,Reading 5,Čitanje 5
DocType: Shopping Cart Settings,Display Settings,Display Settings
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please set Number of Depreciations Booked,Postavite broj knjiženih amortizacija
DocType: Shift Type,Consequence after,Posledica posle
apps/erpnext/erpnext/templates/pages/help.html,What do you need help with?,Za šta ti treba pomoć?
DocType: Journal Entry,Printing Settings,Printing Settings
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Banking,Bankarstvo
DocType: Purchase Invoice Advance,Purchase Invoice Advance,Avans fakture kupovine
DocType: Student Applicant,EDU-APP-.YYYY.-,EDU-APP-.YYYY.-
DocType: Purchase Invoice Item,PR Detail,PR Detail
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Billing Address is same as Shipping Address,Adresa za naplatu je ista kao i adresa za dostavu
DocType: Account,Cash,Gotovina
DocType: Employee,Leave Policy,Leave Policy
DocType: Shift Type,Consequence,Posljedica
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Address,Student Address
DocType: GST Account,CESS Account,CESS nalog
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}: Centar troška je potreban za račun &#39;Profit i gubitak&#39; {2}. Postavite podrazumevani centar troškova za kompaniju.
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","Prilikom kreiranja korisničkog računa za kompaniju {0}, nadređeni račun {1} nije pronađen. Kreirajte matični račun u odgovarajućoj COA"
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js,General Ledger,Glavna knjiga
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Reminder to update GSTIN Sent,Podsetnik za ažuriranje GSTIN-a
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Select Days,Izaberite Dani
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Next Contact By cannot be same as the Lead Email Address,Sljedeći kontakt ne može biti isti kao i glavna adresa e-pošte
DocType: Packing Slip,To Package No.,U broj paketa
DocType: Course,Course Name,Naziv kursa
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Serial no is required for the asset {0},Serijski broj je potreban za imovinu {0}
DocType: Asset,Maintenance,Održavanje
DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Potvrdite prodajnu cijenu za stavku u odnosu na stopu kupovine ili stopu procjene
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,The following Work Orders were created:,Kreirani su sljedeći radni nalozi:
DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,IFSC Code,IFSC Code
DocType: Bank Statement Transaction Payment Item,Mode of Payment,Način plaćanja
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Iznos poreza nakon iznosa popusta
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Get Suppliers By,Get Dobavljači By
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}: Da biste postavili {1} periodičnost, razlika između i od dana mora biti veća ili jednaka {2}"
DocType: Purchase Invoice Item,Valuation Rate,Rate Rate
DocType: Shopping Cart Settings,Default settings for Shopping Cart,Podrazumevane postavke za Košaricu
DocType: Quiz,Score out of 100,Rezultat od 100
DocType: Manufacturing Settings,Capacity Planning,Planiranje kapaciteta
apps/erpnext/erpnext/utilities/user_progress.py,Go to Instructors,Idi na instruktore
DocType: Activity Cost,Projects,Projekti
DocType: Item Barcode,Barcode Type,Barcode Type
DocType: Employee Incentive,Incentive Amount,Incentive Amount
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js,"To set this Fiscal Year as Default, click on 'Set as Default'","Da biste postavili ovu fiskalnu godinu kao zadanu, kliknite na &quot;Postavi kao zadano&quot;"
DocType: C-Form,II,II
DocType: Cashier Closing,From Time,From Time
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant Details Report,Variant Details Report
,BOM Explorer,BOM Explorer
DocType: Currency Exchange,For Buying,For Buying
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Slots for {0} are not added to the schedule,Sloti za {0} se ne dodaju rasporedu
DocType: Target Detail,Target Distribution,Target Distribution
DocType: Staffing Plan,Staffing Plan Details,Detalji plana osoblja
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}
DocType: Pricing Rule,Rule Description,Opis pravila
DocType: Delivery Trip,Total Estimated Distance,Ukupna procijenjena udaljenost
DocType: Opportunity Lost Reason,Lost Reason,Lost Reason
DocType: Depreciation Schedule,Make Depreciation Entry,Napravite unos amortizacije
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Serial nos {0} does not belongs to the location {1},Serijski nos {0} ne pripada lokaciji {1}
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Uloga dozvoljena za postavljanje zamrznutih naloga i uređivanja zamrznutih unosa
DocType: Employee,Health Concerns,Health Concerns
DocType: Company,Company Info,Company Info
DocType: Activity Cost,Activity Cost,Troškovi aktivnosti
DocType: Journal Entry,Payment Order,Platni nalog
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Pricing,Cijene
,Item Delivery Date,Datum isporuke artikla
DocType: Quality Goal,January-April-July-October,Januar-april-jul-oktobar
DocType: Purchase Order Item,Warehouse and Reference,Skladište i reference
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with child nodes cannot be converted to ledger,Račun sa čvorovima za dijete ne može se pretvoriti u knjigu
DocType: Soil Texture,Clay Composition (%),Sastav gline (%)
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM br. Za gotov proizvod
DocType: Journal Entry,User Remark,Napomena za korisnika
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Your order is out for delivery!,Vaša narudžba je isporučena!
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 jedna od vrsta primanja, plaćanja i internog prenosa"
DocType: HR Settings,Payroll Settings,Postavke platnog spiska
DocType: GST HSN Code,GST HSN Code,GST HSN kod
DocType: Period Closing Voucher,Period Closing Voucher,Period za zatvaranje vaučera
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Name,Ime Guardian2
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please enter Expense Account,Unesite račun troška
DocType: Issue,Resolution By Variance,Rezolucija po varijansi
DocType: Employee,Resignation Letter Date,Datum ostavke
DocType: Soil Texture,Sandy Clay,Sandy Clay
DocType: Upload Attendance,Attendance To Date,Prisustvo na datum
DocType: Invoice Discounting,Loan Start Date,Datum početka kredita
DocType: Workstation,Consumable Cost,Potrošni troškovi
DocType: Leave Type,Encashment,Encashment
DocType: Employee Tax Exemption Declaration,Income From Other Sources,Prihodi od drugih izvora
DocType: Crop,Produced Items,Produced Items
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Approval Status must be 'Approved' or 'Rejected',Status odobrenja mora biti &quot;odobren&quot; ili &quot;odbijen&quot;
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,View Now,Prikaži sada
DocType: Item Price,Valid Upto,Valid Upto
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Reference Doctype must be one of {0},Reference Doctype mora biti jedna od {0}
DocType: Employee Checkin,Skip Auto Attendance,Preskoči Auto Attendance
DocType: Payment Request,Transaction Currency,Valuta transakcije
DocType: Loan,Repayment Schedule,Raspored otplate
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Create Sample Retention Stock Entry,Napravite unos zaliha uzorka
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Open,Postavite kao Otvori
DocType: Job Card,Requested Qty,Requested Qty
DocType: POS Profile,Apply Discount On,Primijeni popust na
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sub contracting,Rezervisano za podugovaranje
apps/erpnext/erpnext/stock/doctype/item/item.py,Item variant {0} exists with same attributes,Varijanta stavke {0} postoji sa istim atributima
DocType: Member,Membership Type,Vrsta članstva
DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Pokazat će studentu prisutnim u mjesečnom izvještaju o učeniku
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Minimum Lead Age (Days),Minimum Lead Age (Dani)
DocType: Shopify Settings,Delivery Note Series,Serija napomena za isporuku
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Academic Year,Obavezno polje - akademska godina
DocType: Vehicle Log,Fuel Price,Cijena goriva
DocType: Travel Itinerary,Mode of Travel,Način putovanja
DocType: Special Test Items,Special Test Items,Posebne testne stavke
DocType: Purchase Invoice,Edit Posting Date and Time,Uredi datum i vrijeme knjiženja
DocType: Sales Order,Not Billed,Not Billed
DocType: Employee Transfer,Employee Transfer Detail,Detalji o transferu zaposlenih
DocType: Project,Task Completion,Završetak zadatka
DocType: Shopify Webhook Detail,Webhook ID,Webhook ID
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Travel Expenses,Putne troškove
apps/erpnext/erpnext/hr/utils.py,Future dates not allowed,Budući datumi nisu dozvoljeni
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Varaiance ,Varaiance
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the Mode of Payment in Payment Schedule,Red {0}: Postavite način plaćanja na rasporedu plaćanja
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Academic Term: ,Akademski mandat:
DocType: Quality Feedback Parameter,Quality Feedback Parameter,Parametar povratne informacije kvaliteta
apps/erpnext/erpnext/accounts/page/pos/pos.js,Please select Apply Discount On,Odaberite Apply Discount On
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Row # {0}: ,Red # {0}:
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Ukupna plaćanja
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please enter Account for Change Amount,Unesite račun za iznos izmjene
DocType: Tax Withholding Account,Tax Withholding Account,Račun zadržavanja poreza
DocType: Account,Stock Received But Not Billed,"Zalihe primljene, ali nisu naplaćene"
apps/erpnext/erpnext/accounts/doctype/account/account.py,Please add the account to root level Company - %s,Dodajte račun na korijensku razinu tvrtke -% s
DocType: Sample Collection,Collected By,Collected By
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Obavijesti putem e-pošte o izradi automatskog zahtjeva za materijal
DocType: Asset Repair,Downtime,Downtime
DocType: Cost Center,Cost Center Number,Broj mjesta troška
DocType: Driver,Applicable for external driver,Primjenjivo za vanjskog vozača
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Start on,Start on
DocType: Sales Invoice,Payment Due Date,Rok plaćanja
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Ako ova stavka ima varijante, onda se ne može odabrati u prodajnim nalozima itd."
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Following course schedules were created,Kreirani su sledeći rasporedi kursa
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Timesheet created:,Timesheet kreiran:
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Otvori BOM {0}
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Transfered,Preneseno
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Payable account,Kredit na račun mora biti račun za plaćanje
DocType: Item,Item Attribute,Atribut stavke
apps/erpnext/erpnext/config/quality_management.py,Goal and Procedure,Cilj i procedura
DocType: Asset,Frequency of Depreciation (Months),Učestalost amortizacije (mjeseci)
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Real Estate,Nekretnina
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Parents Teacher Meeting Attendance,Prisustvo sastancima roditelja
DocType: Employee Grade,Employee Grade,Ocjena zaposlenika
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 je nula, možda bi trebalo da promijenite &quot;Distribuiranje naknada na temelju&quot;"
DocType: Sales Invoice Timesheet,Time Sheet,Time Sheet
DocType: Hotel Room Reservation,Late Checkin,Late Checkin
DocType: Project,Costing and Billing,Obračun troškova i fakturisanje
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Total Outgoing,Total Outgoing
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Uobičajeni ugovor o nivou usluge već postoji.
DocType: Packing Slip,If more than one package of the same type (for print),Ako je više od jednog paketa istog tipa (za ispis)
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Please select Company and Posting Date to getting entries,Molimo odaberite Društvo i Datum knjiženja za dobivanje unosa
DocType: Healthcare Practitioner,Default Currency,Default Currency
DocType: Sales Invoice,Packing List,Lista za pakovanje
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Secretary,Sekretar
DocType: Travel Itinerary,Gluten Free,Bez glutena
DocType: Hub Tracked Item,Hub Node,Hub Node
apps/erpnext/erpnext/projects/report/billing_summary.py,Employee ID,ID zaposlenika
DocType: Salary Structure Assignment,Salary Structure Assignment,Raspodela strukture plata
DocType: POS Closing Voucher Taxes,POS Closing Voucher Taxes,Porez na vaučer za zatvaranje POS-a
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,Action Initialised,Postupak inicijalizovan
DocType: POS Profile,Applicable for Users,Primjenjivo za korisnike
,Delayed Order Report,Izveštaj o odloženoj narudžbi
DocType: Training Event,Exam,Ispit
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 pronađenih unosa glavne knjige. Možda ste u transakciji izabrali pogrešan račun.
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Sales Pipeline,Prodaja naftovoda
,Leaderboard,Leaderboard
DocType: Account,Inter Company Account,Inter Company Account
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Closed order cannot be cancelled. Unclose to cancel.,Zatvorena narudžba se ne može otkazati. Zatvorite da biste otkazali.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} does not exist,{0} {1} ne postoji
DocType: Job Opening,Planned number of Positions,Planirani broj pozicija
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
apps/erpnext/erpnext/accounts/page/pos/pos.js,Please select customer,Molimo odaberite kupca
DocType: Account,Round Off,Zaokružiti
DocType: Pricing Rule,Conditions will be applied on all the selected items combined. ,Uslovi će se primjenjivati na sve odabrane stavke zajedno.
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure,Configure
DocType: Hotel Room,Capacity,Kapacitet
DocType: Employee Checkin,Shift End,Shift End
DocType: Installation Note Item,Installed Qty,Installed Qty
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Batch {0} of Item {1} is disabled.,Paket {0} stavke {1} je onemogućen.
DocType: Hotel Room Reservation,Hotel Reservation User,Korisnik rezervacije hotela
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 nivou usluge sa tipom entiteta {0} i entitetom {1} već postoji.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Item Group not mentioned in item master for item {0},Grupa stavki koja nije navedena u glavnom stavku za stavku {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Name error: {0},Greška imena: {0}
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Territory is Required in POS Profile,Teritorija je obavezna u POS profilu
DocType: Purchase Invoice Item,Service End Date,Datum završetka usluge
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Quotation,Citiranje
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Exchange Rate must be same as {0} {1} ({2}),Tečaj mora biti isti kao i {0} {1} ({2})
DocType: Service Level,Holiday List (ignored during SLA calculation),Lista praznika (zanemarena tokom SLA kalkulacije)
DocType: Student Admission Program,Student Admission Program,Program za prijem studenata
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} can not be a ledger,Račun {0}: Roditeljski račun {1} ne može biti knjiga
DocType: Sales Order,% of materials billed against this Sales Order,% materijala naplaćenih protiv ovog prodajnog naloga
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 pristupnika za plaćanje u planu {0} razlikuje se od računa za pristup za plaćanje u ovom zahtjevu za plaćanje
DocType: Stock Entry Detail,Subcontracted Item,Podugovorna stavka
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 kredita i period kredita su obavezni za čuvanje fakture diskontiranja
DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Appointment charges.,Standardni računi potraživanja koji se koriste ako nisu postavljeni u opciji Pacijent za knjiženje naknada za sastanak.
DocType: Student Attendance Tool,Students HTML,Studenti HTML
DocType: Student Guardian,Student Guardian,Student Guardian
DocType: GoCardless Settings,GoCardless Settings,Postavke GoCardless
DocType: Delivery Note,Transport Receipt Date,Datum prijema prijevoza
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js,Show Opening Entries,Prikaži početne unose
DocType: Vital Signs,Heart Rate / Pulse,Puls / puls
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Assessment Groups,Sve grupe za procjenu
DocType: Asset,Asset Name,Asset Name
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""",Može postojati samo jedno pravilo o pravilu otpremanja s 0 ili praznom vrijednošću za &quot;To Value&quot;
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Optimizing routes.,Optimiziranje ruta.
DocType: Shopify Tax Account,Shopify Tax/Shipping Title,Kupujte porez / naslov za isporuku
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 jednako ili manje od datuma
apps/erpnext/erpnext/utilities/user_progress.py,You added ,Vi ste dodali
DocType: Assessment Result,Total Score,Total Score
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 kreirali standardni predložak u šablonu poreza na promet i troškove, odaberite jedan i kliknite na donji gumb."
DocType: Budget,Cost Center,Centar troškova
apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Ukupno dodeljeni procenat za prodajni tim treba da bude 100
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot deliver Serial No {0} of item {1} as it is reserved \
											to fullfill Sales Order {2}",Nije moguće isporučiti serijski broj {0} stavke {1} jer je rezerviran za fullfill prodajni nalog {2}
apps/erpnext/erpnext/accounts/utils.py,Payment Entry has been modified after you pulled it. Please pull it again.,"Unos plaćanja je izmijenjen nakon što ste ga izvukli. Molim vas, povucite ga ponovo."
DocType: Employee,Bio / Cover Letter,Bio / Cover Letter
DocType: Stock Ledger Entry,Stock Value Difference,Stock Value Difference
DocType: Academic Year,Academic Year Name,Ime akademske godine
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Bank Accounts,Bankovni računi
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,The Payment Term at row {0} is possibly a duplicate.,Termin plaćanja u redu {0} je možda duplikat.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Unblock Invoice,Deblokiraj fakturu
DocType: Pricing Rule,Percentage,Procenat
DocType: Sensitivity Test Items,Sensitivity Test Items,Test Sensitivity Test Items
apps/erpnext/erpnext/config/retail.py,To make Customer based incentive schemes.,Izraditi šeme podsticaja zasnovane na klijentima.
,Purchase Register,Registar kupovine
DocType: Depreciation Schedule,Schedule Date,Datum rasporeda
DocType: Packing Slip,Package Weight Details,Detalji o težini paketa
DocType: Job Applicant,Job Opening,Otvaranje posla
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.,Poslednja poznata uspješna sinkronizacija zaposlenika Checkin. Poništite ovo samo ako ste sigurni da su svi zapisi sinkronizirani sa svih lokacija. Molimo vas da ne menjate ovo ako niste sigurni.
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Stvarna cijena
apps/erpnext/erpnext/controllers/accounts_controller.py,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Ukupni napredak ({0}) protiv narudžbe {1} ne može biti veći od ukupnog iznosa ({2})
apps/erpnext/erpnext/stock/doctype/item/item.py,Item Variants updated,Stavka Varijante su ažurirane
DocType: Item,Batch Number Series,Serijski broj serije
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Projects,Open Projects
DocType: Shopify Settings,Import Delivery Notes from Shopify on Shipment,Uvoz isporuke Bilješke iz Shopify na pošiljci
DocType: QuickBooks Migrator,Token Endpoint,Token Endpoint
apps/erpnext/erpnext/utilities/user_progress.py,List a few of your suppliers. They could be organizations or individuals.,Navedite nekoliko vaših dobavljača. To mogu biti organizacije ili pojedinci.
DocType: Amazon MWS Settings,MWS Credentials,MWS vjerodajnice
DocType: Shopping Cart Settings,Shopping Cart Settings,Postavke košarice
DocType: Sales Invoice Item,Enable Deferred Revenue,Omogući odloženi prihod
apps/erpnext/erpnext/config/help.py,Managing Projects,Upravljanje projektima
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Message Sent,Poruka poslata
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Same item has been entered multiple times. {0},Ista stavka je unesena više puta. {0}
DocType: Pricing Rule,Margin,Margin
apps/erpnext/erpnext/accounts/utils.py,{0} '{1}' not in Fiscal Year {2},{0} &#39;{1}&#39; nije u fiskalnoj godini {2}
DocType: Fee Schedule,Fee Structure,Struktura naknada
apps/erpnext/erpnext/public/js/templates/item_quick_entry.html,Variant Attributes,Atributi varijanti
DocType: Employee,Confirmation Date,Datum potvrde
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please set a default Holiday List for Employee {0} or Company {1},Postavite zadanu listu praznika za zaposlenika {0} ili tvrtku {1}
DocType: Job Applicant Source,Job Applicant Source,Izvor podnosioca prijave za posao
DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Otvaranje alata za kreiranje fakture
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0} does not exist,Račun {0} ne postoji
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Ignore Existing Ordered Qty,Zanemari postojeći naručeni broj
DocType: Material Request Item,Lead Time Date,Date Lead Time Date
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Accounts Receivable Summary,Pregled računa potraživanja
DocType: Asset,Available-for-use Date,Datum raspoloživ za upotrebu
DocType: HR Settings,Employee record is created using selected field. ,Zapis zaposlenika se kreira pomoću izabranog polja.
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}: Vrsta referentnog dokumenta mora biti jedna od narudžbenice, fakture kupovine ili unosa dnevnika"
DocType: Payment Entry,Type of Payment,Vrsta plaćanja
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Leave the field empty to make purchase orders for all suppliers,Ostavite polje prazno kako biste napravili narudžbenice za sve dobavljače
apps/erpnext/erpnext/stock/utils.py,Item {0} ignored since it is not a stock item,Stavka {0} je zanemarena jer nije stavka dionice
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot have Valuation Rate",&quot;Stavka dostavljena od strane korisnika&quot; ne može imati stopu procjene
DocType: Soil Texture,Clay,Clay
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} trenutno ima status {1} dobavljača rezultata, a narudžbenice za ovog dobavljača trebaju biti izdate s oprezom."
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 je stavka varijanta druge stavke, onda će se opis, slika, cijena, porezi itd. Postaviti iz predloška, osim ako nije izričito navedeno"
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Total Target,Total Target
DocType: Location,Longitude,Longitude
DocType: Accounts Settings,Determine Address Tax Category From,Odredite poresku kategoriju adrese
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Identifying Decision Makers,Identifikovanje odluka
DocType: Stock Entry Detail,Reference Purchase Receipt,Referentni račun za kupovinu
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invocies,Get Invocies
DocType: Tally Migration,Is Day Book Data Imported,Da li su podaci o dnevnoj knjizi uvezeni
,Sales Partners Commission,Sales Partners Commission
DocType: Shift Type,Enable Different Consequence for Early Exit,Omogući različite posledice za rani izlazak
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Legal,Legal
DocType: Loan Application,Required by Date,Potrebno po datumu
DocType: Quiz Result,Quiz Result,Rezultat kviza
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Close Loan,Close Loan
DocType: Lead,From Customer,Od kupca
DocType: Payment Reconciliation,Minimum Invoice Amount,Minimalni iznos fakture
apps/erpnext/erpnext/stock/doctype/material_request/material_request_dashboard.py,Related,Povezano
DocType: Drug Prescription,Description/Strength,Opis / Snaga
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work Order cannot be raised against a Item Template,Radni nalog se ne može podići protiv šablona predmeta
DocType: Employee External Work History,Salary,Plata
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Postavi status
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward supplies from ISD,Unutrašnje isporuke iz ISD-a
,Vehicle Expenses,Troškovi vozila
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set 'Apply Additional Discount On',Postavite &#39;Primijeni dodatni popust na&#39;
DocType: Closed Document,Closed Document,Zatvoreni dokument
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py,Please select weekly off day,Molimo da izaberete nedeljni dan
DocType: Leave Type,Applicable After (Working Days),Primjenjivo poslije (radni dani)
DocType: Timesheet Detail,Hrs,Hrs
DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Kriterijumi dobavljača rezultata
DocType: Amazon MWS Settings,FR,FR
DocType: Quality Feedback Template Parameter,Quality Feedback Template Parameter,Parametar predloška kvalitete povratne informacije
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date of Joining must be greater than Date of Birth,Datum pridruživanja mora biti veći od datuma rođenja
DocType: Bank Statement Transaction Invoice Item,Invoice Date,Datum računa
DocType: Healthcare Settings,Create Lab Test(s) on Sales Invoice Submit,Napravite laboratorijske testove na dostavnici dostavnice
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 sastavnica za stavku {0}. Isporuka serijskim brojem ne može biti osigurana
DocType: Employee Education,Post Graduate,Post Graduate
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Račun {0} je unesen više puta
DocType: Employee Benefit Application Detail,Pay Against Benefit Claim,Platite protiv potraživanja povlastica
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Principal Amount,Glavni iznos
apps/erpnext/erpnext/setup/doctype/company/company.py,Main,Main
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,Serial No {0} does not exist,Serijski broj {0} ne postoji
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Program,Molimo odaberite Program
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Discharge,Schedule Discharge
apps/erpnext/erpnext/stock/doctype/batch/batch.py,"Set items shelf life in days, to set expiry based on manufacturing_date plus self life","Postavite rok trajanja stavki u danima, kako biste postavili rok upotrebe na osnovu datuma proizvodnje + životni vek"
DocType: Bank Reconciliation,Get Payment Entries,Primajte uplate za plaćanje
DocType: Amazon MWS Settings,Max Retry Limit,Maksimalno ograničenje ponavljanja
DocType: Woocommerce Settings,Endpoint,Endpoint
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Cost Center is required in row {0} in Taxes table for type {1},Centar troškova je potreban u redu {0} u tabeli Porezi za tip {1}
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,Currency Exchange must be applicable for Buying or for Selling.,Mjenjačnica mora biti primjenjiva za kupovinu ili prodaju.
DocType: Cheque Print Template,Cheque Width,Check Width
DocType: Woocommerce Settings,Secret,Tajna
DocType: Restaurant Order Entry,Current Order,Current Order
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 gumba &quot;Preuzmi stavke iz kupovine&quot;
,Delay Days,Delay Days
DocType: Company,Default Income Account,Default Income Account
DocType: Patient Appointment,Get prescribed procedures,Nabavite propisane procedure
DocType: Lead,Market Segment,Segment tržišta
apps/erpnext/erpnext/projects/doctype/task/task_list.js,Set as Completed,Postavi kao dovršeno
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Completed Qty can not be greater than 'Qty to Manufacture',Završena količina ne može biti veća od &#39;Količina za proizvodnju&#39;
apps/erpnext/erpnext/config/support.py,Service Level.,Nivo usluge.
DocType: Stock Entry,MAT-STE-.YYYY.-,MAT-STE-.YYYY.-
DocType: Fiscal Year,Year Start Date,Datum početka godine
DocType: Work Order Operation,(Hour Rate / 60) * Actual Operation Time,(Hour Rate / 60) * Stvarno vrijeme rada
DocType: C-Form,Received Date,Datum prijema
apps/erpnext/erpnext/config/accounting.py,Financial / accounting year.,Finansijska / obračunska godina.
DocType: Pricing Rule,Pricing Rule,Pravilo o cenama
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Optional Holiday List not set for leave period {0},Neobavezna lista praznika nije postavljena za period odlaska {0}
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please set User ID field in an Employee record to set Employee Role,Postavite polje ID korisnika u zapis zaposlenika da biste postavili ulogu zaposlenika
DocType: Training Event,Training Event,Training Event
DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Normalan krvni pritisak kod odrastanja je oko 120 mmHg sistolički i 80 mmHg dijastolički, skraćeno &quot;120/80 mmHg&quot;."
DocType: Payment Reconciliation,System will fetch all the entries if limit value is zero.,Sistem će dohvatiti sve unose ako je granična vrijednost nula.
DocType: Item,Copy From Item Group,Kopiraj iz grupe stavki
,Bank Remittance,Bankovna doznaka
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","Stopa vrednovanja nije pronađena za stavku {0}, koja je potrebna za knjiženje za {1} {2}. Ako se stavka odnosi na stavku nulte stope procjene u {1}, navedite to u tablici stavki {1}. U suprotnom, kreirajte ulaznu transakciju dionica za stavku ili navedite stopu procjene u zapisu stavke, a zatim pokušajte poslati / otkazati ovaj unos"
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 da bude između između datuma i datuma
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Accrual Journal Entry for salaries from {0} to {1},Unos dnevnog obračuna za plate od {0} do {1}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Material Receipt,Prijem materijala
DocType: Employee Transfer,Re-allocate Leaves,Prerasporedite lišće
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,To Date should be within the Fiscal Year. Assuming To Date = {0},Datum treba da bude u okviru fiskalne godine. Pretpostavljajući da je datum = {0}
DocType: Employee Promotion,Employee Promotion Details,Detalji promocije zaposlenika
DocType: Project User,Project Status,Status projekta
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction can not be deleted,Račun sa postojećom transakcijom ne može se izbrisati
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js,This is a root supplier group and cannot be edited.,Ovo je osnovna grupa dobavljača i ne može se uređivati.
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py,Could not find path for ,Nije moguće pronaći put
DocType: Item Customer Detail,Item Customer Detail,Detalji o kupcu
DocType: Grant Application,Assessment  Mark (Out of 10),Procjenska oznaka (od 10)
DocType: Shareholder,ACC-SH-.YYYY.-,ACC-SH-.YYYY.-
DocType: Lab Test,LabTest Approver,LabTest Approver
DocType: Task,Is Milestone,Is Milestone
DocType: Program Enrollment Tool,Get Students,Get Students
DocType: Program Enrollment,Self-Driving Vehicle,Vozilo za samostalan rad
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} must be a Fixed Asset Item,Stavka {0} mora biti fiksna stavka imovine
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Rent,Office Rent
DocType: Asset,In Maintenance,In Maintenance
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 promijeniti svojstva varijante nakon transakcije dionica. Morat ćete napraviti novu stavku da biste to učinili.
DocType: Purchase Invoice,Unpaid,Neplaćeno
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Name / Number,Ažurirajte naziv / broj računa
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Intern,Intern
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show only POS,Prikaži samo POS
DocType: Cashier Closing,Custody,Starateljstvo
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,From Date cannot be greater than To Date,Datum ne može biti veći od datuma
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,As per your assigned Salary Structure you cannot apply for benefits,Prema vašoj dodijeljenoj strukturi plata ne možete podnijeti zahtjev za povlastice
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup defaults,Nije uspjelo postavljanje zadanih postavki
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account Number {0} already used in account {1},Broj računa {0} je već korišten u računu {1}
DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,Elektronska pošta plaće zaposleniku na osnovu željene e-pošte odabrane u Employee
DocType: Company,Asset Depreciation Cost Center,Centar troškova troškova amortizacije
DocType: Lead,Address Desc,Adresa Desc
DocType: Woocommerce Settings,Enable Sync,Omogući sinhronizaciju
DocType: Student Applicant,Approved,Odobreno
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,From Date should be within the Fiscal Year. Assuming From Date = {0},Od datuma treba da bude u okviru fiskalne godine. Pretpostavljajući od datuma = {0}
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please Set Supplier Group in Buying Settings.,Podesite grupu dobavljača u postavkama kupovine.
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,{} is an invalid Attendance Status.,{} je nevažeći status prisutnosti.
DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Privremeni otvarajući račun
DocType: Purchase Invoice,Cash/Bank Account,Novčani / bankovni račun
DocType: Quality Meeting Table,Quality Meeting Table,Tabela kvaliteta sastanka
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 početka termina ne može biti ranije od datuma početka godine akademske godine na koju je taj termin povezan (akademska godina {}). Ispravite datume i pokušajte ponovo.
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 1,Raspon starenja 1
DocType: Employee Tax Exemption Proof Submission,Tax Exemption Proofs,Dokazi o oslobađanju od poreza
DocType: Purchase Invoice,Price List Currency,Valuta cjenika
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Batch: ,Batch:
DocType: Purchase Invoice,Total Advance,Total Advance
DocType: Employee,Emergency Phone,Telefon za hitne slučajeve
DocType: Inpatient Occupancy,Check Out,Provjeri
DocType: Invoice Discounting,Loan Period,Period kredita
DocType: Loyalty Program,Conversion Factor,Faktor konverzije
DocType: BOM Operation,Operating Cost(Company Currency),Operativni trošak (valuta kompanije)
apps/erpnext/erpnext/config/website.py,"Settings for online shopping cart such as shipping rules, price list etc.","Postavke za on-line korpe za kupovinu, kao što su pravila za dostavu, cenovnik itd."
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Edit Publishing Details,Uredi detalje objavljivanja
DocType: Soil Texture,Soil Texture Criteria,Kriterijumi za teksturu tla
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Department...,Odaberite odjel ...
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Currency should be same as Price List Currency: {0},Valuta mora biti ista kao i cjenovnik: {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row #{0}: Please specify Serial No for Item {1},Red # {0}: navedite serijski broj za stavku {1}
DocType: Plant Analysis Criteria,Minimum Permissible Value,Minimalna dozvoljena vrijednost
DocType: Stock Entry,Source Warehouse Address,Adresa skladišta izvora
DocType: Compensatory Leave Request,Compensatory Leave Request,Zahtjev za kompenzacijski dopust
DocType: Lead,Mobile No.,Mobile No.
DocType: GSTR 3B Report,July,Jul
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Eligible ITC,Prihvatljivi ITC
DocType: Fertilizer,Density (if liquid),Gustina (ako je tečna)
DocType: Employee,External Work History,Vanjska radna povijest
DocType: Quality Inspection,Outgoing,Outgoing
DocType: Email Digest,Add Quote,Add Quote
DocType: Inpatient Record,Discharge,Ispuštanje
DocType: Amazon MWS Settings,MWS Auth Token,MWS Auth Token
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,"Food, Beverage & Tobacco","Hrana, piće i duhan"
apps/erpnext/erpnext/education/doctype/course/course.js,Course Schedule,Raspored kursa
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Stavka Wise Tax Detail
DocType: Shift Type,Attendance will be marked automatically only after this date.,Prisustvo će biti automatski označeno tek nakon tog datuma.
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to UIN holders,Potrošnja za UIN nosioce
apps/erpnext/erpnext/hooks.py,Request for Quotations,Zahtev za ponudu
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 unosa neke druge valute
apps/erpnext/erpnext/controllers/accounts_controller.py,Cannot set quantity less than delivered quantity,Nije moguće postaviti količinu manju od isporučene količine
apps/erpnext/erpnext/config/accounting.py,Bank/Cash transactions against party or for internal transfer,Banke / Gotovinske transakcije protiv stranke ili za interni transfer
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py,Disabled template must not be default template,Onemogućeni predložak ne smije biti zadani predložak
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Absent,Mark Absent
DocType: Salary Component,Statistical Component,Statistical Component
DocType: Bin,Reserved Quantity,Rezervirana količina
DocType: Vehicle,Insurance Company,Insurance Company
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Note: Item {0} entered multiple times,Napomena: Stavka {0} je unesena više puta
DocType: Plant Analysis,Collection Datetime,Collection Datetime
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Total Achieved,Ukupno postignuto
DocType: Course Topic,Topic,Tema
DocType: Employee Promotion,Promotion Date,Datum promocije
DocType: Tax Withholding Category,Account Details,Detalji računa
DocType: POS Profile,Allow user to edit Rate,Omogući korisniku da uređuje stopu
DocType: Healthcare Settings,Result Emailed,Rezultat e-poštom
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js,View Leads,View Leads
DocType: Fee Validity,Visited yet,Posetio još
DocType: Purchase Invoice,Terms,Uslovi
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Disbursed Amount cannot be greater than Loan Amount {0},Iznos isplate ne može biti veći od iznosa zajma {0}
DocType: Share Balance,Issued,Izdato
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Admission,Schedule Admission
apps/erpnext/erpnext/public/js/templates/contact_list.html,No contacts added yet.,Još nije dodan nijedan kontakt.
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Create Print Format,Kreirajte format za štampanje
DocType: Asset,Policy number,Broj police
DocType: GL Entry,Against Voucher,Against Voucher
DocType: Bank Statement Transaction Payment Item,Payment Reference,Referenca plaćanja
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Student Mobile No.,Student Mobile No.
DocType: Cheque Print Template,Cheque Print Template,Proverite šablon za štampanje
DocType: Loyalty Program Collection,For how much spent = 1 Loyalty Point,Koliko je potrošeno = 1 bod lojalnosti
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,Email Digest: ,Email Digest:
DocType: Accounts Settings,Show Inclusive Tax In Print,Prikaži uključeni porez u štampi
DocType: Student Report Generation Tool,Include All Assessment Group,Uključi sve grupe za procjenu
DocType: Employee Benefit Application,Employee Benefits,Benefits za zaposlene
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 prekoračuje ograničenje {0} {1} za stavku {4}. Da li pravite još jednu {3} protiv iste {2}?
DocType: Leave Type,Is Optional Leave,Opcionalno odlazi
DocType: Cash Flow Mapping,Is Finance Cost,Je finansijski trošak
DocType: Vehicle,Doors,Vrata
DocType: Shopify Settings,Customer Settings,Korisničke postavke
DocType: Purchase Invoice Item,Include Exploded Items,Uključi eksplodirane stavke
DocType: Assessment Plan,Evaluate,Evaluate
DocType: Purchase Invoice Item,Is Free Item,Is Free Item
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Present,Total Present
DocType: Item,Is Item from Hub,Je stavka iz čvorišta
apps/erpnext/erpnext/config/quality_management.py,Quality Procedure.,Procedura kvaliteta.
DocType: Share Balance,No of Shares,Broj dionica
DocType: Quality Action,Preventive,Preventivno
DocType: Support Settings,Forum URL,URL foruma
apps/erpnext/erpnext/config/hr.py,Employee and Attendance,Zaposleni i prisutni
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Vital Signs,Vital Signs
DocType: Academic Term,Academics User,Korisnik akademika
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Get Items from BOM,Nabavite stavke iz BOM-a
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Serial No is mandatory for Item {0},Serijski broj je obavezan za stavku {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Get Items from Prescriptions,Nabavite stavke iz recepta
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},Nije moguće otkazati {0} {1} jer serijski broj {2} ne pripada skladištu {3}
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,View Orders,View Orders
DocType: Staffing Plan Detail,Number Of Positions,Broj pozicija
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Walk In,Ući
DocType: Shopify Settings,Import Sales Invoice from Shopify if Payment is marked,Uvoz fakture prodaje iz Shopify ako je plaćanje označeno
DocType: Certification Application,Certification Status,Status certifikacije
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Source Location is required for the asset {0},Lokacija izvora je potrebna za imovinu {0}
DocType: Employee,Encashment Date,Datum unovčavanja
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 završenog dnevnika održavanja imovine
DocType: Quiz,Latest Attempt,Latest Attempt
DocType: Leave Block List,Allow Users,Dozvoli korisnicima
apps/erpnext/erpnext/accounts/doctype/account/account.js,Chart Of Accounts,Chart of Accounts
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py,Customer is mandatory if 'Opportunity From' is selected as Customer,Korisnik je obavezan ako je za klijenta izabrana opcija &#39;Opportunity From&#39;
DocType: Customer,Primary Address,Primary Address
DocType: Room,Room Name,Ime sobe
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Tax Id: ,Identifikacija poreza:
DocType: Serial No,Creation Document No,Kreiranje dokumenta br
apps/erpnext/erpnext/stock/doctype/item/item.js,Projected,Projected
DocType: Purchase Invoice Item,Rejected Qty,Odbijena količina
DocType: Pricing Rule,Free Item,Free Item
DocType: Salary Component,Is Payable,Is Payable
DocType: Clinical Procedure Template,Allow Stock Consumption,Dopusti potrošnju zaliha
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Akademski termin sa ovom &#39;akademskom godinom&#39; {0} i &#39;Ime termina&#39; {1} već postoji. Izmijenite ove unose i pokušajte ponovo.
DocType: Payment Entry,Initiated,Inicirano
apps/erpnext/erpnext/config/selling.py,Blanket Orders from Costumers.,Narudžbenice od kupaca.
DocType: Sales Order Item,Used for Production Plan,Koristi se za plan proizvodnje
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 2,Raspon starenja 2
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Time logs are required for job card {0},Dnevnici vremena su potrebni za karticu posla {0}
DocType: Expense Claim,Vehicle Log,Log vozila
DocType: Grading Scale,Grading Scale Intervals,Intervali skale za ocjenjivanje
DocType: Accounts Settings,Report Settings,Postavke izvještaja
apps/erpnext/erpnext/config/retail.py,Point-of-Sale Profile,Profil prodajnog mjesta
DocType: Lab Test Groups,Lab Test Groups,Lab Test Groups
DocType: Stock Settings,Default Valuation Method,Default Valuation Method
DocType: Item,Safety Stock,Safety Stock
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Print settings updated in respective print format,Postavke ispisa ažurirane u odgovarajućem formatu ispisa
DocType: Support Settings,Issues,Problemi
apps/erpnext/erpnext/utilities/user_progress.py,Student Application,Student Application
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Extra Large,Ekstra veliki
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Remaining Balance,Preostali iznos
DocType: Lead,Industry,Industrija
DocType: Payment Entry,Cheque/Reference Date,Datum provjere / reference
DocType: Asset Movement,Stock Manager,Stock Manager
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,No items to be received are overdue,Nema stavki koje treba primiti
apps/erpnext/erpnext/config/non_profit.py,Grant information.,Grant information.
apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Postavite filtar tvrtke prazan ako je Grupa po &quot;Tvrtka&quot;
apps/erpnext/erpnext/erpnext_integrations/doctype/amazon_mws_settings/amazon_methods.py,Sync has been temporarily disabled because maximum retries have been exceeded,Sinhronizacija je privremeno onemogućena jer su prekoračeni maksimalni ponovi
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled or stopped,{0} {1} je otkazan ili zaustavljen
DocType: Asset Maintenance Log,Has Certificate,Ima certifikat
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 artikla, serijskom broju, serijskom broju ili barkodu"
DocType: Item Price,Multiple Item prices.,Višestruke cijene stavke.
DocType: Request for Quotation,Request for Quotation,Zahtev za ponudu
DocType: Stock Reconciliation Item,Current Valuation Rate,Current Valuation Rate
DocType: Tax Rule,Shipping County,Shipping County
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Perception Analysis,Analiza percepcije
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item {0} is not active or end of life has been reached,Stavka {0} nije aktivna ili je dostignut kraj života
apps/erpnext/erpnext/stock/doctype/item/item.js,Single Variant,Single Variant
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Red # {0}: Vrsta referentnog dokumenta mora biti jedna od tvrdnji o troškovima ili unosa dnevnika
DocType: Purchase Invoice,Print Language,Jezik ispisa
DocType: Pricing Rule,Pricing Rule Help,Pravilo za pomoć za cijene
DocType: Shareholder,Contact List,Lista kontakata
DocType: Employee,Better Prospects,Better Prospects
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 se ne generira za sve stavke. Molimo kliknite na &#39;Generiraj raspored&#39;
DocType: Authorization Rule,Itemwise Discount,Itemwise Discount
DocType: Inpatient Record,Patient Encounter,Pacijentski susret
apps/erpnext/erpnext/config/non_profit.py,Define various loan types,Definišite različite vrste kredita
DocType: Supplier,Supplier Type,Tip dobavljača
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Collected: {0},Ukupno prikupljenih: {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Credit Card,Kreditna kartica
DocType: Warranty Claim,SER-WRN-.YYYY.-,SER-WRN -YYYY.-
DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Setup Scorecard za dobavljača
DocType: Amazon MWS Settings,Amazon MWS Settings,Amazon MWS postavke
DocType: Program Enrollment,Walking,Hodanje
DocType: SMS Log,Requested Numbers,Requested Numbers
DocType: Woocommerce Settings,Freight and Forwarding Account,Račun za otpremu i otpremu
apps/erpnext/erpnext/accounts/party.py,Please select a Company,Molimo izaberite kompaniju
apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py,Row {0}: {1} must be greater than 0,Red {0}: {1} mora biti veći od 0
apps/erpnext/erpnext/public/js/setup_wizard.js,Upload your letter head and logo. (you can edit them later).,Otpremite pismo i logo. (kasnije ih možete urediti).
DocType: Salary Component,Create Separate Payment Entry Against Benefit Claim,Napravite poseban unos plaćanja protiv potraživanja povlastica
apps/erpnext/erpnext/utilities/bot.py,Did not find any item called {0},Nije pronađena nijedna stavka pod nazivom {0}
DocType: Student,Nationality,Nacionalnost
DocType: BOM Item,Scrap %,Scrap%
DocType: Item,Inspection Criteria,Kriteriji inspekcije
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup company,Nije uspjelo postavljanje tvrtke
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To account must be a Balance Sheet account,Zaduženje Račun mora biti račun računa
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Number of Order,Broj narudžbe
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: Purchase Invoice,Items,Stavke
DocType: C-Form,I,I
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Work-in-Progress Warehouse is required before Submit,Prije slanja je potrebno skladište za rad u tijeku
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","Prodajna narudžba {0} ima rezervaciju za stavku {1}, možete isporučiti rezervisanu {1} protiv {0}. Serijski broj {2} ne može biti isporučen"
DocType: Quality Goal,Monitoring Frequency,Frekvencija nadgledanja
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,Closing Balance,Završni bilans
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Sold Asset,Trošak prodate imovine
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Qty can not be entered in Purchase Return,Red # {0}: Odbijeni broj se ne može unijeti u Povratak kupovine
DocType: Asset Maintenance Log,ACC-AML-.YYYY.-,ACC-AML-.YYYY.-
DocType: GSTR 3B Report,JSON Output,JSON izlaz
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Increment cannot be 0,Povećanje ne može biti 0
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} must be submitted,BOM {0} mora biti dostavljen
DocType: Amazon MWS Settings,Synch Orders,Synch Orders
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Disburse Loan,Kredit za isplatu
DocType: Item,Delivered by Supplier (Drop Ship),Isporučuje dobavljač (Drop Ship)
apps/erpnext/erpnext/templates/pages/cart.html,Place Order,Place Order
DocType: Employee,Place of Issue,Mjesto izdavanja
DocType: Purchase Receipt,Transporter Details,Transporter Details
,Gross and Net Profit Report,Izvještaj o bruto i neto dobiti
DocType: Appraisal Template,Appraisal Template Title,Naslov šablona procjene
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Orders Created: {0},Napravljeni radni nalozi: {0}
DocType: Packed Item,To Warehouse (Optional),U skladište (opcionalno)
DocType: Appointment Type,Physician,Lekar
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Until,Do
DocType: Leave Policy,Leave Policy Details,Ostavite detalje o politici
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- {first_name} - {date_of_birth.year} <br> Ovo će generirati lozinku kao SAL-Jane-1972
apps/erpnext/erpnext/config/accounting.py,To make recurring documents,Da pravite dokumente koji se ponavljaju
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,PDC/LC Ref,PDC / LC Ref
DocType: Naming Series,Update Series Number,Ažurirajte broj serije
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 da razmotrite grupu dok pravite grupe zasnovane na kursu.
DocType: Assessment Plan Criteria,Maximum Score,Maximum Score
DocType: Website Filter Field,Website Filter Field,Polje za filtriranje web-lokacije
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Probationary Period,Probnog perioda
DocType: Travel Request,Require Full Funding,Zahtevati potpuno finansiranje
DocType: Batch,Manufacturing Date,Datum proizvodnje
apps/erpnext/erpnext/utilities/activation.py,Group your students in batches,Grupirajte učenike u grupama
DocType: Payroll Entry,Bimonthly,Bimonthly
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Eliminated due to disposal of assets,Amortizacija se otpisuje zbog otuđenja imovine
DocType: Maintenance Visit,Purposes,Ciljevi
apps/erpnext/erpnext/hooks.py,Shipments,Pošiljke
DocType: Program Enrollment Tool,New Academic Term,Novi akademski mandat
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Nothing is included in gross,Ništa nije uključeno u bruto
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,New Warehouse Name,Novo ime skladišta
apps/erpnext/erpnext/selling/report/sales_partner_transaction_summary/sales_partner_transaction_summary.js,Show Return Entries,Prikaži povratne unose
DocType: Soil Texture,Soil Type,Vrsta tla
DocType: Loyalty Program,Multiple Tier Program,Višestruki program
DocType: BOM Update Tool,The BOM which will be replaced,BOM koji će biti zamijenjen
DocType: Patient,Risk Factors,Faktori rizika
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sale,Rezervirano za prodaju
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Prescriptions,Prescriptions
apps/erpnext/erpnext/config/accounting.py,Bills raised to Customers.,Računi podignuti kupcima.
DocType: Training Event,Seminar,Seminar
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Credit ({0}),Kredit ({0})
DocType: Payment Request,Subscription Plans,Planovi pretplate
DocType: GSTR 3B Report,March,Mart
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split Batch,Split Batch
DocType: School House,House Name,Ime kuće
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Outstanding for {0} cannot be less than zero ({1}),Izvanredno za {0} ne može biti manja od nule ({1})
DocType: Vehicle,Petrol,Petrol
DocType: Customer,Bypass credit limit check at Sales Order,Zaobići kreditni limit provjerite kod prodajnog naloga
DocType: Employee External Work History,Employee External Work History,Vanjska radna povijest zaposlenika
DocType: HR Settings,Expense Approver Mandatory In Expense Claim,Odobren trošak Obavezan u potraživanju troškova
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Optional. Sets company's default currency, if not specified.","Opcionalno. Postavlja zadanu valutu kompanije, ako nije navedena."
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Monthly Repayment Amount cannot be greater than Loan Amount,Iznos mjesečne otplate ne može biti veći od iznosa zajma
DocType: Leave Allocation,Allocation,Dodjela
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid attachment {0},Upozorenje: neispravan prilog {0}
DocType: Vehicle,License Plate,License Plate
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Paid Amount cannot be greater than total negative outstanding amount {0},Plaćeni iznos ne može biti veći od ukupnog negativnog iznosa nepodmirenog iznosa {0}
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js,Stock quantity to start procedure is not available in the warehouse. Do you want to record a Stock Transfer,Količina zaliha za početak postupka nije dostupna u skladištu. Želite li snimiti prijenos dionica
DocType: Bank Guarantee,Clauses and Conditions,Klauzule i uslovi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please select correct account,Odaberite ispravan račun
DocType: Content Activity,Content Activity,Content Activity
DocType: Pricing Rule Detail,Pricing Rule Detail,Detalj pravila o cenama
DocType: Loan,Monthly Repayment Amount,Mesečni iznos otplate
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Isporučena stavka računa za kupovinu
DocType: Leave Control Panel,Employment Type (optional),Tip zaposlenja (izborno)
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid {0} for Inter Company Transaction.,Nevažeći {0} za internu transakciju kompanije.
DocType: Asset Movement,From Employee,From Employee
DocType: Attendance,Attendance Date,Datum prisustva
apps/erpnext/erpnext/setup/doctype/company/company.js,There were errors.,Bilo je grešaka.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consumer Products,Consumer Products
DocType: Email Digest,Add/Remove Recipients,Dodaj / ukloni primaoce
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Iznos poreza nakon iznosa popusta (valuta kompanije)
DocType: Account,Capital Work in Progress,Kapitalni rad u toku
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Browse BOM
DocType: Cash Flow Mapping,Select Maximum Of 1,Izaberite Maksimalno 1
DocType: Stock Settings,Batch Identification,Identifikacija serije
DocType: Pricing Rule Brand,Pricing Rule Brand,Marka pravila za određivanje cijena
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js,This is a root sales person and cannot be edited.,Ovo je korijenski prodavač i ne može se uređivati.
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Payroll date can not be less than employee's joining date,Datum na platnom spisku ne može biti manji od datuma pridruživanja zaposlenog
DocType: Fee Validity,Max number of visit,Maksimalan broj posjeta
DocType: Item,Serial Nos and Batches,Serijski brojevi i paketi
DocType: HR Settings,Password Policy,Politika lozinki
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,There were errors creating Course Schedule,Bilo je grešaka pri kreiranju rasporeda kursa
DocType: Student Attendance Tool,Batch,Batch
DocType: Amazon MWS Settings,ERPNext Integrations,ERPNext Integrations
DocType: Batch,Source Document Name,Naziv izvornog dokumenta
DocType: Restaurant,Invoice Series Prefix,Prefiks serije faktura
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,90-Above,90-Iznad
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Currency for {0} must be {1},Valuta za {0} mora biti {1}
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,From Date must be before To Date,Od datuma mora biti prije datuma
DocType: Delivery Settings,Dispatch Notification Attachment,Prilog o obavještenju o otpremi
apps/erpnext/erpnext/controllers/accounts_controller.py,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Ukupni iznos uplate na rasporedu plaćanja mora biti jednak Grand / Rounded Total
,Itemwise Recommended Reorder Level,Preporučeni nivo ponovne narudžbe
DocType: Course Activity,Video,Video
DocType: Salary Slip Loan,Salary Slip Loan,Zajam za isplatu plata
DocType: Account,Balance Sheet,Bilans
DocType: Email Digest,Payables,Obveze
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Created,Fee Created
,Customer Acquisition and Loyalty,Kupnja kupaca i lojalnost
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Student Group Name is mandatory in row {0},Ime grupe učenika je obavezno u redu {0}
apps/erpnext/erpnext/config/accounting.py,Exchange Rate Revaluation master.,Master revalorizacije kursa.
apps/erpnext/erpnext/controllers/status_updater.py,Status must be one of {0},Status mora biti jedan od {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",Za karticu posla {0} možete izvršiti samo unos zaliha &#39;Transfer materijala za proizvodnju&#39;
DocType: Asset,Insurance Start Date,Datum početka osiguranja
DocType: Target Detail,Target Detail,Target Detail
DocType: Packing Slip,Net Weight UOM,Neto težina UOM
DocType: Purchase Invoice Item,Net Amount (Company Currency),Neto iznos (valuta kompanije)
DocType: Bank Statement Transaction Settings Item,Mapped Data,Mapirani podaci
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
DocType: Promotional Scheme Price Discount,Discount Type,Tip popusta
DocType: Hotel Settings,Default Taxes and Charges,Podrazumevani porezi i naknade
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py,This is based on transactions against this Supplier. See timeline below for details,Ovo se zasniva na transakcijama protiv ovog dobavljača. Za detalje pogledajte vremensku liniju ispod
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum benefit amount of employee {0} exceeds {1},Maksimalni iznos naknade zaposlenika {0} premašuje {1}
DocType: Delivery Note Item,Against Sales Invoice,Protiv fakture prodaje
DocType: Loyalty Point Entry,Purchase Amount,Iznos kupovine
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Cannot set as Lost as Sales Order is made.,Nije moguće postaviti kao Izgubljeno kao prodajni nalog.
DocType: Salary Structure,Salary Component for timesheet based payroll.,Komponenta plata za obračun plaća zasnovan na vremenskom rasporedu.
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py,Suplier Name,Suplier Name
DocType: Manufacturing Settings,Allow multiple Material Consumption against a Work Order,Omogućite višestruku potrošnju materijala u odnosu na radni nalog
apps/erpnext/erpnext/templates/pages/help.html,Open a new ticket,Otvori novu kartu
apps/erpnext/erpnext/public/js/conf.js,Report an Issue,Prijavite problem
DocType: Support Search Source,Link Options,Opcije veze
DocType: Selling Settings,Sales Update Frequency,Frekvencija ažuriranja prodaje
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Pin Code,Za PIN kod
apps/erpnext/erpnext/config/crm.py,Newsletters,Newsletters
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,License,Licenca
DocType: Employee Tax Exemption Declaration,Other Incomes,Ostali prihodi
DocType: Job Card,Job Started,Job Started
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set recurring after saving,Podesite ponavljanje nakon spremanja
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Atleast one item should be entered with negative quantity in return document,Najmanje jedna stavka treba da se unese sa negativnom količinom u povratnom dokumentu
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for Hold,Razlog za zadržavanje
apps/erpnext/erpnext/regional/report/hsn_wise_summary_of_outward_supplies/hsn_wise_summary_of_outward_supplies.js,HSN/SAC,HSN / SAC
DocType: Homepage,"URL for ""All Products""",URL za &quot;Svi proizvodi&quot;
DocType: Lead,Organization Name,Ime organizacije
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from and valid upto fields are mandatory for the cumulative,Važeća i valjana polja upto su obavezna za kumulativ
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Batch No must be same as {1} {2},Red # {0}: Serijski broj mora biti isti kao i {1} {2}
DocType: Employee Checkin,Shift Start,Shift Start
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock transactions before {0} are frozen,Stock transakcije prije {0} su zamrznute
DocType: Driver,Issuing Date,Datum izdavanja
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requestor,Requestor
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Centar troškova {2} ne pripada kompaniji {3}
DocType: Certification Application,Not Certified,Nije certificirano
DocType: Work Order,Check if material transfer entry is not required,Provjerite nije li unos prijenosa materijala potreban
DocType: BOM,Raw Material Cost,Troškovi sirovine
DocType: Project,Second Email,Second Email
DocType: Vehicle Log,Service Detail,Service Detail
DocType: Manufacturing Settings,Default 10 mins,Default 10 mins
DocType: Subscription Plan,Billing Interval,Interval naplate
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Total Debit must be equal to Total Credit. The difference is {0},Ukupan debit mora biti jednak ukupnom kreditu. Razlika je {0}
DocType: Supplier,Name and Type,Ime i tip
DocType: Cheque Print Template,Cheque Height,Proverite visinu
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please enter relieving date.,Unesite datum oslobađanja.
DocType: Loyalty Program,Loyalty Program Help,Pomoć za program lojalnosti
DocType: Journal Entry,Inter Company Journal Entry Reference,Inter Company Journal Entry Reference
DocType: Quality Meeting,Agenda,Agenda
DocType: Quality Action,Corrective,Korektivno
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js,Group By,Group By
DocType: Bank Account,Address and Contact,Adresa i kontakt
DocType: Payment Term,Day(s) after invoice date,Dan (a) nakon datuma fakture
DocType: Woocommerce Settings,API consumer secret,Tajna API korisnika
DocType: Shift Assignment,Shift Assignment,Shift Assignment
DocType: Maintenance Visit,MAT-MVS-.YYYY.-,MAT-MVS-.YYYY.-
DocType: Issue,First Responded On,Prvi odgovor je uključen
DocType: Work Order Operation,Estimated Time and Cost,Procijenjeno vrijeme i trošak
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Return / Credit Note,Povratna / kreditna napomena
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Select Default Supplier,Izaberite Default Supplier
DocType: Water Analysis,Appearance,Izgled
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Voucher #,Voucher #
DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Podešavanje vrste računa pomaže u odabiru ovog računa u transakcijama.
apps/erpnext/erpnext/config/projects.py,Define Project type.,Definirajte tip projekta.
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to install presets,Nije uspjelo instaliranje predpodešavanja
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Root Company,Root Company
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,Default Activity Cost exists for Activity Type - {0},Osnovni trošak aktivnosti postoji za vrstu aktivnosti - {0}
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Target Location,Target Location
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Count,Broj naloga
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Invoice Patient Registration,Registracija računa pacijenta
DocType: Training Event Employee,Training Event Employee,Training Event Employee
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 zapise prethodno generiranih faktura. Jeste li sigurni da želite ponovo pokrenuti ovu pretplatu?
DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Detalji šablona mapiranja novčanog toka
apps/erpnext/erpnext/config/hr.py,Recruitment and Training,Zapošljavanje i obuka
DocType: Drug Prescription,Interval UOM,Interval UOM
DocType: Shift Type,Grace Period Settings For Auto Attendance,Podešavanja Grace perioda za automatsko pozivanje
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Iz valute i valute ne može biti isto
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Pharmaceuticals,Pharmaceuticals
DocType: Employee,HR-EMP-,HR-EMP-
DocType: Service Level,Support Hours,Sati podrške
apps/erpnext/erpnext/controllers/selling_controller.py,{0} {1} is cancelled or closed,{0} {1} je otkazan ili zatvoren
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Red {0}: avans protiv klijenta mora biti kredit
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Voucher (Consolidated),Grupisanje po vaučeru (Konsolidovano)
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Please set default account in Expense Claim Type {0},Postavite zadani račun u vrsti zahtjeva za troškove {0}
,BOM Search,BOM Search
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Dispatch State,Dispatch State
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Continue Configuration,Nastavi konfiguraciju
DocType: Item Alternative,Item Alternative,Item Alternative
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Healthcare Practitioner...,Izaberite zdravstveni radnik ...
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Employee {0} already submited an apllication {1} for the payroll period {2},Zaposleni {0} je već poslao aplikaciju {1} za period obračuna plaća {2}
apps/erpnext/erpnext/controllers/accounts_controller.py,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Napomena: unos za plaćanje neće biti kreiran jer nije naveden &quot;Novčani ili bankovni račun&quot;
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non GST Inward Supplies,Non GST Inward Supplies
DocType: Detected Disease,Disease,Bolest
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,'To Date' is required,&#39;To Date&#39; je obavezno
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Capital Equipments,Kapitalna oprema
DocType: Bank Statement Settings,Statement Headers,Zaglavlja izvoda
DocType: Packing Slip,Gross Weight UOM,Bruto težina UOM
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please check Multi Currency option to allow accounts with other currency,Molimo provjerite opciju Multi Currency da biste omogućili račune s drugom valutom
DocType: Loan,Repay Fixed Amount per Period,Povrati fiksni iznos po periodu
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Show Variant Attributes,Prikaži atribute varijante
DocType: GL Entry,Credit Amount,Iznos kredita
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Total Amount Credited,Ukupan iznos odobren
DocType: Support Search Source,Post Route Key List,Postavi listu ključeva rute
apps/erpnext/erpnext/accounts/utils.py,{0} {1} not in any active Fiscal Year.,{0} {1} nije u nekoj aktivnoj fiskalnoj godini.
DocType: Quality Action Resolution,Problem,Problem
DocType: Training Event,Conference,Konferencija
DocType: Mode of Payment Account,Mode of Payment Account,Račun plaćanja
DocType: Leave Encashment,Encashable days,Dani u kojima se može izvršiti povrat
DocType: Healthcare Settings,Collect Fee for Patient Registration,Prikupite naknadu za registraciju pacijenta
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Disable Template,Onemogući predložak
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Filter Employees By (Optional),Filtrirajte zaposlenike prema (neobavezno)
apps/erpnext/erpnext/setup/default_success_action.py,{0} has been submitted successfully,{0} je uspješno poslana
DocType: Workstation,Wages per hour,Plate po satu
DocType: Item,Max Discount (%),Maksimalni popust (%)
DocType: Employee,Salary Mode,Način plata
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 od {0} postavljen u ovom zahtjevu za plaćanje razlikuje se od izračunatog iznosa svih planova plaćanja: {1}. Uvjerite se da je to ispravno prije slanja dokumenta.
DocType: Opportunity,Contact Info,Kontakt info
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Transaction reference no {0} dated {1},Referenca transakcije broj {0} od {1}
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Currency is required for Price List {0},Valuta je potrebna za Cjenovnik {0}
DocType: Program,Program Name,Naziv programa
apps/erpnext/erpnext/accounts/doctype/account/account.js,This is a root account and cannot be edited.,Ovo je root nalog i ne može se uređivati.
apps/erpnext/erpnext/projects/doctype/task/task.py,'Expected Start Date' can not be greater than 'Expected End Date',&quot;Očekivani datum početka&quot; ne može biti veći od &quot;Očekivani datum završetka&quot;
DocType: Employee Tax Exemption Declaration Category,Employee Tax Exemption Declaration Category,Kategorija izjave o izuzeću od poreza na zaposlene
DocType: Work Order,Item To Manufacture,Stavka za proizvodnju
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,In Qty,In Qty
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","&quot;Is Fixed Asset&quot; se ne može poništiti, jer evidencija imovine postoji protiv stavke"
DocType: Salary Component,Flexible Benefits,Flexible Benefits
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Approval Notification,Obavijest o odobrenju
DocType: Employee Tax Exemption Proof Submission,Total Actual Amount,Ukupni stvarni iznos
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party is mandatory,Stranka je obavezna
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Check all,Provjeri sve
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 neograničeno isteče za bodove lojalnosti, zadržite prazno trajanje isteka ili 0."
DocType: Attendance Request,Explanation,Objašnjenje
DocType: Journal Entry Account,Exchange Rate,Kurs
DocType: Task,Total Costing Amount (via Time Sheet),Ukupni iznos troškova (putem vremenskog lista)
DocType: Tax Rule,Billing County,Billing County
DocType: Lead Source,Lead Source,Lead Source
DocType: Email Digest,Next email will be sent on:,Sljedeća e-pošta će biti poslana na:
DocType: Batch,Source Document Type,Vrsta izvornog dokumenta
DocType: Project,Frequency To Collect Progress,Učestalost prikupljanja napretka
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Head of Marketing and Sales,Voditelj marketinga i prodaje
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Supplier Quotation {0} created,Stvorena je Ponuda dobavljača {0}
apps/erpnext/erpnext/setup/doctype/company/company.js,Successfully deleted all transactions related to this company!,Uspješno obrisane sve transakcije vezane za ovu kompaniju!
DocType: Purchase Taxes and Charges,On Net Total,On Net Total
DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Hold,Držite
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,You can not enter current voucher in 'Against Journal Entry' column,Ne možete uneti trenutni vaučer u kolonu „Protiv dnevnika“
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Please select Company and Party Type first,Prvo izaberite Company and Party Type
apps/erpnext/erpnext/utilities/user_progress.py,Go to ,Idi
,Work Orders in Progress,Radni nalozi u toku
DocType: Payment Reconciliation,To Invoice Date,Na datum fakture
DocType: Staffing Plan Detail,Vacancies,Slobodna radna mjesta
DocType: Purchase Order Item,Last Purchase Rate,Poslednja stopa kupovine
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Sales Expenses,Troškovi prodaje
DocType: Healthcare Settings,Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,Računi primanja po defaultu koji će se koristiti ako nisu postavljeni u zdravstvenom radniku za knjiženje naknada za imenovanje.
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Student Group is already updated.,Studentska grupa je već ažurirana.
DocType: Driver,Fleet Manager,Fleet Manager
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,You are not authorized to approve leaves on Block Dates,Niste ovlašćeni da odobravate ostavljanje na datumu bloka
,Purchase Invoice Trends,Trendovi kupnje fakture
DocType: Purchase Taxes and Charges,On Previous Row Amount,Na prethodnom redu iznos
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 tekuću fiskalnu godinu.
DocType: Travel Itinerary,Taxi,Taxi
DocType: Contract,Inactive,Neaktivan
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Actual qty in stock,Stvarna količina na lageru
DocType: Student Sibling,Student Sibling,Student Sibling
apps/erpnext/erpnext/utilities/user_progress.py,Go to Rooms,Idi u sobe
apps/erpnext/erpnext/utilities/activation.py,Create Employee Records,Napravite evidenciju zaposlenika
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 kupovinu, ali nije primljena."
DocType: Patient,Patient ID,ID pacijenta
DocType: Employee,Permanent Address Is,Permanent Address is
DocType: Hotel Room Reservation,Guest Name,Ime gosta
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Accumulated Values in Group Company,Akumulirane vrijednosti u Grupi
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Resume,Nastavi
,BOM Stock Calculated,BOM Stock Calculated
DocType: Employee Transfer,New Employee ID,Novi ID zaposlenika
apps/erpnext/erpnext/config/accounting.py,Tax template for selling transactions.,Šablon poreza za transakcije prodaje.
DocType: Currency Exchange,To Currency,To Currency
DocType: Course Schedule,Instructor Name,Ime instruktora
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Research,Istraživanje
DocType: Additional Salary,Employee Name,ime zaposlenika
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance can not be marked for future dates,Prisustvo ne može biti označeno za buduće datume
DocType: Supplier Scorecard Scoring Standing,Min Grade,Min Grade
DocType: Work Order,Manufactured Qty,Proizvedeni kom
DocType: Patient,Alcohol Current Use,Trenutna upotreba alkohola
DocType: Leave Application,Total Leave Days,Ukupno dana odmora
DocType: Asset Repair,Repair Status,Status popravke
DocType: Territory,Territory Manager,Upravnik teritorija
DocType: Lab Test,Sample ID,Sample ID
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html,Cart is Empty,Košarica je prazna
apps/erpnext/erpnext/hr/doctype/shift_type/shift_type.js,Attendance has been marked as per employee check-ins,Pohađanje je označeno po prijavama za zaposlene
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset {0} must be submitted,Imovina {0} mora biti poslata
,Absent Student Report,Odsutni studentski izvještaj
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Included in Gross Profit,Uključeno u bruto profit
apps/erpnext/erpnext/accounts/page/pos/pos.js,Price List not found or disabled,Cenovnik nije pronađen ili onemogućen
DocType: Travel Request Costing,Funded Amount,Finansirani 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 poslata tako da se akcija ne može dovršiti
DocType: Subscription,Trial Period End Date,Datum završetka probnog perioda
DocType: Shift Type,Alternating entries as IN and OUT during the same shift,Naizmjenični unosi kao IN i OUT tijekom iste smjene
DocType: BOM Update Tool,The new BOM after replacement,Nova BOM nakon zamjene
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dobavljač&gt; Tip dobavljača
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 5,Tačka 5
DocType: Employee,Passport Number,Broj pasoša
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Opening,Privremeno otvaranje
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Pricing Rules are further filtered based on quantity.,Pravila određivanja cijena se dalje filtriraju na osnovu količine.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Appraisal {0} created for Employee {1} in the given date range,Procjena {0} kreirana za zaposlenika {1} u danom rasponu datuma
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Variance,Varijanca
DocType: Sales Order,Partly Delivered,Delimično isporučeno
DocType: Item,Maintain Stock,Maintain Stock
DocType: Job Card,Started Time,Started Time
apps/erpnext/erpnext/config/hr.py,Shifts and Fleet Management,Smene i upravljanje voznim parkom
DocType: Item,Average time taken by the supplier to deliver,Prosječno vrijeme koje dobavljač treba da isporuči
DocType: Stock Entry,Per Transferred,Per Transferred
DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),Označava da je paket dio ove isporuke (samo skica)
DocType: Upload Attendance,Get Template,Get Template
DocType: Agriculture Task,Next Business Day,Sljedeći radni dan
DocType: Payment Reconciliation,Receivable / Payable Account,Račun potraživanja / dugovanja
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 zadužiti isti račun
DocType: Agriculture Analysis Criteria,Weather,Vreme
,Welcome to ERPNext,Dobrodošli u ERPNext
DocType: Payment Reconciliation,Maximum Invoice Amount,Maksimalni iznos fakture
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Expense Claim for Vehicle Log {0},Zahtev za rashodom za dnevnik vozila {0}
DocType: Healthcare Settings,Patient Encounters in valid days,Susreti pacijenata u važećim danima
,Student Fee Collection,Zbirka studentskih naknada
DocType: Selling Settings,Sales Order Required,Obavezni prodajni nalog
DocType: Stock Entry Detail,Serial No / Batch,Serijski broj / serija
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Statement of Account,Stanje racuna
DocType: Job Offer Term,Offer Term,Termin ponude
apps/erpnext/erpnext/setup/doctype/company/company.py,Account {0} does not belong to company: {1},Račun {0} ne pripada tvrtki: {1}
DocType: Tally Migration,Tally Migration,Tally Migration
DocType: Item,"Purchase, Replenishment Details","Kupovina, Pojedinosti o dopuni"
DocType: Purchase Invoice,"Once set, this invoice will be on hold till the set date","Jednom postavljena, ova faktura će biti na čekanju do određenog datuma"
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 za stavku {0} jer ima varijante
DocType: Lab Test Template,Grouped,Grupisano
DocType: GSTR 3B Report,January,Januar
DocType: Course Assessment Criteria,Course Assessment Criteria,Kriteriji za ocjenjivanje kursa
DocType: Certification Application,INR,INR
DocType: Job Card Time Log,Completed Qty,Completed Qty
DocType: Agriculture Task,Start Day,Start Day
apps/erpnext/erpnext/config/integrations.py,GoCardless payment gateway settings,GoCardless postavke šifre plaćanja
DocType: Asset Category Account,Depreciation Expense Account,Račun troškova amortizacije
DocType: Production Plan Sales Order,Production Plan Sales Order,Proizvodni plan prodajnog naloga
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 biti različita
apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js,View Lab Tests,Pogledajte laboratorijske testove
DocType: Article,Instructor,Instruktor
DocType: Shopping Cart Settings,Show Public Attachments,Prikaži javne priloge
DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Polja će se kopirati samo u vreme stvaranja.
DocType: Delivery Note,Vehicle No,Vozilo br
DocType: Lead,CRM-LEAD-.YYYY.-,CRM-LEAD-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry is already created,Unos za plaćanje je već kreiran
apps/erpnext/erpnext/stock/doctype/item/item.js,Multiple Variants,Višestruke varijante
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please select a csv file,Odaberite csv datoteku
DocType: Serial No,Serial No Details,Serial No Details
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Source and Target Location cannot be same,Lokacija izvora i cilj ne može biti ista
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Show Employee,Show Employee
DocType: Payment Entry,Writeoff,Otpisati
DocType: Issue,ISS-.YYYY.-,ISS-.YYYY.-
DocType: Payment Order,Payment Request,Zahtev za plaćanje
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Selected Price List should have buying and selling fields checked.,Izabrani cjenik treba da ima označena polja kupovine i prodaje.
apps/erpnext/erpnext/accounts/doctype/account/account.py,Cannot covert to Group because Account Type is selected.,Nije moguće preći u grupu jer je izabran tip naloga.
DocType: Company,Exchange Gain / Loss Account,Račun dobiti i gubitka
DocType: Project Template,Project Template,Predložak projekta
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Reorder Qty,Reorder Qty
apps/erpnext/erpnext/accounts/report/financial_statements.html,Too many columns. Export the report and print it using a spreadsheet application.,Previše kolona. Izvezite izveštaj i odštampajte ga pomoću aplikacije za tabelarne proračune.
DocType: Payroll Entry,Salary Slips Submitted,Plate Slips Submitted
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,For Supplier,Za dobavljača
apps/erpnext/erpnext/accounts/party.py,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Računovodstveni unosi su već izvršeni u valuti {0} za preduzeće {1}. Molimo izaberite račun za potraživanje ili plaćanje sa valutom {0}.
DocType: Asset Value Adjustment,New Asset Value,Nova vrijednost imovine
DocType: Volunteer,Volunteer Type,Volunteer Type
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Printed On,Printed On
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js,Grant Leaves,Grant Leaves
DocType: Vehicle,Vehicle Value,Vehicle Value
,Project Billing Summary,Sažetak obračuna projekta
DocType: Asset,Receipt,Receipt
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule' to get schedule,Kliknite na &#39;Generiraj raspored&#39; da biste dobili raspored
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,TDS Rate %,TDS stopa%
DocType: Training Event,Contact Number,Kontakt broj
DocType: POS Closing Voucher,POS Closing Voucher,POS Zatvaranje vaučera
DocType: Quality Inspection Template,Quality Inspection Template Name,Naziv predloška za provjeru kvalitete
apps/erpnext/erpnext/public/js/hub/marketplace.js,Added {0} users,Dodato je {0} korisnika
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to Non-Group,Pretvori u ne-grupu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Set as Lost,Postavite kao Izgubljeno
DocType: Journal Entry Account,Payroll Entry,Payroll Entry
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 zapis razmjene valuta nije kreiran za {1} do {2}.
DocType: Delivery Note,Transporter Name,Ime transportera
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.","Planirana količina: Količina, za koju je radni nalog podignut, ali čeka na proizvodnju."
DocType: Item,Has Variants,Has Varijante
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Securities & Commodity Exchanges,Vrijednosni papiri i robne razmjene
DocType: Purchase Invoice Item,Deferred Expense,Deferred Expense
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py,Salary Slip ID,ID plaće
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Membership ID,ID članstva
,Sales Register,Sales Register
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Please specify a valid 'From Case No.',Molimo Vas da navedete važeću &#39;From Case No.&#39;
DocType: Customer,Primary Address and Contact Detail,Osnovna adresa i detalji kontakta
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,This is based on transactions against this Customer. See timeline below for details,Ovo se zasniva na transakcijama protiv ovog klijenta. Za detalje pogledajte vremensku liniju ispod
DocType: Hotel Room,Hotels,Hoteli
DocType: Shipping Rule,Valid for Countries,Vrijedi za zemlje
,Territory Target Variance Based On Item Group,Teritorijalna varijacija na osnovu grupe proizvoda
DocType: Rename Tool,Rename Tool,Preimenuj alat
DocType: Loan Application,Total Payable Amount,Ukupan iznos koji se plaća
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Dodaj sve dobavljače
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} treba da bude jednaka odabranoj valuti {2}
DocType: Pricing Rule,Product,Proizvod
apps/erpnext/erpnext/controllers/item_variant.py,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},Vrijednost {0} za atribut {1} ne postoji u popisu važećih vrijednosti atributa stavke za stavku {2}
apps/erpnext/erpnext/utilities/bot.py,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} jedinica [{1}] (# Form / Item / {1}) pronađenih u [{2}] (# Form / Warehouse / {2})
DocType: Vital Signs,Weight (In Kilogram),Težina (u kilogramima)
DocType: Department,Leave Approver,Leave Approver
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Transakcije
DocType: Issue,Resolution Details,Detalji rezolucije
DocType: Sales Invoice Item,Delivery Note Item,Stavka dostavnice
DocType: QuickBooks Migrator,Connected to QuickBooks,Povezan na QuickBooks
DocType: Item,Shelf Life In Days,Rok trajanja u danima
apps/erpnext/erpnext/config/buying.py,Key Reports,Ključni izvještaji
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Possible Supplier,Mogući dobavljač
,Issued Items Against Work Order,Izdate stavke protiv radnog naloga
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Creating {0} Invoice,Kreiranje {0} fakture
apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Molimo vas da podesite Sistem za imenovanje instruktora u obrazovanju&gt; Postavke obrazovanja
DocType: Student,Joining Date,Datum pridruživanja
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requesting Site,Requesting Site
DocType: Purchase Invoice,Against Expense Account,Protiv računa troškova
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Cannot create a Delivery Trip from Draft documents.,Nije moguće kreirati put isporuke iz nacrta dokumenata.
apps/erpnext/erpnext/config/crm.py,Lead to Quotation,Vodite na ponudu
DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,Označite ovo ako učenik živi u hostelu Instituta.
apps/erpnext/erpnext/education/utils.py,Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} pojavljuje se više puta u redu {2} &amp; {3}
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Creating Payment Entries......,Kreiranje unosa za plaćanje ......
DocType: Production Plan,Total Planned Qty,Ukupna planirana količina
DocType: Subscription Plan,Cost,Cost
DocType: Healthcare Service Unit Type,Healthcare Service Unit Type,Vrsta jedinice zdravstvene službe
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,Please enter atleast 1 invoice in the table,Molimo vas da u tabeli unesete najmanje 1 fakturu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Sales Order {0} is not submitted,Prodajni nalog {0} nije dostavljen
apps/erpnext/erpnext/education/api.py,Attendance has been marked successfully.,Prisustvo je uspešno obeleženo.
apps/erpnext/erpnext/accounts/doctype/tax_category/tax_category_dashboard.py,Pre Sales,Pre Sales
apps/erpnext/erpnext/config/projects.py,Project master.,Master projekta.
DocType: Daily Work Summary,Daily Work Summary,Dnevni pregled rada
DocType: Asset,Partially Depreciated,Delimično amortizovana
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,'Days Since Last Order' must be greater than or equal to zero,&#39;Dani od zadnjeg reda&#39; moraju biti veći ili jednaki nuli
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,For Default Supplier (optional),Za podrazumevanog dobavljača (opcionalno)
DocType: Employee,Leave Encashed?,Leave Encashed?
DocType: Certified Consultant,Discuss ID,Discuss ID
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Please set GST Accounts in GST Settings,Postavite GST račune u GST postavkama
DocType: Quiz,Latest Highest Score,Latest Highest Score
DocType: Supplier,Billing Currency,Valuta naplate
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Student Activity,Studentska aktivnost
apps/erpnext/erpnext/setup/doctype/territory/territory.py,Either target qty or target amount is mandatory,Ciljna količina ili ciljni iznos je obavezan
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žite preglednik kako bi promjena stupila na snagu.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Address 2,From Address 2
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Of the supplies shown in 3.1 (a) above, details of inter-State supplies made to unregisterd
	persons, composition taxable persons and UIN holders","Od isporuka navedenih u 3.1 (a) gore, detalji o međudržavnim zalihama za neregistrovane osobe, poreske obveznike i nosioce UIN-a"
DocType: Company,Default Inventory Account,Default Inventory Account
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Datum završetka godine ne može biti ranije od datuma početka godine. Ispravite datume i pokušajte ponovo.
DocType: Target Detail,Target  Amount,Ciljni iznos
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Hotel Rooms of type {0} are unavailable on {1},Hotelske sobe tipa {0} nisu dostupne na {1}
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,New Customer Revenue,Novi prihod od kupaca
DocType: Landed Cost Item,Applicable Charges,Primjenjive naknade
,Point of Sale,Mjestu prodaje
DocType: Authorization Rule,Approving User  (above authorized value),Odobravanje korisnika (iznad ovlaštene vrijednosti)
DocType: Service Level Agreement,Entity,Entitet
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/accounts/doctype/sales_invoice/sales_invoice.py,Customer {0} does not belong to project {1},Korisnik {0} ne pripada projektu {1}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Party Name,Od imena stranke
DocType: Asset Maintenance Log,Maintenance Status,Status održavanja
DocType: Production Plan Item,Pending Qty,Pending Qty
apps/erpnext/erpnext/controllers/accounts_controller.py, or ,ili
DocType: Sales Order,Not Delivered,Not Delivered
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leave Type {0} cannot be allocated since it is leave without pay,Tip ostavljanja {0} ne može biti dodijeljen jer je to dopust bez plaćanja
DocType: GL Entry,Debit Amount,Debitni iznos
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Already record exists for the item {0},Već postoji zapis za stavku {0}
DocType: Video,Vimeo,Vimeo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Sub Assemblies,Sub Assemblies
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 preovlađuju višestruka pravila za određivanje cijena, od korisnika se traži da ručno podesi prioritet da bi riješio sukob."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Ne može se odbiti kada je kategorija za &#39;Vrednovanje&#39; ili &#39;Vrednovanje i Ukupno&#39;
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,BOM and Manufacturing Quantity are required,Potrebna je sastavnica i količina proizvodnje
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} has reached its end of life on {1},Stavka {0} je završila svoj život na {1}
DocType: Quality Inspection Reading,Reading 6,Čitanje 6
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Company field is required,Polje kompanije je obavezno
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 proizvodnje.
DocType: Assessment Group,Assessment Group Name,Naziv grupe za procjenu
DocType: Purchase Invoice Item,Manufacturer Part Number,Broj dijela proizvođača
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Payroll Payable,Payroll Payable
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 negativan za stavku {2}
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Balance Qty,Balance Qty
DocType: Question,Multiple Correct Answer,Višestruki ispravan odgovor
DocType: Loyalty Program,1 Loyalty Points = How much base currency?,1 Bodovi lojalnosti = Kolika je osnovna valuta?
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Napomena: Nema dovoljno preostalog balansa za vrstu ostavljanja {0}
DocType: Clinical Procedure,Inpatient Record,Inpatient Record
DocType: Sales Invoice Item,Customer's Item Code,Kôd artikla kupca
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Item Code,Promijenite šifru artikla
DocType: Student Group Instructor,Student Group Instructor,Instruktor grupe studenata
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Transaction Type,Vrsta transakcije
apps/erpnext/erpnext/regional/india/utils.py,House rented dates should be atleast 15 days apart,Datumi iznajmljivanja kuća trebali bi biti najmanje 15 dana
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,View Form,View Form
apps/erpnext/erpnext/stock/doctype/item/item.py,Valuation Rate is mandatory if Opening Stock entered,Stopa vrednovanja je obavezna ako je otvorena ulazna zaliha
DocType: Employee,Exit Interview Details,Detalji iz intervjua
DocType: Sales Invoice,Accounting Details,Računovodstveni detalji
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Raspored održavanja {0} mora biti poništen prije otkazivanja ovog prodajnog naloga
DocType: Driver,HR-DRI-.YYYY.-,HR-DRI-.YYYY.-
DocType: Customer,Mention if non-standard receivable account,Navedite ako je račun nestandardnog potraživanja
DocType: Lab Test,Prescription,Prescription
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Closed,Set as Closed
DocType: Asset,Opening Accumulated Depreciation,Otvaranje akumulirane amortizacije
DocType: Soil Texture,Sand Composition (%),Sastav pijeska (%)
DocType: Production Plan,MFG-PP-.YYYY.-,MFG-PP-.YYYY.-
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Day Book Data,Uvoz podataka o knjizi
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Podesite Naming Series za {0} preko Setup&gt; Settings&gt; Naming Series
DocType: Asset,Asset Owner Company,Društvo vlasnika imovine
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Cost center is required to book an expense claim,Mjesto troška je potrebno za knjiženje troškova potraživanja
apps/erpnext/erpnext/stock/utils.py,{0} valid serial nos for Item {1},{0} važeći serijski broj za stavku {1}
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Cannot promote Employee with status Left,Nije moguće promovirati zaposlenika sa statusom lijevo
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expiry (In Days),Istek (u danima)
DocType: Supplier Scorecard Standing,Notify Other,Notify Other
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Please select Company,Molimo odaberite Društvo
,Item-wise Purchase Register,Registar nabavke po stavkama
DocType: Employee,Reason For Leaving,Razlog za napuštanje
DocType: Salary Slip,Earning & Deduction,Zarada i odbijanje
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Employee Referral,Referral zaposlenika
,Qty to Order,Kol
apps/erpnext/erpnext/config/buying.py,Request for purchase.,Zahtjev za kupovinu.
DocType: Bin,Moving Average Rate,Moving Average Rate
apps/erpnext/erpnext/config/buying.py,Tax template for buying transactions.,Šablon poreza za transakcije kupovine.
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Send SMS,Pošalji SMS
apps/erpnext/erpnext/erpnext_integrations/utils.py,Unverified Webhook Data,Unverified Webhook Data
apps/erpnext/erpnext/config/help.py,Human Resource,Ljudski resursi
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} has been modified. Please refresh.,{0} {1} je izmijenjeno. Please refresh.
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},Saldo zaliha u seriji {0} će postati negativan {1} za stavku {2} na skladištu {3}
,Asset Depreciation Ledger,Knjiga amortizacije imovine
DocType: Location,Tree Details,Detalji stabla
DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Napravite nedostajućeg kupca ili dobavljača.
DocType: Vital Signs,Blood Pressure (diastolic),Krvni pritisak (dijastolički)
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: Item,Show in Website (Variant),Prikaži na web-lokaciji (varijanta)
apps/erpnext/erpnext/education/doctype/fees/fees.js,Please set the Email ID for the Student to send the Payment Request,Molimo vas da postavite ID e-pošte kako bi učenik mogao poslati zahtjev za plaćanje
DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Stvorite pakirne listiće za pakete koji se isporučuju. Koristi se za prijavljivanje broja paketa, sadržaja paketa i njegove težine."
DocType: SMS Log,No of Requested SMS,Broj traženog SMS-a
apps/erpnext/erpnext/config/accounting.py,Banking and Payments,Bankarstvo i plaćanja
DocType: Instructor,Instructor Log,Instructor Log
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 zaposlenog {0} premašuje {1} za iznos {2} naknade za pro-rata komponentu i prethodni traženi iznos
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Please enter valid email address,Unesite važeću adresu e-pošte
apps/erpnext/erpnext/config/retail.py,Retail Operations,Maloprodajne operacije
DocType: Company,Phone No,Telefon br
,Reqd By Date,Reqd By Date
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Uncheck all,Poništite sve
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Place,To Place
DocType: Manufacturing Settings,Default Work In Progress Warehouse,Određen forumom Work In Progress Warehouse
DocType: Fees,Include Payment,Uključi plaćanje
DocType: Crop,Byproducts,Byproducts
DocType: Assessment Result,Student,Student
apps/erpnext/erpnext/config/crm.py,Manage Customer Group Tree.,Upravljanje stablom grupe korisnika.
DocType: Payment Entry,Payment From / To,Plaćanje od / do
apps/erpnext/erpnext/stock/utils.py,Serial number {0} entered more than once,Serijski broj {0} unesen je više puta
DocType: Website Item Group,Website Item Group,Group Item Group
DocType: Amazon MWS Settings,CA,CA
DocType: Serial No,Under Warranty,Pod garancijom
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,Invoice Posting Date,Datum knjiženja fakture
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Delivery Note,Napomena o isporuci
DocType: Education Settings,Attendance Freeze Date,Datum zamrzavanja prisutnosti
DocType: Warranty Claim,Item and Warranty Details,Detalji o stavci i garanciji
DocType: Job Card,Time Logs,Dnevnici vremena
DocType: Hotel Room,Extra Bed Capacity,Kapacitet dodatnog ležaja
DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,Neto isplata (riječima) će biti vidljiva nakon što spremite ispis plata.
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 vaganja. Proverite da li je formula validna.
DocType: Asset,Asset Owner,Vlasnik imovine
apps/erpnext/erpnext/buying/utils.py,Warehouse is mandatory for stock Item {0} in row {1},Skladište je obavezno za zalihu Stavka {0} u redu {1}
DocType: Stock Entry,Total Additional Costs,Ukupni dodatni troškovi
apps/erpnext/erpnext/regional/italy/utils.py,Please set at least one row in the Taxes and Charges Table,Postavite najmanje jedan red u tabeli Porezi i naknade
DocType: Asset Maintenance Team,Maintenance Team Name,Ime tima za održavanje
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Chart of Cost Centers,Grafikon centara troškova
apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Idi na korisnike
DocType: Pricing Rule,Item Code,Šifra artikla
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,'Opening',&#39;Otvaranje&#39;
DocType: Payment Entry,Set Exchange Gain / Loss,Postavite Exchange Gain / Loss
DocType: Accounts Settings,Make Payment via Journal Entry,Napravite plaćanje putem unosa dnevnika
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,User has not applied rule on the invoice {0},Korisnik nije primijenio pravilo na fakturi {0}
apps/erpnext/erpnext/config/accounting.py,Payment Terms based on conditions,Uvjeti plaćanja na temelju uvjeta
DocType: Purchase Order,% Received,% Primljeno
DocType: Sales Order Item,Work Order Qty,Količina radnih naloga
DocType: Job Card,WIP Warehouse,WIP skladište
DocType: Payment Request,ACC-PRQ-.YYYY.-,ACC-PRQ-.YYYY.-
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,User ID not set for Employee {0},ID korisnika nije postavljen za zaposlenika {0}
apps/erpnext/erpnext/education/doctype/guardian/guardian.py,User {0} created,Korisnik {0} je kreiran
DocType: Stock Settings,Item Naming By,Item Naming By
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js,Ordered,Naručeno
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js,This is a root customer group and cannot be edited.,Ovo je glavna korisnička grupa i ne može se uređivati.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Material Request {0} is cancelled or stopped,Zahtjev za materijal {0} je otkazan ili zaustavljen
DocType: Shift Type,Strictly based on Log Type in Employee Checkin,Strogo se zasniva na Log Type u Checking zaposlenika
DocType: Purchase Order Item Supplied,Supplied Qty,Priložena količina
DocType: Cash Flow Mapper,Cash Flow Mapper,Kartiranje novčanog toka
DocType: Soil Texture,Sand,Sand
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Employee cannot report to himself.,Zaposleni se ne može prijaviti sebi.
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_log/shopify_log.js,Order rescheduled for sync,Narudžba je reprogramirana za sinhronizaciju
apps/erpnext/erpnext/stock/doctype/item/item.py,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Zadana jedinica mjere za varijantu &#39;{0}&#39; mora biti ista kao u predlošku &#39;{1}&#39;
DocType: Blanket Order,Purchasing,Purchasing
DocType: Driver,Cellphone Number,Broj mobitela
DocType: Salary Slip,Gross Pay,Gross Pay
DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Hotelski paket cena
DocType: Pricing Rule,Is Cumulative,Is Cumulative
apps/erpnext/erpnext/templates/pages/cart.html,Your cart is Empty,Vaša košarica je prazna
,Daily Timesheet Summary,Daily Timesheet Summary
apps/erpnext/erpnext/quality_management/doctype/quality_procedure/quality_procedure_tree.js,New Quality Procedure,Nova procedura kvaliteta
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Podugovaranje
DocType: Fee Schedule Program,Total Students,Ukupno studenata
apps/erpnext/erpnext/utilities/user_progress_utils.py,Local,Lokalno
DocType: Chapter Member,Leave Reason,Ostavi razlog
DocType: Salary Component,Condition and Formula,Stanje i formula
DocType: Quality Goal,Objectives,Ciljevi
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.","Plata koja je već obrađena za period između {0} i {1}, razdoblje napuštanja aplikacije ne može biti između ovog raspona datuma."
DocType: BOM Item,Basic Rate (Company Currency),Osnovna stopa (valuta kompanije)
DocType: BOM Scrap Item,BOM Scrap Item,BOM Scrap Item
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Serial #,Serial # \ t
DocType: Activity Type,Default Billing Rate,Default Billing Rate
DocType: Vital Signs,Coated,Premazan
DocType: Patient Appointment,More Info,Više informacija
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Bill of Materials,Bill of Materials
DocType: Purchase Invoice,Inter Company Invoice Reference,Referenca fakture Inter kompanije
DocType: Crop Cycle,Cycle Type,Tip ciklusa
DocType: Employee Separation,Exit Interview Summary,Exit Interview Summary
,Item Variant Details,Item Variant Details
DocType: Contract,Partially Fulfilled,Djelomično ispunjeno
DocType: Journal Entry,ACC-JV-.YYYY.-,ACC-JV-.YYYY.-
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,To {0},Do {0}
DocType: GST Settings,GST Accounts,GST računi
DocType: C-Form,Total Invoiced Amount,Ukupni fakturisani iznos
DocType: Manufacturing Settings,Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order,Onemogućava kreiranje vremenskih dnevnika protiv radnog naloga. Operacije neće biti praćene radnim nalogom
apps/erpnext/erpnext/stock/utils.py,Group node warehouse is not allowed to select for transactions,Skladište čvora grupe nije dozvoljeno da bira transakcije
DocType: Subscriber,Subscriber Name,Subscriber Name
DocType: Purchase Order,Customer Mobile No,Broj mobilnog telefona br
DocType: Bank Guarantee,Receiving,Primanje
DocType: Account,Is Group,Is Group
DocType: Healthcare Practitioner,Contacts and Address,Kontakti i adresa
DocType: Warehouse,Warehouse Name,Naziv skladišta
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as it is a Holiday.,Pohađanje nije predato za {0} jer je to praznik.
DocType: Leave Type,Rounding,Zaokruživanje
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Ineligible ITC,Neprihvatljivi ITC
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,{0} created,{0} kreirano
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,Odaberite voditelja banke u kojoj je položen ček.
DocType: Service Level,Support and Resolution,Podrška i rezolucija
DocType: Account,Bank,Bank
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Receive at Warehouse Entry,Primite na ulazu u skladište
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Send Supplier Emails,Pošalji e-poštu dobavljača
DocType: Lab Test Groups,Add new line,Dodajte novu liniju
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate item group found in the item group table,Udvostručena grupa stavki pronađena u tablici grupe stavki
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Annual Salary,Godišnja plata
DocType: Supplier Scorecard,Weighting Function,Funkcija utega
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM konverzijski faktor ({0} -&gt; {1}) nije pronađen za stavku: {2}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py,Error evaluating the criteria formula,Pogreška pri ocjeni formule kriterija
,Lab Test Report,Lab Test Report
DocType: BOM,With Operations,Sa operacijama
apps/erpnext/erpnext/utilities/user_progress.py,People who teach at your organisation,Ljudi koji podučavaju u vašoj organizaciji
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} does not belongs to company {1},Račun {0} ne pripada tvrtki {1}
DocType: Item,Has Expiry Date,Ima datum isteka
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,Sum of Scores of Assessment Criteria needs to be {0}.,Zbir bodova kriterijuma procjene mora biti {0}.
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Property already added,Vlasništvo je već dodano
DocType: Supplier,SUP-.YYYY.-,SUP-.YYYY.-
DocType: Expense Claim Account,Expense Claim Account,Račun troškova potraživanja
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments available for Journal Entry,Nema otplate za unos dnevnika
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} je neaktivan student
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Napravite unos zaliha
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM recursion: {0} cannot be parent or child of {1},BUR rekurzija: {0} ne može biti roditelj ili dijete {1}
DocType: Employee Onboarding,Activities,Aktivnosti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Atleast one warehouse is mandatory,Najmanje jedno skladište je obavezno
,Customer Credit Balance,Kreditni saldo kupca
DocType: BOM,Operations,Operations
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Create Salary Slips,Napravite isplate plata
,Monthly Attendance Sheet,Mjesečni list
DocType: Vital Signs,Reflexes,Refleksi
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,"Service Item,Type,frequency and expense amount are required","Potrebna je stavka usluge, tip, učestalost i iznos troškova"
DocType: Supplier Scorecard Period,Variables,Varijable
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Multiple Loyalty Program found for the Customer. Please select manually.,Pronašli smo više programa lojalnosti za klijenta. Odaberite ručno.
DocType: Patient,Medication,Lijekovi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Select Loyalty Program,Izaberite Program lojalnosti
DocType: Employee Checkin,Attendance Marked,Obilježeno prisustvo
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Raw Materials,Sirovine
DocType: Sales Order,Fully Billed,Fully Billed
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Please set Hotel Room Rate on {},Molimo vas da postavite cijenu za hotelsku sobu na {}
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Select only one Priority as Default.,Izaberite samo jedan prioritet kao podrazumevani.
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please identify/create Account (Ledger) for type - {0},Molimo identifikujte / kreirajte račun (knjiga) za tip - {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Total Credit/ Debit Amount should be same as linked Journal Entry,Ukupni iznos kredita / zaduženja treba biti isti kao i unos u dnevnik
DocType: Purchase Invoice Item,Is Fixed Asset,Is Fixed Asset
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Party Name,Za ime stranke
apps/erpnext/erpnext/stock/doctype/item/item.js,This Item is a Variant of {0} (Template).,Ova stavka je varijanta {0} (Predložak).
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 vam pomaže da ažurirate ili popravite količinu i vrednovanje zaliha u sistemu. Obično se koristi za sinhronizaciju sistemskih vrijednosti i onoga što stvarno postoji u vašim skladištima.
DocType: Cashier Closing,Net Amount,Neto iznos
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Selling Price List,Cjenik prodaje
DocType: Amazon MWS Settings,IT,IT
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,{0} must be negative in return document,{0} mora biti negativan u povratnom dokumentu
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please select a valid Date,Odaberite važeći datum
DocType: Agriculture Task,End Day,Kraj dana
apps/erpnext/erpnext/templates/emails/training_event.html,Please confirm once you have completed your training,Potvrdite nakon što završite obuku
apps/erpnext/erpnext/utilities/user_progress.py,Go to Letterheads,Idite na slova
DocType: Leave Block List Allow,Allow User,Dopusti korisnika
DocType: Sales Order,% of materials delivered against this Sales Order,% materijala dostavljenih protiv ovog prodajnog naloga
DocType: Purpose of Travel,Purpose of Travel,Svrha putovanja
DocType: Healthcare Settings,Appointment Confirmation,Potvrda o sastanku
DocType: Shopping Cart Settings,Orders,Orders
DocType: HR Settings,Retirement Age,Dob umirovljenja
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Postavite nizove brojeva za Prisustvo putem Podešavanja&gt; Brojčane serije
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Projected Qty,Projected Qty
apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Brisanje nije dopušteno za zemlju {0}
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} is already {2},Red # {0}: Imovina {1} je već {2}
DocType: Delivery Note,Installation Status,Status instalacije
DocType: Item Attribute Value,Attribute Value,Vrijednost atributa
DocType: Sales Invoice,Base Change Amount (Company Currency),Iznos osnovne promene (valuta kompanije)
DocType: Leave Allocation,Unused leaves,Neiskorišteni listovi
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Finished Item {0} must be entered for Manufacture type entry,Završena stavka {0} mora biti unesena za unos tipa proizvodnje
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,'Entries' cannot be empty,&#39;Unosi&#39; ne mogu biti prazni
apps/erpnext/erpnext/utilities/user_progress.py,Go to Courses,Idi na Tečajeve
DocType: Fee Schedule,Fee Breakup for each student,Naknada za svakog učenika
DocType: Item,Will also apply for variants,Takođe će se prijaviti za varijante
DocType: Shopify Settings,Shared secret,Shared secret
DocType: POS Profile,Write Off Cost Center,Napiši centar troškova
DocType: Soil Texture,Silty Clay,Silty Clay
DocType: Loyalty Point Entry Redemption,Redeemed Points,Redeemed Points
DocType: GoCardless Mandate,Mandate,Mandat
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Multiple,Napravite više
DocType: Supplier Scorecard,Scoring Standings,Scoring Standings
DocType: Support Search Source,Result Title Field,Rezultat Naslov polje
DocType: Leave Allocation,New Leaves Allocated,New Leaves Allocated
DocType: Homepage,Homepage,Početna stranica
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Compensatory Off,Compensatory Off
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices Summary,Sažetak otvorenih faktura
DocType: Vehicle Service,Engine Oil,Motorno ulje
DocType: Job Applicant,Applicant Name,Ime aplikanta
DocType: Serial No,Delivery Document No,Dokument o isporuci br
DocType: Hub Users,Hub Users,Hub Users
DocType: Bin,Actual Quantity,Actual Quantity
DocType: Payment Term,Credit Days,Credit Days
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Id,Id projekta
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Electronics,Elektronika
apps/erpnext/erpnext/controllers/accounts_controller.py,Due Date is mandatory,Datum dospijeća je obavezan
DocType: BOM Explosion Item,Qty Consumed Per Unit,Potrošena količina po jedinici
,Completed Work Orders,Završeni radni nalozi
DocType: Loyalty Program,Help Section,Help Section
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance date can not be less than employee's joining date,Datum prisustvovanja ne može biti manji od datuma pridruživanja zaposlenog
DocType: BOM,Total Cost(Company Currency),Ukupni trošak (valuta kompanije)
DocType: Subscription,Net Total,Neto Ukupno
DocType: Procedure Prescription,Referral,Referral
DocType: Vehicle,Model,Model
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Please specify from/to range,Navedite od / do raspona
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Quantity to Manufacture must be greater than 0.,Količina za proizvodnju mora biti veća od 0.
DocType: Maintenance Visit,Maintenance Time,Vreme održavanja
DocType: Asset,Naming Series,Naming Series
DocType: Contract,Contract Terms,Uvjeti ugovora
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,Either target qty or target amount is mandatory.,Ciljna količina ili ciljni iznos je obavezan.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,Invalid {0},Nevažeće {0}
DocType: Item,FIFO,FIFO
DocType: Inpatient Record,HLC-INP-.YYYY.-,FHP-INP-.YYYY.- \ t
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation cannot have more than 5 characters,Skraćenica ne može imati više od 5 znakova
DocType: Employee Benefit Application,Max Benefits (Yearly),Maksimalne pogodnosti (godišnje)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Create Material Request,Kreirajte zahtev za materijal
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js,Primary Address Details,Detalji primarne adrese
DocType: Project Template Task,Duration (Days),Trajanje (Dani)
DocType: Customer Feedback Template Table,Customer Feedback Template Table,Tablica predložaka za povratne informacije korisnika
DocType: Purchase Invoice Item,Price List Rate,Price List Rate
DocType: Budget,Action if Annual Budget Exceeded on PO,Akcija ako je godišnji budžet premašen na PO
DocType: POS Profile,Campaign,Kampanja
DocType: POS Profile,Accounting,Računovodstvo
DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Postavite budžete za grupu predmeta na ovoj teritoriji. Takođe možete uključiti sezonalnost postavljanjem Distribucije.
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Insurance Start date should be less than Insurance End date,Datum početka osiguranja mora biti manji od datuma završetka osiguranja
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items in progress,{0} stavki u toku
DocType: Item,Foreign Trade Details,Detalji spoljne trgovine
DocType: Quality Review Table,Yes/No,Da ne
DocType: Tally Migration,Is Master Data Imported,Da li su uvezeni glavni podaci
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,Redak poreske stavke {0} mora imati račun tipa Porez ili Prihod ili Trošak ili Trošak
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} nije važeći serijski broj za stavku {1}
apps/erpnext/erpnext/utilities/user_progress.py,Learn More,Nauči više
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Credit Note {0} has been created automatically,Kreditna bilješka {0} je kreirana automatski
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 za zamjenu sastavnice. Može potrajati nekoliko minuta.
DocType: Lab Test,Result Date,Datum rezultata
apps/erpnext/erpnext/config/accounting.py,Currency exchange rate master.,Master deviznog kursa.
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js,Latest price updated in all BOMs,Najnovija cijena ažurirana u svim sastavnicama
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Series Updated Successfully,Serija je uspješno ažurirana
DocType: Soil Texture,Clay Loam,Clay Loam
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select item code,Odaberite kôd stavke
apps/erpnext/erpnext/accounts/page/pos/pos.js,Default warehouse is required for selected item,Podrazumevano skladište je potrebno za odabranu stavku
apps/erpnext/erpnext/stock/get_item_details.py,No Item with Serial No {0},Nema stavke sa serijskim brojem {0}
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,Party Type and Party is mandatory for {0} account,Tip stranke i stranka je obavezna za {0} račun
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Accountant,Računovođa
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/pos_closing_voucher.py,POS Closing Voucher alreday exists for {0} between date {1} and {2},Naknada za kupovinu POS-a postoji za {0} između datuma {1} i {2}
apps/erpnext/erpnext/config/help.py,Navigating,Navigacija
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,No outstanding invoices require exchange rate revaluation,Nijedna otvorena faktura ne zahtijeva revalorizaciju tečaja
DocType: Authorization Rule,Customer / Item Name,Naziv kupca / predmeta
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 imati skladište. Skladište mora biti postavljeno putem unosa zaliha ili kupovine
DocType: Issue,Via Customer Portal,Preko korisničkog portala
DocType: Work Order Operation,Planned Start Time,Planirano vrijeme početka
apps/erpnext/erpnext/controllers/buying_controller.py,{0} {1} is {2},{0} {1} je {2}
DocType: Service Level Priority,Service Level Priority,Prioritet nivoa usluge
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Broj knjiženih amortizacija ne može biti veći od ukupnog broja amortizacije
apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js,Share Ledger,Podijeli Ledger
DocType: Journal Entry,Accounts Payable,Dugovanja
DocType: Job Offer,Select Terms and Conditions,Odaberite Uvjete i odredbe
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Ends On date cannot be before Next Contact Date.,Završava na datum ne može biti prije sljedećeg datuma kontakta.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Goods are already received against the outward entry {0},Roba je već primljena u odnosu na ulazni ulaz {0}
DocType: Employee Tax Exemption Sub Category,Tax Exemption Category,Kategorija oslobođenja od poreza
DocType: Sales Invoice,Debit To,Debit To
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,"Selling must be checked, if Applicable For is selected as {0}","Prodaja se mora provjeriti, ako je Primjenjivo za odabrano kao {0}"
DocType: Company,Date of Establishment,Datum osnivanja
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Leave Type is madatory,Tip napuštanja je madatory
DocType: Sales Invoice,Sales Taxes and Charges Template,Šablon poreza i naknada za prodaju
DocType: Purchase Receipt,Return Against Purchase Receipt,Povratak protiv kupovine
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Student Group: ,Grupa učenika:
DocType: Cheque Print Template,Cheque Size,Proverite veličinu
,Consolidated Financial Statement,Konsolidovani finansijski izveštaji
DocType: Cheque Print Template,Scanned Cheque,Scanned Check
DocType: Restaurant Reservation,Reservation End Time,Vrijeme završetka rezervacije
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,In Value,U vrijednosti
DocType: Job Opening,Staffing Plan,Plan osoblja
DocType: Manufacturing Settings,Material Transferred for Manufacture,Preneseni materijal za proizvodnju
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for manufacturing,Rezervirano za proizvodnju
DocType: QuickBooks Migrator,Undeposited Funds Account,Račun nedodijeljenih sredstava
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Material Request No,Zahtjev za materijal br
DocType: Payment Reconciliation,Unreconciled Payment Details,Neusaglašeni detalji plaćanja
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ-ovi nisu dozvoljeni za {0} zbog stanja rezultata {1}
DocType: Bank Guarantee,Validity in Days,Valjanost u danima
DocType: Price List,Applicable for Countries,Primjenjivo za zemlje
DocType: Supplier,Individual,Individualno
DocType: Clinical Procedure Template,Clinical Procedure Template,Obrazac kliničkog postupka
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Net Asset value as on,Neto vrijednost imovine kao i na
DocType: Sales Invoice,Redemption Account,Redemption Account
apps/erpnext/erpnext/config/buying.py,Tree of Item Groups.,Drvo grupa artikala.
DocType: BOM,Show Items,Prikaži stavke
DocType: Journal Entry,Paid Loan,Plaćeni kredit
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Do you really want to scrap this asset?,Da li stvarno želite da napišete ovu imovinu?
DocType: Production Plan Sales Order,Sales Order Date,Datum prodajnog naloga
DocType: Workstation,Operating Costs,Operativni troškovi
DocType: Supplier Quotation Item,Lead Time in days,Vreme vođenja u danima
DocType: Loan,Repay from Salary,Otplati iz Plata
DocType: Discounted Invoice,Discounted Invoice,Diskontovana faktura
DocType: Leave Block List Allow,Leave Block List Allow,Ostavi blok listu
DocType: Serial No,AMC Expiry Date,Datum isteka AMC-a
DocType: Asset,Number of Depreciations Booked,Broj knjiženih amortizacija
DocType: Student Group Creation Tool,Student Group Creation Tool,Alat za kreiranje učeničkih grupa
,Purchase Order Items To Be Billed,Stavke narudžbenice za naplatu
DocType: Leave Period,Holiday List for Optional Leave,Lista praznika za opcionalni odmor
apps/erpnext/erpnext/config/accounting.py,Default settings for accounting transactions.,Podrazumevane postavke za računovodstvene transakcije.
DocType: Purchase Invoice,Scan Barcode,Scan Barcode
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Update Cost Center Number,Ažurirajte broj centra troškova
DocType: Purchase Invoice Item,Service Start Date,Datum početka usluge
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Furnitures and Fixtures,Nameštaj i pribor
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Criteria weights must add up to 100%,Utezi kriterijuma moraju biti 100%
DocType: Authorization Rule,Average Discount,Average Discount
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/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Accumulated Depreciation as on,Akumulirana amortizacija kao na
DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Varijabla za ocenjivanje dobavljača dobavljača
DocType: Cheque Print Template,Message to show,Poruka za prikaz
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,No Students in,Nema studenata u
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Accounts,Privremeni računi
DocType: Invoice Discounting,Bank Charges,Naknade za banke
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods Transferred,Prenesena roba
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js,Primary Contact Details,Primary Contact Details
DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Ako se ne proveri, popis će se morati dodati svakom odjelu gdje ga treba primijeniti."
DocType: Item Group,Show this slideshow at the top of the page,Prikaži ovu prezentaciju na vrhu stranice
apps/erpnext/erpnext/support/doctype/issue/issue.py,{0} parameter is invalid,Parametar {0} je nevažeći
apps/erpnext/erpnext/templates/generators/bom.html,No description given,Opis nije dat
DocType: Accounting Period,Closed Documents,Zatvoreni dokumenti
DocType: Project,Gross Margin,Bruto marža
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation Account,Račun revalorizacije deviznog tečaja
DocType: Quotation,Quotation To,Quotation To
DocType: Bank Statement Settings Item,Bank Statement Settings Item,Stavka za postavke bankovnog izvoda
DocType: Naming Series,Setup Series,Setup Series
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js,Reload Linked Analysis,Reload Linked Analysis
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Količina mora biti manja ili jednaka {0}
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Out Qty,Out Qty
DocType: Payment Request,Outward,Outward
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Sales Orders in the above table,Molimo vas da unesete prodajne narudžbe u gornju tabelu
DocType: Invoice Discounting,Bank Charges Account,Račun bankovnih naknada
DocType: Journal Entry,Get Outstanding Invoices,Get Outstanding Invoices
DocType: Opportunity,Opportunity From,Opportunity From
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Target Details,Detalji o meti
DocType: Item,Customer Code,Customer Code
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Please enter Item first,Molimo prvo unesite stavku
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Website Listing,Website Listing
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! Unos koji ste uneli ne odgovara formatu GSTIN-a.
DocType: Item Reorder,Re-order Qty,Količina re-reda
DocType: Asset,Maintenance Required,Potrebno održavanje
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Name,Naziv dokumenta
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Lead Owner cannot be same as the Lead,Vodeći vlasnik ne može biti isti kao i vođa
apps/erpnext/erpnext/config/accounting.py,"e.g. Bank, Cash, Credit Card","npr. banka, gotovina, kreditna kartica"
DocType: Item,Serial Number Series,Serijska serija
apps/erpnext/erpnext/config/accounting.py,Bank Statement Transaction Entry List,Lista unosa transakcije za bankovni račun
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/setup/setup_wizard/operations/install_fixtures.py,Management,Management
apps/erpnext/erpnext/config/retail.py,To view logs of Loyalty Points assigned to a Customer.,Za pregled logova bodova lojalnosti dodijeljenih klijentu.
DocType: Item,If subcontracted to a vendor,Ako se podugovara prodavcu
apps/erpnext/erpnext/templates/pages/help.html,Visit the forums,Posjetite forume
DocType: C-Form,C-Form,C-Form
DocType: Asset Maintenance,Maintenance Team,Maintenance Team
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Half day Leave on {1},{0} na pola dana odlaska na {1}
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,Combined invoice portion must equal 100%,Dio kombinirane fakture mora biti jednak 100%
DocType: Patient,Occupational Hazards and Environmental Factors,Profesionalne opasnosti i faktori okoline
DocType: Volunteer,Volunteer,Volonter
DocType: Lab Test,Custom Result,Custom Result
DocType: Issue,Opening Date,Datum otvaranja
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
DocType: Delivery Note,Delivery To,Dostava Za
DocType: Bank Statement Transaction Settings Item,Bank Data,Bank Data
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js,Scheduled Upto,Scheduled Upto
apps/erpnext/erpnext/config/crm.py,Track Leads by Lead Source.,Vodeći tragovi vodećeg izvora.
DocType: Clinical Procedure,Nursing User,Nursing User
DocType: Support Settings,Response Key List,Lista ključnih odgovora
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Based On,Aging Based On
apps/erpnext/erpnext/stock/doctype/item/item.js,Balance,Balans
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,Skladište u kojem se čuva zaliha odbijenih stavki
apps/erpnext/erpnext/public/js/setup_wizard.js,Retail,Maloprodaja
,Maintenance Schedules,Rasporedi održavanja
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cannot convert Cost Center to ledger as it has child nodes,Nije moguće pretvoriti Centar troška u knjigu jer ima dječje čvorove
apps/erpnext/erpnext/controllers/item_variant.py,Please specify at least one attribute in the Attributes table,Navedite najmanje jedan atribut u tablici Atributi
DocType: Company,Create Chart Of Accounts Based On,Kreirajte grafikon računa na osnovu
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Faktura prodaje {0} mora biti otkazana prije otkazivanja ovog prodajnog naloga
DocType: Item,Default Purchase Unit of Measure,Default Purchase Unit of Measure
DocType: Location,Location Details,Detalji o lokaciji
DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Osnovna stopa (po UOM za dionice)
DocType: Travel Request Costing,Travel Request Costing,Trošak zahtjeva za putovanje
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Sales Invoice,Kreirajte fakturu prodaje
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py,From Time cannot be greater than To Time.,Iz vremena ne može biti veće od vremena.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js,To Date cannot be less than From Date,Datum ne može biti manji od datuma
apps/erpnext/erpnext/config/crm.py,Manage Territory Tree.,Upravljanje stablom teritorije.
DocType: GL Entry,Voucher Type,Tip vaučera
,Serial No Service Contract Expiry,Serijski Bez ugovornog ugovora
DocType: Certification Application,Certified,Certified
DocType: Purchase Invoice Item,Manufacture,Proizvodnja
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items produced,Proizvedeno je {0} stavki
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Request for {0},Zahtjev za plaćanje za {0}
apps/erpnext/erpnext/accounts/report/inactive_sales_items/inactive_sales_items.js,Days Since Last Order,Dani od poslednjeg reda
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please set default Cash or Bank account in Mode of Payment {0},Molimo vas da postavite uobičajeni novčani ili bankovni račun u načinu plaćanja {0}
DocType: Student Group,Instructors,Instruktori
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Present,Mark Present
DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Za praktičnost korisnika, ovi kodovi se mogu koristiti u formatima za štampanje kao što su fakture i isporuke"
DocType: Amazon MWS Settings,Enable Amazon,Omogući Amazon
DocType: Loan,Total Interest Payable,Ukupna dospjela kamata
DocType: Topic,Topic Content,Sadržaj teme
DocType: Sales Invoice,Company Address Name,Ime i prezime kompanije
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods In Transit,Roba u tranzitu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,You can only redeem max {0} points in this order.,Maksimalno {0} bodova možete iskoristiti samo u ovom redoslijedu.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please set account in Warehouse {0},Postavite račun u skladištu {0}
DocType: Quality Action,Resolution,Rezolucija
DocType: Sales Invoice,Loyalty Points Redemption,Otkup bodova lojalnosti
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Total Taxable Value,Ukupna porezna vrijednost
DocType: Patient Appointment,Scheduled,Zakazano
DocType: Sales Partner,Partner Type,Tip partnera
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of services,Uvoz usluga
DocType: Employee Education,School/University,Škola / Univerzitet
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}: UOM Conversion Factor is mandatory,Red {0}: faktor konverzije UOM je obavezan
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Reference No.,Referentni broj
DocType: Work Order,Additional Operating Cost,Dodatni operativni troškovi
DocType: Loyalty Program Collection,Collection Factor (=1 LP),Faktor prikupljanja (= 1 LP)
DocType: Serial No,Delivery Document Type,Vrsta dokumenta isporuke
DocType: Products Settings,Attributes,Atributi
DocType: Bank Guarantee,Bank Guarantee,Bankarska garancija
DocType: Territory,Territory Name,Naziv teritorije
DocType: Item Price,Minimum Qty ,Minimum Qty
DocType: Supplier Scorecard,Per Week,Po tjednu
DocType: Supplier Scorecard,Warn for new Request for Quotations,Upozori za novi zahtjev za ponudu
DocType: Account,Tax,Porez
DocType: Delivery Stop,Visited,Posjetio
DocType: Loyalty Program,Auto Opt In (For all customers),Auto Opt In (za sve korisnike)
DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,Stopa po kojoj se valuta kupca pretvara u osnovnu valutu kupca
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is an Individual or a Proprietorship,Može se primeniti ako je kompanija individualna ili vlasništvo
DocType: Restaurant,Restaurant,Restoran
DocType: Delivery Stop,Address Name,Address Name
DocType: Employee Promotion,Employee Promotion,Promocija zaposlenika
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments selected for Journal Entry,Nije izabrana nikakva otplata za unos dnevnika
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čunati na osnovu ove fakturne vrijednosti.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Ne može se odbiti kada je kategorija za &#39;Vrednovanje&#39; ili &#39;Vaulation i Total&#39;
DocType: Quality Goal,Revised On,Revised On
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please enter Root Type for - {0},Molimo unesite Root Type za - {0}
apps/erpnext/erpnext/healthcare/utils.py,The item referenced by {0} - {1} is already invoiced,Stavka na koju upućuje {0} - {1} je već fakturirana
DocType: Driver,Suspended,Suspended
DocType: Asset Category Account,Accumulated Depreciation Account,Akumulirani račun amortizacije
DocType: Journal Entry Account,Credit in Company Currency,Krediti u valuti kompanije
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Entertainment & Leisure,Zabava i slobodno vrijeme
DocType: Email Digest,New Sales Invoice,Nova prodajna faktura
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Net Profit,Neto profit
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,Another Sales Person {0} exists with the same Employee id,Druga prodajna osoba {0} postoji s istim ID-om zaposlenika
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Closing (Dr),Zatvaranje (Dr)
DocType: Loyalty Point Entry,Loyalty Program Tier,Program lojalnosti Tier
DocType: Purchase Invoice,Total Taxes and Charges,Ukupni porezi i naknade
DocType: Amazon MWS Settings,JP,JP
DocType: Work Order Operation,Operation Description,Opis operacije
DocType: Bank Statement Transaction Entry,Bank Transaction Entries,Unosi bankovnih transakcija
DocType: HR Settings,Leave Approval Notification Template,Ostavite predložak obavijesti o odobrenju
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Type
DocType: Email Digest,New Purchase Invoice,Nova faktura kupovine
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 koja se traži za kupovinu, ali nije naručena."
DocType: Purchase Invoice,Supplier Name,Dobavljač Ime
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},Kliknite na &#39;Generiraj raspored&#39; da biste dohvatili serijski broj dodan za stavku {0}
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Delivered Items,Troškovi isporučenih artikala
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Consumed,Consumed
DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Pravna osoba / podružnica sa zasebnim kontnim planom Organizacije.
DocType: BOM,Show In Website,Show In Website
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.","Zatim se Pravila o cijenama filtriraju na temelju klijenta, grupe korisnika, teritorije, dobavljača, vrste dobavljača, kampanje, prodajnog partnera itd."
DocType: Payment Request,Payment Request Type,Vrsta zahtjeva za plaćanje
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field To Shareholder cannot be blank,Polje Za dioničara ne može biti prazno
DocType: QuickBooks Migrator,QuickBooks Migrator,QuickBooks Migrator
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,POS Profile is required to use Point-of-Sale,POS profil je potreban za korištenje Point-of-Sale
DocType: Purchase Order,Purchase Order Pricing Rule,Pravilo o cijenama narudžbenice
DocType: Expense Claim,Expenses,Troškovi
DocType: Employee,Cheque,Provjeri
DocType: Purchase Invoice,Currency and Price List,Valuta i cjenik
DocType: Shopify Settings,Shop URL,URL prodavnice
DocType: Asset Movement,Source Location,Lokacija izvora
apps/erpnext/erpnext/accounts/page/pos/pos.js,Enter value must be positive,Unesite vrijednost mora biti pozitivna
DocType: Accounts Settings,Allow Cost Center In Entry of Balance Sheet Account,Omogući mjesto troška u unosu računa bilance
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js,Attendance,Prisustvo
DocType: Training Event,Internet,Internet
DocType: Monthly Distribution,Monthly Distribution Percentages,Procenat mjesečne distribucije
DocType: Delivery Settings,Dispatch Notification Template,Predložak za slanje obavijesti
apps/erpnext/erpnext/templates/print_formats/includes/total.html,Total (Without Tax),Ukupno (bez poreza)
DocType: Cash Flow Mapping,Cash Flow Mapping,Mapiranje novčanog toka
DocType: Patient Encounter,HLC-ENC-.YYYY.-,FHP-ENC-.YYYY.- \ t
DocType: Cash Flow Mapper,Section Leader,Lider sekcije
,Budget Variance Report,Izvještaj o odstupanju budžeta
DocType: Asset,Gross Purchase Amount,Bruto iznos kupovine
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date is mandatory,Datum polu-dana je obavezan
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Removed items with no change in quantity or value.,Uklonjene stavke bez promjene u količini ili vrijednosti.
DocType: Loan,Applicant Type,Tip podnosioca
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 2,U adresu 2
DocType: Purchase Receipt,Range,Range
DocType: Budget,BUDGET,BUDŽET
DocType: Journal Entry,Depreciation Entry,Unos amortizacije
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Cijena cjenika (valuta tvrtke)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Not Paid and Not Delivered,Nije plaćeno i nije isporučeno
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Sales Invoice {0} created,Napravljena je faktura prodaje {0}
DocType: Quality Review Table,Objective,Cilj
DocType: Inpatient Record,Admission Scheduled,Admission Scheduled
DocType: Purchase Order Item,To be delivered to customer,Isporučuje se kupcu
DocType: Attendance Request,On Duty,Na dužnosti
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Variable,Variable
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Row {0}: Depreciation Start Date is required,Red {0}: Datum početka amortizacije je obavezan
DocType: Options,Option,Opcija
DocType: Healthcare Settings,Out Patient SMS Alerts,Out Patient SMS Alerts
apps/erpnext/erpnext/setup/doctype/company/company.py,Sales Account,Račun prodaje
DocType: Weather,Weather Parameter,Vremenski parametar
DocType: Leave Control Panel,Allocate,Allocate
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Detalje o rasporedu održavanja
DocType: BOM Update Tool,BOM Update Tool,BOM Update Tool
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Notice Period,Otkazni rok
,Lead Owner Efficiency,Efikasnost vodećeg vlasnika
DocType: SMS Center,Total Characters,Ukupno znakova
DocType: Patient,Alcohol Past Use,Alcohol Past Use
DocType: Patient,Divorced,Razveden
DocType: Sales Invoice,Allocate Advances Automatically (FIFO),Automatski dodeljuje unapred (FIFO)
DocType: Leave Type,Is Compensatory,Is Compensatory
,Employees working on a holiday,Zaposleni rade na odmoru
DocType: Healthcare Practitioner,Mobile,Mobile
apps/erpnext/erpnext/utilities/activation.py,"Timesheets help keep track of time, cost and billing for activites done by your team","Vremenski listovi pomažu u praćenju vremena, troškova i naplate za aktivnosti koje vaš tim obavlja"
DocType: Delivery Stop,Order Information,Informacije o narudžbi
apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Subtotal
DocType: Invoice Discounting,Invoice Discounting,Faktura Popust
apps/erpnext/erpnext/regional/italy/utils.py,Nos,Nos
DocType: Stock Settings,Freeze Stock Entries,Freeze Stock Entries
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Item {0} not found,Stavka {0} nije pronađena
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,You have entered duplicate items. Please rectify and try again.,Uneli ste duple stavke. Ispravite i pokušajte ponovo.
DocType: Purchase Invoice Item,Rate,Rate
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.py,Saving {0},Spremanje {0}
DocType: SMS Center,Total Message(s),Ukupno poruka (e)
DocType: Purchase Invoice,Accounting Dimensions,Dimenzije računovodstva
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Account,Grupa po računu
DocType: Quotation,In Words will be visible once you save the Quotation.,In Words će biti vidljive kada sačuvate ponudu.
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js,Quantity to Produce,Količina za proizvodnju
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,Red # {0}: Ne može se postaviti stopa ako je iznos veći od obračunatog iznosa za stavku {1}.
DocType: Work Order Operation,Actual Start Time,Stvarno vrijeme početka
DocType: Antibiotic,Laboratory User,Korisnik laboratorija
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Online Auctions,Online Auctions
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Priority {0} has been repeated.,Ponovljen je prioritet {0}.
DocType: Fee Schedule,Fee Creation Status,Status stvaranja naknade
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Softwares,Softwares
apps/erpnext/erpnext/config/help.py,Sales Order to Payment,Prodajni nalog do plaćanja
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,This is based on transactions against this Healthcare Practitioner.,Ovo se zasniva na transakcijama protiv ovog zdravstvenog radnika.
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Assigning Structures...,Dodjeljivanje struktura ...
apps/erpnext/erpnext/config/manufacturing.py,Details of the operations carried out.,Pojedinosti o izvršenim operacijama.
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Operation Time must be greater than 0 for Operation {0},Vrijeme rada mora biti veće od 0 za rad {0}
apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Pitanje mora imati barem jednu ispravnu opciju
DocType: Shareholder,Folio no.,Folio no.
DocType: Inpatient Record,A Negative,A Negative
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} is mandatory for Item {1},{0} je obavezna za stavku {1}
,Production Analytics,Analitika proizvodnje
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Set Supplier for item {1},Red # {0}: Postavi dobavljača za stavku {1}
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter_dashboard.py,Records,Records
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Case No(s) already in use. Try from Case No {0},Broj predmeta koji se već koriste. Pokušajte iz Case No {0}
DocType: Chapter Member,Website URL,URL sajta
apps/erpnext/erpnext/accounts/doctype/account/account.py,Report Type is mandatory,Tip izveštaja je obavezan
DocType: Vehicle,Policy No,Politika br
apps/erpnext/erpnext/hr/report/daily_work_summary_replies/daily_work_summary_replies.py,Replies,Odgovori
DocType: Supplier Scorecard Scoring Variable,Variable Name,Naziv promenljive
DocType: Rename Tool,Utilities,Utilities
DocType: Job Card,Total Completed Qty,Ukupno Završeno Kol
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials to Manufacture,Nema artikala sa materijalom za proizvodnju
DocType: Purchase Order Item,Blanket Order Rate,Stopa porudžbine
DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Pratite odvojene prihode i troškove za vertikale ili podjele proizvoda.
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid SSL certificate on attachment {0},Upozorenje: Nevažeći SSL certifikat o privitku {0}
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp Count,Opp Count
apps/erpnext/erpnext/education/doctype/instructor/instructor.js,As Examiner,Kao ispitivač
DocType: Company,Default Expense Claim Payable Account,Račun naplate potraživanja po defaultu
DocType: Additional Salary,HR-ADS-.YY.-.MM.-,HR-ADS-.YY .-.
apps/erpnext/erpnext/templates/pages/search_help.py,Docs Search,Pretraživanje dokumenata
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 manji od početnog datuma
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials.,Nema stavki sa materijalom.
apps/erpnext/erpnext/config/support.py,Single unit of an Item.,Jedinica jedinice.
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Quotations,Citati
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Could not generate Secret,Nije moguće generisati tajnu
DocType: Purchase Taxes and Charges,Valuation and Total,Vrednovanje i ukupno
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Member Activity,Member Activity
DocType: Upload Attendance,Import Attendance,Prisustvo uvoza
DocType: POS Profile,Account for Change Amount,Račun za iznos promene
,Item Price Stock,Stavka Cijena zaliha
DocType: Asset,ACC-ASS-.YYYY.-,ACC-ASS-.YYYY.-
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,"Request for Quotation is disabled to access from portal, for more check portal settings.","Zahtjev za ponudu je onemogućen za pristup s portala, za više provjera postavki portala."
DocType: Bank Statement Settings Item,Mapped Header,Mapped Header
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,"Item Code, warehouse, quantity are required on row","Šifra artikla, skladište, količina je potrebna u redu"
DocType: Payment Order Reference,Bank Account Details,Detalji bankovnog računa
DocType: Homepage,Homepage Slideshow,Homepage Slideshow
DocType: Travel Request,"Partially Sponsored, Require Partial Funding","Delimično sponzorisana, zahtevaju delimično finansiranje"
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Payment of {0} from {1} to {2},Plaćanje od {0} od {1} do {2}
,Serial No Status,Serijski nema statusa
DocType: Donor,Donor,Donator
DocType: BOM,Item UOM,Stavka UOM
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Red {0}: izaberite radnu stanicu protiv operacije {1}
DocType: Stock Settings,Default Return Warehouse,Default Return Warehouse
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py,{0} must be submitted,{0} mora biti dostavljen
DocType: Project,Estimated Cost,Procjena troškova
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot/Lead %,Quot / Lead%
apps/erpnext/erpnext/config/non_profit.py,Member information.,Informacije o članovima.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Reverse Journal Entry
apps/erpnext/erpnext/utilities/user_progress.py,Set a sales goal you'd like to achieve for your company.,Postavite cilj prodaje koji želite postići za svoju tvrtku.
DocType: Lab Test Template,Special,Poseban
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Subcontract: Raw materials quantity to make subcotracted items.,Rezervisana količina za podugovor: Količina sirovina za izradu podkatara.
DocType: Patient Encounter,In print,In print
apps/erpnext/erpnext/accounts/report/financial_statements.py,Could not retrieve information for {0}.,Nije moguće dohvatiti informacije za {0}.
apps/erpnext/erpnext/accounts/party.py,Billing currency must be equal to either default company's currency or party account currency,Valuta za naplatu mora biti jednaka ili zadanoj valuti kompanije ili valuti stranaka računa
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js,Please enter Employee Id of this sales person,Molimo vas da unesete ID zaposlenika ovog prodavača
DocType: Shift Type,Early Exit Consequence after,Rane izlaze nakon
apps/erpnext/erpnext/config/accounting.py,Create Opening Sales and Purchase Invoices,Napravite otvaranje faktura prodaje i kupovine
DocType: Disease,Treatment Period,Period liječenja
apps/erpnext/erpnext/config/settings.py,Setting up Email,Podešavanje e-pošte
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Debit Note Amount,Iznos duga
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Stopa po kojoj se valuta cjenika pretvara u osnovnu valutu kupca
apps/erpnext/erpnext/hooks.py,Certification,Certifikat
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Ovdje možete održavati visinu, težinu, alergije, medicinske probleme itd"
DocType: Journal Entry,Print Heading,Print Heading
DocType: Grant Application,Withdrawn,Povučen
apps/erpnext/erpnext/public/js/utils/party.js,Select company first,Najprije odaberite tvrtku
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Application period cannot be across two allocation records,Period primene ne može biti na dve evidencije o dodeli
apps/erpnext/erpnext/templates/pages/order.html,Rate:,Ocijeni:
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Employee {0} has no maximum benefit amount,Zaposlenik {0} nema maksimalni iznos naknade
DocType: Employee Skill Map,Employee Skills,Employee Skills
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Name: ,Ime studenta:
DocType: SMS Log,Sent On,Sent On
DocType: Bank Statement Transaction Invoice Item,Sales Invoice,Faktura prodaje
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 zasnovanu na kursu, kurs će biti validiran za svakog studenta sa upisanih kurseva u upis u program."
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Intra-State Supplies,Unutrašnja oprema
DocType: Employee,Create User Permission,Kreiranje korisničke dozvole
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Please save the report again to rebuild or update,Sačuvajte ponovo izveštaj da biste ponovo izgradili ili ažurirali
DocType: C-Form Invoice Detail,Territory,Teritorija
DocType: C-Form,Quarter,Četvrtina
DocType: Purchase Invoice,Grand Total (Company Currency),Grand Total (Valuta kompanije)
DocType: Prescription Dosage,Prescription Dosage,Doziranje na recept
DocType: Salary Slip,Hour Rate,Hour Rate
DocType: Location,Latitude,Latitude
DocType: Expense Claim Detail,Expense Date,Datum rashoda
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show Payment Details,Prikaži detalje plaćanja
DocType: Company,Default Payable Account,Default Payable Account
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to any Warehouse,Serijski broj {0} ne pripada nijednom skladištu
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Party,Grupa po partiji
DocType: Volunteer,Evening,Večer
DocType: Campaign,SAL-CAM-.YYYY.-,SAL-CAM-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Exchange Gain/Loss,Exchange Gain / Loss
DocType: Payment Request,Make Sales Invoice,Napravite fakturu prodaje
DocType: Opening Invoice Creation Tool,Create Missing Party,Napravite nestalu stranku
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For quantity {0} should not be grater than work order quantity {1},Za količinu {0} ne bi trebalo da bude veća od količine radnog naloga {1}
DocType: Landed Cost Voucher,Additional Charges,Additional Charges
DocType: Assessment Result Tool,Assessment Result Tool,Alat rezultata procjene
DocType: Journal Entry,Contra Entry,Contra Entry
DocType: Student Applicant,Application Status,Status aplikacije
DocType: Journal Entry,Total Amount in Words,Ukupan iznos u riječima
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment. ","Pratite prodajne kampanje. Pratite vodi, citatima, prodajnim nalozima i sl. Iz kampanja da biste izmjerili povrat ulaganja."
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Missing Currency Exchange Rates for {0},Nedostaje kursna lista valuta za {0}
DocType: Pricing Rule Item Group,Pricing Rule Item Group,Grupa odredbi o cijenama cijena
DocType: Quality Inspection Reading,Reading 8,Čitanje 8
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,From Fiscal Year,Od fiskalne godine
DocType: Tally Migration,Tally Creditors Account,Račun poverilaca
DocType: Student Report Generation Tool,Print Section,Print Section
apps/erpnext/erpnext/hr/doctype/department/department.js,This is a root department and cannot be edited.,Ovo je root odjel i ne može se uređivati.
,Project Quantity,Količina projekta
apps/erpnext/erpnext/config/settings.py,Standard contract terms for Sales or Purchase.,Standardni uslovi ugovora za prodaju ili kupovinu.
DocType: Sales Invoice,Customer PO Details,Detalji o korisničkom PO-u
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Patient not found,Pacijent nije pronađen
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Select a Default Priority.,Izaberite podrazumevani prioritet.
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Remove item if charges is not applicable to that item,Uklonite stavku ako naplata nije primjenjiva na tu stavku
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 korisnička grupa sa istim imenom, promijenite ime klijenta ili preimenujte korisničku grupu"
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 predložak poreza koji se može primijeniti na sve transakcije prodaje. Ovaj predložak može sadržati popis poreznih glava, kao i druge glave za troškove / prihode kao što su &quot;Špedicija&quot;, &quot;Osiguranje&quot;, &quot;Rukovanje&quot; itd. #### Napomena Porezna stopa koju ovde definišete biće standardna poreska stopa za sve ** Stavke **. Ako postoje ** stavke ** koje imaju različite stope, one se moraju dodati u tablicu ** Item Tax ** u ** Item ** master. #### Opis kolona 1. Vrsta kalkulacije: - To može biti na ** Neto Ukupan ** (to je zbir osnovnog iznosa). - ** Na prethodni red Ukupno / iznos ** (za kumulativne poreze ili naknade). Ako odaberete ovu opciju, porez će se primjenjivati kao postotak od prethodnog reda (u poreznoj tablici) iznosa ili ukupnog iznosa. - ** Actual ** (kao što je spomenuto). 2. Voditelj računa: Knjigovodstvena knjiga pod kojom će se ovaj porez rezervirati 3. Centar troška: Ako je porez / naknada prihod (kao što je otprema) ili trošak, potrebno ga je knjižiti na mjesto troška. 4. Opis: Opis poreza (koji će biti odštampan u fakturama / navodnicima). 5. Stopa: Stopa poreza. 6. Iznos: Iznos poreza. 7. Ukupno: Kumulativni ukupni iznos za ovu tačku. 8. Unesite red: Ako se na osnovu &quot;Prethodni redak ukupno&quot; možete izabrati broj reda koji će se uzeti kao osnova za ovaj izračun (podrazumevani je prethodni red). 9. Da li je ovaj porez uključen u osnovnu stopu ?: Ako ovo označite, to znači da ovaj porez neće biti prikazan ispod tabele stavki, već će biti uključen u osnovnu stopu u vašoj glavnoj tabeli stavki. Ovo je korisno tamo gdje želite dati jedinstvenu cijenu (uključujući sve poreze) kupcima."
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,To Date must be greater than From Date,Datum mora biti veći od datuma
DocType: Customer Group,Parent Customer Group,Grupa roditelja
DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,Cene neće biti prikazane ako Cenovnik nije postavljen
apps/erpnext/erpnext/config/settings.py,ERPNext Settings,Postavke ERPNext
apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Vremenski list za proizvodnju.
DocType: Student Language,Student Language,Student Language
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Payment Schedule,Postavite raspored plaćanja
DocType: Travel Request,Name of Organizer,Ime organizatora
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Postavite račune za amortizaciju u kategoriji imovine {0} ili tvrtku {1}
apps/erpnext/erpnext/config/accounting.py,Setup cheque dimensions for printing,Podešavanje proverite dimenzije za štampanje
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 Vas da nam se javite."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Purchase Receipt {0} is not submitted,Potvrda o kupnji {0} nije poslana
DocType: Task,Total Expense Claim (via Expense Claim),Ukupni iznos potraživanja (preko potraživanja od rashoda)
DocType: Quality Goal,Quality Goal,Cilj kvaliteta
DocType: Support Settings,Support Portal,Portal za podršku
apps/erpnext/erpnext/projects/doctype/project/project.py,End date of task <b>{0}</b> cannot be less than <b>{1}</b> expected start date <b>{2}</b>,Datum završetka zadatka <b>{0}</b> ne može biti manji od <b>{1}</b> očekivanog datuma početka <b>{2}</b>
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} is on Leave on {1},Zaposleni {0} je na ostavi na {1}
apps/erpnext/erpnext/support/doctype/issue/issue.py,This Service Level Agreement is specific to Customer {0},Ovaj ugovor o nivou usluge je specifičan za klijenta {0}
DocType: Employee,Held On,Održanoj
DocType: Healthcare Practitioner,Practitioner Schedules,Raspored praktičara
DocType: Project Template Task,Begin On (Days),Počni (dana)
DocType: Production Plan,"If enabled, then system will create the material even if the raw materials are available","Ako je omogućeno, sistem će stvoriti materijal čak i ako su sirovine dostupne"
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work Order has been {0},Radni nalog je bio {0}
DocType: Inpatient Record,Admission Schedule Date,Datum upisa
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Value Adjustment,Podešavanje vrednosti imovine
DocType: Shift Type,Mark attendance based on 'Employee Checkin' for Employees assigned to this shift.,Označite prisustvo na osnovu &#39;Check-inja zaposlenika&#39; za zaposlene koji su dodijeljeni ovoj smjeni.
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to Unregistered Persons,Potrošni materijal za neregistrovana lica
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,All Jobs,All Jobs
DocType: Appointment Type,Appointment Type,Tip sastanka
DocType: Manufacturing Settings,Allow Overtime,Allow Overtime
DocType: Sales Invoice Item,Available Qty at Warehouse,Dostupno Qty at Warehouse
DocType: Sales Invoice Item,Sales Invoice Item,Stavka fakture prodaje
DocType: Additional Salary,HR,HR
DocType: Student Report Generation Tool,Assessment Terms,Uslovi procene
apps/erpnext/erpnext/controllers/item_variant.py,Increment for Attribute {0} cannot be 0,Povećanje za atribut {0} ne može biti 0
DocType: Leave Control Panel,Carry Forward,Nastaviti
DocType: Dependent Task,Dependent Task,Zavisni zadatak
DocType: Allowed To Transact With,Allowed To Transact With,Dozvoljeno za transakciju
apps/erpnext/erpnext/public/js/hub/marketplace.js,Become a Seller,Postanite prodavac
DocType: Bank Reconciliation,Bank Reconciliation,Bankovno pomirenje
apps/erpnext/erpnext/config/projects.py,Types of activities for Time Logs,Vrste aktivnosti za logove vremena
DocType: POS Closing Voucher Invoices,POS Closing Voucher Invoices,Račun za zatvaranje vaučera za POS
DocType: Inpatient Record,AB Negative,AB Negative
DocType: Company,Budget Detail,Detalji o budžetu
DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normalni referentni opseg za odrasle je 16-20 udisaja u minuti (RCP 2012)
DocType: Production Plan,Sales Orders,Prodajni nalozi
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Create Journal Entry,Kreirajte unos dnevnika
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Osigurani krediti
DocType: Share Transfer,To Shareholder,Za akcionara
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Maintenance Schedule,Raspored održavanja
DocType: Chapter,"chapters/chapter_name
leave blank automatically set after saving chapter.",poglavlja / chapter_name ostavljaju prazninu automatski postavljenu nakon spremanja poglavlja.
DocType: Shopping Cart Settings,Payment Success Url,Uspjeh plaćanja Url
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Isporučeni iznos
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/hr/doctype/employee_benefit_application/employee_benefit_application.py,Salary Structure not found for employee {0} and date {1},Struktura plata nije pronađena za zaposlene {0} i datum {1}
DocType: Healthcare Settings,Invoice Appointments Automatically,Automatsko imenovanje faktura
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 detalje za izradu rezultata ocjenjivanja.
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Variance ({}),Varijacija ({})
DocType: Healthcare Settings,Patient Name,Ime pacijenta
apps/erpnext/erpnext/public/js/setup_wizard.js,Your Organization,Your Organization
DocType: Contract,Fulfilment Details,Detalji o ispunjavanju
DocType: Project,Total Billed Amount (via Sales Invoices),Ukupan iznos naplate (putem faktura prodaje)
apps/erpnext/erpnext/utilities/user_progress.py,Kg,Kg
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Appointment cancelled,Sastanak otkazan
DocType: Healthcare Settings,Reminder Message,Poruka podsjetnika
DocType: Repayment Schedule,Balance Loan Amount,Iznos bilansnog kredita
apps/erpnext/erpnext/config/crm.py,Manage Sales Person Tree.,Upravljanje stablom prodavača.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,There are more holidays than working days this month.,U ovom mjesecu ima više odmora nego radnih dana.
DocType: Item,Default BOM,Default BOM
DocType: BOM,Operating Cost (Company Currency),Operativni trošak (valuta kompanije)
DocType: Item Price,Item Price,Cijena stavke
DocType: Payment Entry,Party Name,Ime stranke
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select a customer,Izaberite klijenta
DocType: Program Enrollment Tool,New Program,Novi program
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,"Number of new Cost Center, it will be included in the cost center name as a prefix","Broj novog troškovnog centra, on će biti uključen u naziv mjesta troška kao prefiks"
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Select the customer or supplier.,Izaberite kupca ili dobavljača.
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Valid till date cannot be before transaction date,Važi do datuma ne može biti pre datuma transakcije
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Cannot deactivate or cancel BOM as it is linked with other BOMs,BOM nije moguće deaktivirati ili otkazati jer je povezan s drugim sastavnicama
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Place Of Supply (State/UT),Mjesto opskrbe (država / UT)
DocType: Job Opening,Job Title,Naziv posla
DocType: Fee Component,Fee Component,Komponenta naknada
apps/erpnext/erpnext/config/accounting.py,C-Form records,Zapisi C-Forma
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Cancelled. Please check your GoCardless Account for more details,Plaćanje otkazano. Molimo Vas da provjerite svoj GoCardless račun za više detalja
DocType: Crop Cycle,Less than a year,Manje od godinu dana
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0} must be submitted,Radni nalog {0} mora biti dostavljen
apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js,Filter Total Zero Qty,Filtrirajte ukupan broj nula
DocType: Job Applicant,Applicant for a Job,Podnosilac prijave za posao
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,No records found in the Invoice table,Nema zapisa u tabeli fakture
DocType: Chart of Accounts Importer,Chart of Accounts Importer,Grafikon računa uvoznika
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item or Warehouse for row {0} does not match Material Request,Stavka ili skladište za redak {0} ne odgovara upitu materijala
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,IGST Amount,IGST Iznos
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,Delivery Notes {0} updated,Napomene o isporuci {0} su ažurirane
DocType: Travel Itinerary,Lodging Required,Lodging Required
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Total Revenue,Ukupnog prihoda
DocType: Student Group Student,Student Group Student,Student Student Group
DocType: Customer,Buyer of Goods and Services.,Kupac robe i usluga.
DocType: Vehicle,Vehicle,Vozilo
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 redu {1}
DocType: Retention Bonus,Bonus Amount,Bonus iznos
DocType: Stock Reconciliation Item,Amount Difference,Amount Difference
DocType: Asset Maintenance,Maintenance Tasks,Zadaci održavanja
DocType: HR Settings,Stop Birthday Reminders,Zaustavite podsetnike za rođendan
DocType: Payment Gateway Account,Payment Account,Račun plaćanja
DocType: Stock Settings,Stock Frozen Upto,Stock Frozen Upto
DocType: Item,Default Material Request Type,Podrazumijevani tip zahtjeva za materijal
DocType: Clinical Procedure Item,Clinical Procedure Item,Stavka kliničkog postupka
DocType: Finance Book,Finance Book,Finance Book
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py,From Datetime,From Datetime
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/stock/report/item_variant_details/item_variant_details.py,Open Orders,Open Orders
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.js,Admit,Priznati
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py,Total {0} ({1}),Ukupno {0} ({1})
DocType: Certified Consultant,GitHub ID,GitHub ID
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Address 1,From Address 1
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Total hours: {0},Ukupno sati: {0}
DocType: Employee Transfer,Transfer Date,Datum transfera
DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,Unesite naziv kampanje ako je izvor upita kampanja
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 stavka je predložak i ne može se koristiti u transakcijama. Atributi stavki će se kopirati u varijante osim ako nije postavljeno &quot;No Copy&quot;
DocType: Cheque Print Template,Regular,Regular
apps/erpnext/erpnext/controllers/selling_controller.py,Maximum discount for Item {0} is {1}%,Maksimalni popust za stavku {0} je {1}%
DocType: Production Plan,Not Started,Nije počelo
DocType: Disease,Treatment Task,Zadatak tretmana
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>,Red {0}: korisnik nije primijenio pravilo <b>{1}</b> na stavku <b>{2}</b>
DocType: Landed Cost Voucher,Landed Cost Help,Pomoć za uzletnu cijenu
DocType: Supplier Scorecard,Scoring Criteria,Kriterijumi bodovanja
DocType: Bank Statement Transaction Entry,Matching Invoices,Odgovarajući računi
DocType: Donor,Donor Name,Ime donatora
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Select Property,Izaberite Svojstvo
DocType: Homepage,Homepage Section,Homepage Section
DocType: Assessment Result,Grade,Grade
DocType: Production Plan Material Request,Production Plan Material Request,Zahtjev materijala za plan proizvodnje
DocType: Request for Quotation Supplier,Send Email,Pošaljite e-mail
DocType: Item,Retain Sample,Zadržite uzorak
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0} (Payment Table): Amount must be negative,Red # {0} (Tabela plaćanja): Iznos mora biti negativan
,Warehouse wise Item Balance Age and Value,Warehouse wise Item Balance Age and Value
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 + težina ambalaže. (za štampu)
DocType: Plant Analysis,Laboratory Testing Datetime,Datetime test laboratorijskog testiranja
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,The Item {0} cannot have Batch,Stavka {0} ne može imati paket
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Student Group Strength,Snaga studentske grupe
DocType: Bank Statement Transaction Entry,Bank Statement Transaction Entry,Unos transakcije bankovnog izvoda
DocType: Purchase Order,Get Items from Open Material Requests,Nabavite stavke iz zahtjeva otvorenog materijala
DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Fiskalna godina ** predstavlja finansijsku godinu. Sve računovodstvene stavke i druge velike transakcije prate se ** ** fiskalna godina **.
DocType: Procedure Prescription,Procedure Name,Naziv postupka
apps/erpnext/erpnext/public/js/event.js,Add Sales Partners,Dodajte prodajne partnere
apps/erpnext/erpnext/public/js/pos/pos.html,Qty Total,Ukupno ukupno
DocType: Payment Entry Reference,Outstanding,Izvanredno
DocType: Employee Tax Exemption Proof Submission,Employee Tax Exemption Proof Submission,Podnošenje dokaza o oslobađanju od plaćanja poreza na zaposlene
DocType: Contract Fulfilment Checklist,Requirement,Zahtev
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,No active or default Salary Structure found for employee {0} for the given dates,Nema aktivne ili zadane strukture plaća za zaposlenika {0} za zadane datume
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity should be greater than 0,Količina bi trebala biti veća od 0
DocType: Purchase Order Item,Supplier Quotation Item,Stavka ponude dobavljača
DocType: Appraisal,Appraisal Template,Predložak procjene
DocType: Item,Hub Category to Publish,Kategorija Hub-a za objavljivanje
DocType: Staffing Plan Detail,Current Openings,Current Openings
apps/erpnext/erpnext/config/crm.py,Customer Database.,Baza podataka klijenata.
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,As On Date,Kao na datum
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Delivery Note {0} is not submitted,Napomena za isporuku {0} nije poslata
DocType: Appraisal Template Goal,Appraisal Template Goal,Predložak procjene cilja
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Closing (Cr),Zatvaranje (Cr)
DocType: Restaurant Reservation,Restaurant Reservation,Rezervacija restorana
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Last Order Amount,Iznos posljednje narudžbe
apps/erpnext/erpnext/config/desktop.py,Learn,Learn
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Višestruki podrazumevani način plaćanja nije dozvoljen
DocType: Crop Cycle,This will be day 1 of the crop cycle,Ovo će biti prvi dan ciklusa useva
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/controllers/stock_controller.py,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Račun troškova ili razlike je obavezan za stavku {0} jer utječe na ukupnu vrijednost dionica
DocType: Purchase Invoice,Price List Exchange Rate,Cenovnik kursa
DocType: Purchase Invoice Item,Amount (Company Currency),Iznos (valuta kompanije)
DocType: Driver,Driver,Driver
DocType: GST Account,CGST Account,CGST Račun
DocType: Loan,Disbursement Date,Datum isplate
apps/erpnext/erpnext/templates/pages/projects.html,New task,Novi zadatak
DocType: Customer Feedback Table,Customer Feedback Table,Tabela povratnih informacija korisnika
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Course {2},{0} - {1} nije upisano u kurs {2}
DocType: Asset Value Adjustment,Difference Amount,Iznos razlike
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Cheques and Deposits incorrectly cleared,Provjere i depoziti su pogrešno izbrisani
DocType: Journal Entry,Cash Entry,Cash Entry
DocType: GST Settings,GST Settings,GST postavke
,Item-wise Sales Register,Registar prodaje
apps/erpnext/erpnext/stock/doctype/item/item.py,Item has variants.,Stavka ima varijante.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Difference Amount must be zero,Razlika Iznos mora biti nula
DocType: Fee Schedule,Institution,Institucija
DocType: Patient,Tobacco Current Use,Trenutna upotreba duvana
apps/erpnext/erpnext/utilities/user_progress.py,Setup your ,Podesite svoj
DocType: Payment Entry Deduction,Payment Entry Deduction,Odbitak za plaćanje
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}: Serija {1} ima samo {2} kom. Molimo odaberite drugi paket koji ima dostupnu količinu {3} ili podijelite red na više redova, kako biste isporučili / izdali više paketa"
DocType: Patient Appointment,Procedure,Procedura
,Total Stock Summary,Ukupan pregled zaliha
DocType: Purchase Invoice,Additional Discount,Dodatni popust
DocType: Healthcare Settings,Patient Name By,Ime pacijenta By
DocType: Healthcare Service Unit Type,Rate / UOM,Stopa / UOM
DocType: Job Offer,Job Offer Terms,Uslovi ponude za posao
DocType: GL Entry,Debit Amount in Account Currency,Iznos dugovanja u valuti računa
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,{0} must appear only once,{0} se mora pojaviti samo jednom
apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Račun rashoda / razlike ({0}) mora biti račun profita ili gubitka
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},Red No {0}: Iznos ne može biti veći od iznosa na čekanju u odnosu na potraživanje rashoda {1}. Iznos na čekanju je {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Earnest Money,Earnest Money
apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Sve kartice dobavljača.
DocType: Sales Invoice,Terms and Conditions Details,Uvjeti i odredbe Detalji
DocType: Exchange Rate Revaluation,Get Entries,Get Entries
DocType: Vehicle Service,Service Item,Predmet usluge
DocType: Sales Invoice,Customer's Purchase Order,Narudžbenica kupca
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in formula or condition: {0},Greška sintakse u formuli ili uslovu: {0}
DocType: Agriculture Analysis Criteria,Agriculture User,Korisnik poljoprivrede
apps/erpnext/erpnext/controllers/buying_controller.py,Please enter Reqd by Date,Molimo unesite zahtjev po datumu
DocType: Company,Total Monthly Sales,Ukupna mjesečna prodaja
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Procenat mjesečne distribucije
DocType: Stock Reconciliation,Reconciliation JSON,Reconciliation JSON
apps/erpnext/erpnext/stock/get_item_details.py,No Item with Barcode {0},Nema stavke sa barkodom {0}
DocType: Asset,Scrapped,Otpisan
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Delivery Trip,Trip Trip
DocType: Student Admission Program,Application Fee,Pristojba za prijavu
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Sales orders are not available for production,Prodajni nalozi nisu dostupni za proizvodnju
DocType: Website Attribute,Attribute,Atribut
DocType: Rename Tool,Rename Log,Preimenuj dnevnik
apps/erpnext/erpnext/controllers/trends.py,'Based On' and 'Group By' can not be same,&#39;Based On&#39; i &#39;Group By&#39; ne mogu biti isti
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.js,Show Ageing Warehouse-wise,Show Aging Warehouse-wise
DocType: Sales Invoice,Write Off Outstanding Amount,Ispisivanje izvanrednog iznosa
DocType: Payroll Entry,Employee Details,Detalji o zaposlenima
DocType: Pricing Rule,Discount Amount,Iznos popusta
DocType: Healthcare Service Unit Type,Item Details,Detalji detalja
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.py,Duplicate Tax Declaration of {0} for period {1},Duplicirana porezna deklaracija {0} za period {1}
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js,From Delivery Note,Od dostavnice
DocType: Holiday,Holiday,Holiday
DocType: Cheque Print Template,Line spacing for amount in words,Razmak između redova za iznos u riječima
DocType: Item Group,Item Group Defaults,Default Group Defaults
DocType: Salary Component,Abbr,Abbr
apps/erpnext/erpnext/config/support.py,Warranty Claim against Serial No.,Zahtev za garanciju protiv serijskog broja
apps/erpnext/erpnext/config/desktop.py,Quality,Kvalitet
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,{0} is not a stock Item,{0} nije dionica
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Troškovi isporučenih sirovina
DocType: Employee,Permanent Address,stalna adresa
DocType: Asset,Booked Fixed Asset,Booked Fixed Asset
apps/erpnext/erpnext/templates/pages/help.html,Your tickets,Vaše karte
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Create Supplier Quotation,Kreirajte ponudu dobavljača
DocType: Item,Inspection Required before Purchase,Potrebna inspekcija prije kupovine
DocType: Payment Entry,Payment Ordered,Naručeno plaćanje
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.","Izgleda da postoji problem sa konfiguracijom servera GoCardless. Ne brinite, u slučaju neuspjeha, iznos će biti vraćen na vaš račun."
apps/erpnext/erpnext/accounts/page/pos/pos.js,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.",Način plaćanja nije konfiguriran. Molimo provjerite da li je račun postavljen na način plaćanja ili na POS profil.
DocType: Email Digest,Purchase Orders Items Overdue,Stavke narudžbenice Dospjele
DocType: BOM,Inspection Required,Potrebna inspekcija
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled so the action cannot be completed,{0} {1} je otkazano tako da se radnja ne može dovršiti
DocType: Project Template Task,Project Template Task,Zadatak predloška projekta
apps/erpnext/erpnext/projects/doctype/task/task.py,Circular Reference Error,Kružna referentna greška
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: račun tipa &#39;Profit i gubitak&#39; {2} nije dozvoljen u uvodnom unosu
DocType: Website Item Group,Cross Listing of Item in multiple groups,Unos stavke u više grupa
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction cannot be converted to ledger,Račun sa postojećom transakcijom ne može se pretvoriti u knjigu
DocType: POS Profile,Display Items In Stock,Prikaz stavki na zalihi
DocType: Issue,Service Level,Nivo usluge
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Other outward supplies(Nil rated,Exempted)","Ostali spoljni potrošni materijal (Nil ocijenjeno, Izuzeto)"
,TDS Payable Monthly,TDS Plaća Mesečno
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select Posting Date before selecting Party,Molimo odaberite Datum knjiženja prije odabira Stranke
,GST Purchase Register,Registar nabavke GST-a
DocType: Accounts Settings,Automatically Add Taxes and Charges from Item Tax Template,Automatski dodajte poreze i naknade iz šablona poreza na stavku
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Stock Options,Stock Options
DocType: Healthcare Schedule Time Slot,Healthcare Schedule Time Slot,Terminski plan vremenskog rasporeda zdravstvene zaštite
apps/erpnext/erpnext/public/js/pos/pos.html,Tap items to add them here,Dodirnite stavke da biste ih dodali ovdje
DocType: Payment Schedule,Invoice Portion,Invoice Delion
apps/erpnext/erpnext/config/accounting.py,Tax Category for overriding tax rates.,Kategorija poreza za prevazilaženje poreskih stopa.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Retained Earnings,Zadržana zarada
DocType: Grant Application,Requested Amount,Traženi iznos
DocType: Salary Detail,Additional Amount,Dodatni iznos
DocType: Quiz,Quiz Configuration,Konfiguracija kviza
DocType: Mode of Payment,General,General
DocType: Email Digest,Annual Expenses,Godišnji troškovi
apps/erpnext/erpnext/projects/doctype/project/project.py,Expected End Date can not be less than Expected Start Date,Očekivani datum završetka ne može biti manji od očekivanog datuma početka
DocType: Global Defaults,Disable In Words,Onemogući u rečima
DocType: Customer,CUST-.YYYY.-,CUST-.YYYY.-
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Net pay cannot be negative,Neto plata ne može biti negativna
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,No of Interactions,Broj interakcija
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} na narudžbenicu narudžbe {3}
DocType: Attendance,Shift,Shift
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Chart of Accounts and Parties,Obrada kontnog plana i strana
DocType: Stock Settings,Convert Item Description to Clean HTML,Pretvori opis stavke u Clean HTML
apps/erpnext/erpnext/patches/v11_0/rename_supplier_type_to_supplier_group.py,All Supplier Groups,Sve grupe dobavljača
,Final Assessment Grades,Konačne ocjene ocjenjivanja
apps/erpnext/erpnext/projects/doctype/task/task.py,Cannot close task {0} as its dependant task {1} is not closed.,Nije moguće zatvoriti zadatak {0} jer njegov zavisni zadatak {1} nije zatvoren.
DocType: Promotional Scheme,Promotional Scheme Price Discount,Promotivna shema Cijena Popust
DocType: Installation Note,Installation Note,Napomena za instalaciju
DocType: Student Admission,Application Form Route,Putanja obrasca aplikacije
DocType: Work Order,Planned Operating Cost,Planirani operativni troškovi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Colour,Boja
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} is not in Optional Holiday List,{0} nije u opcionalnoj listi praznika
DocType: Student Report Generation Tool,Show Marks,Show Marks
DocType: Salary Component,Max Benefit Amount (Yearly),Maksimalni iznos pogodnosti (godišnje)
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Redoslijed amortizacije {0}: Sljedeći datum amortizacije ne može biti prije datuma kupovine
DocType: Loyalty Program,Customer Group,Customer Group
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 treba da bude jedna godina ranije od datuma završetka fiskalne godine
,BOM Items and Scraps,Stavke sastavnice i bilješke
apps/erpnext/erpnext/healthcare/setup.py,High Sensitivity,High Sensitivity
DocType: Pricing Rule,Apply Discount on Rate,Primijeni popust na stopu
DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Automatsko ažuriranje BOM troškova preko Scheduler-a, na osnovu najnovije stope procene / cene liste / poslednje stope kupovine sirovina."
DocType: Tally Migration,Tally Company,Tally Company
DocType: Quiz Question,Quiz Question,Quiz Question
DocType: Task Depends On,Task Depends On,Zadatak zavisi od
,Lead Id,Lead Id
DocType: Subscription Plan Detail,Subscription Plan Detail,Detalj plana pretplate
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Created {0} scorecards for {1} between: ,Napravljeno je {0} kartica rezultata za {1} između:
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,This Week's Summary,Rezime ove sedmice
DocType: Pricing Rule Item Code,Pricing Rule Item Code,Šifra artikla za pravila cijena
DocType: Water Analysis,Storage Temperature,Temperatura skladištenja
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Income,Direktni prihodi
apps/erpnext/erpnext/controllers/trends.py,Amt,Amt
,Sales Analytics,Sales Analytics
DocType: Project,Total Billable Amount (via Timesheets),Ukupan iznos koji se naplaćuje (putem Timesheets-a)
DocType: Setup Progress Action,Domains,Domains
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,"Not permitted, configure Lab Test Template as required","Nije dozvoljeno, konfigurirajte Lab Lab Template prema potrebi"
DocType: Item,Default Unit of Measure,Standard Unit of Measure
DocType: Serial No,Distinct unit of an Item,Jedinica jedinice
DocType: Amazon MWS Settings,Synch Products,Synch Products
DocType: Supplier Scorecard Scoring Variable,Path,Put
DocType: Project Task,Task ID,ID zadatka
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Dr),Otvaranje (Dr)
DocType: Project,% Completed,% Završeno
DocType: Customer,Commission Rate,Provizija
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Central Tax,Central Tax
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Total Outstanding Amount,Ukupan preostali iznos
DocType: Employee Tax Exemption Proof Submission Detail,Maximum Exemption Amount,Maksimalni iznos izuzeća
DocType: Subscription Plan,Based on price list,Na osnovu cjenika
DocType: Stock Entry Detail,Additional Cost,Dodatni troškovi
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Closing Account {0} must be of type Liability / Equity,Završni račun {0} mora biti tipa Liability / Equity
apps/erpnext/erpnext/utilities/user_progress.py,Setup Company,Setup Company
DocType: Inpatient Occupancy,Check In,Provjeri
apps/erpnext/erpnext/config/buying.py,Customer and Supplier,Kupac i dobavljač
DocType: Issue,Support Team,Tim za podršku
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: You can not assign itself as parent account,Račun {0}: Ne možete se dodijeliti kao nadređeni račun
apps/erpnext/erpnext/stock/doctype/item/item.py,Fixed Asset Item must be a non-stock item.,Stavka fiksnog sredstva mora biti stavka koja nije na zalihama.
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch ID (Optional),Novi ID serije (opcionalno)
apps/erpnext/erpnext/projects/doctype/project/project.js,Gantt Chart,Gantt Chart
DocType: Employee Benefit Application Detail,Max Benefit Amount,Maksimalni iznos pogodnosti
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Leave on {1},{0} na Ostavi na {1}
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Do you really want to restore this scrapped asset?,Da li zaista želite da vratite ovu aktivnu imovinu?
apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py,Registration fee can not be Zero,Kotizacija ne može biti Zero
DocType: Item Tax Template,Item Tax Template,Predložak poreza na stavku
DocType: Fiscal Year,Auto Created,Auto Created
DocType: Quality Objective,Quality Objective,Cilj kvaliteta
DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Glavu računa u okviru Obaveze ili Kapital, u kojoj će se rezervisati dobit / gubitak"
DocType: GL Entry,Credit Amount in Account Currency,Iznos kredita u valuti računa
DocType: Employee Onboarding Activity,Employee Onboarding Activity,Djelatnost zaposlenika
DocType: Healthcare Service Unit,Parent Service Unit,Jedinica za podršku roditelja
DocType: Sales Invoice,Include Payment (POS),Uključi plaćanje (POS)
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Private Equity,Private Equity
DocType: Shift Type,First Check-in and Last Check-out,Prva prijava i posljednja odjava
DocType: Landed Cost Item,Receipt Document,Dokument o prijemu
DocType: Supplier Scorecard Period,Supplier Scorecard Period,Period Scorecard dobavljača
DocType: Employee Grade,Default Salary Structure,Default Salary Structure
DocType: Exchange Rate Revaluation,Total Gain/Loss,Ukupna dobit / gubitak
apps/erpnext/erpnext/education/doctype/course_enrollment/course_enrollment.py,Student is already enrolled.,Student je već upisan.
DocType: Product Bundle,Parent Item,Parent Item
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Brokerage,Brokerage
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please create purchase receipt or purchase invoice for the item {0},Izradite račun kupovine ili račun za kupovinu stavke {0}
,Product Bundle Balance,Balans proizvoda
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Name cannot be Company,Naziv kompanije ne može biti Kompanija
DocType: Maintenance Visit,Breakdown,Slom
DocType: Inpatient Record,B Negative,B Negativno
DocType: Issue,Response By,Response By
DocType: Purchase Invoice,Credit To,Credit To
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Submit this Work Order for further processing.,Pošaljite ovaj radni nalog za dalju obradu.
DocType: Bank Guarantee,Bank Guarantee Number,Broj bankarske garancije
apps/erpnext/erpnext/templates/pages/material_request_info.html,Delivered: {0},Isporučeno: {0}
DocType: Quality Meeting Table,Under Review,Under Review
apps/erpnext/erpnext/public/js/setup_wizard.js,Agriculture (beta),Poljoprivreda (beta)
,Average Commission Rate,Prosečna provizija
DocType: Sales Invoice,Customer's Purchase Order Date,Datum narudžbenice naručioca
apps/erpnext/erpnext/config/buying.py,All Contacts.,Svi kontakti.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Used Leaves
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field From Shareholder cannot be blank,Polje Iz Dioničara ne može biti prazno
DocType: Brand,Brand Defaults,Default Defaults
DocType: Task,Depends on Tasks,Zavisi od zadataka
DocType: Healthcare Settings,Healthcare Settings,Postavke zdravstvene zaštite
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,{0} Student Groups created.,{0} Stvorene su studentske grupe.
apps/erpnext/erpnext/public/js/hub/marketplace.js,Register,Register
DocType: Woocommerce Settings,"This warehouse will be used to create Sale Orders. The fallback warehouse is ""Stores"".",Ovo skladište će se koristiti za kreiranje prodajnih naloga. Skladište je &quot;Stores&quot;.
DocType: Vehicle Service,Oil Change,Promjena ulja
DocType: Project User,Project User,Korisnik projekta
DocType: Course,Assessment,Procjena
DocType: Promotional Scheme,Price Discount Slabs,Ploče s popustom za cijene
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,New Customers,Novi klijenti
DocType: Project,Total Expense Claim (via Expense Claims),Ukupni iznos potraživanja (putem potraživanja od rashoda)
DocType: Instructor Log,Other Details,Ostali detalji
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 dionica. Napravite novu stavku i prenesite zalihe u novu stavku
DocType: Employee Attendance Tool,Employees HTML,Zaposleni HTML
DocType: Leave Block List,Stop users from making Leave Applications on following days.,Zaustavite korisnike da ne puštaju aplikacije u narednim danima.
DocType: Budget,Ignore,Ignoriraj
,Sales Person Target Variance Based On Item Group,Prodajno lice ciljno odstupanje na osnovu grupe proizvoda
DocType: Education Settings,Current Academic Year,Trenutna akademska godina
DocType: Bank Statement Transaction Entry,Submit/Reconcile Payments,Slanje / Usklađivanje plaćanja
DocType: Purchase Invoice,Set Advances and Allocate (FIFO),Postavite prednosti i dodijelite (FIFO)
DocType: BOM,Item to be manufactured or repacked,Proizvod koji će se proizvoditi ili prepakirati
apps/erpnext/erpnext/accounts/page/pos/pos.js,New Cart,New Cart
DocType: Purchase Receipt,MAT-PRE-.YYYY.-,MAT-PRE-.YYYY.-
apps/erpnext/erpnext/stock/doctype/item/item.py,Please select Sample Retention Warehouse in Stock Settings first,Prvo izaberite Skladište uzorka zadržavanja u postavkama zaliha
DocType: Lab Test Template,Result Format,Format rezultata
DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,Glave (ili grupe) protiv kojih se sastavljaju računovodstveni unosi i bilanci se održavaju.
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Zahtjev za materijal koji se koristi za unos ove dionice
DocType: Request for Quotation,Link to material requests,Veza na materijalne zahtjeve
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Unsecured Loans,Unsecured Loans
apps/erpnext/erpnext/public/js/event.js,Add Customers,Dodaj klijente
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Default Skladište gotovih proizvoda
DocType: Grant Application,Grant Description,Grant Description
apps/erpnext/erpnext/stock/doctype/item/item.js,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Navedite i težinu, Molimo vas da navedete i &quot;Težina UOM&quot;"
apps/erpnext/erpnext/accounts/party.py,{0} {1} is disabled,{0} {1} je onemogućeno
DocType: Contract,Contract Period,Period ugovora
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js,Please enter Item Code to get Batch Number,Molimo unesite šifru artikla da dobijete serijski broj
DocType: Cash Flow Mapping,Is Working Capital,Je li radni kapital
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 ga u Postavke isporuke.
DocType: Packing Slip,MAT-PAC-.YYYY.-,MAT-PAC-.YYYY.-
DocType: Supplier Scorecard,"Scorecard variables can be used, as well as:
{total_score} (the total score from that period),
{period_number} (the number of periods to present day)
","Mogu se koristiti varijable indeksa, kao i: {total_score} (ukupni rezultat iz tog perioda), {period_number} (broj perioda do danas)"
apps/erpnext/erpnext/public/js/stock_analytics.js,Value Or Qty,Vrijednost ili broj
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 vas da registrujete SIREN broj u datoteci s informacijama o kompaniji
DocType: Amazon MWS Settings,Check this to enable a scheduled Daily synchronization routine via scheduler,Označite ovo da biste omogućili planiranu dnevnu rutinu sinkronizacije preko rasporeda
DocType: Employee Tax Exemption Declaration,Declarations,Deklaracije
DocType: Manufacturing Settings,Backflush Raw Materials Based On,BackFlush sirovine na bazi
DocType: Cheque Print Template,Distance from top edge,Udaljenost od gornje ivice
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Job Description,Opis posla
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"Can not filter based on Voucher No, if grouped by Voucher","Ne može se filtrirati na osnovu No vaučera, ako je grupisano po vaučeru"
DocType: Purchase Receipt Item,Received and Accepted,Primljeno i prihvaćeno
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Negative Valuation Rate is not allowed,Negativna stopa procene nije dozvoljena
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, stavki i prodajnih naloga. Ovaj korisnik treba da ima odgovarajuće dozvole."
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Purchase Order,Napravite narudžbenicu
apps/erpnext/erpnext/config/accounting.py,Define budget for a financial year.,Definišite budžet za finansijsku godinu.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Accounts table cannot be blank.,Tabela računa ne može biti prazna.
DocType: Employee Checkin,Entry Grace Period Consequence,Posledica ulaska u Grace period
,Payment Period Based On Invoice Date,Period plaćanja na osnovu datuma fakture
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Installation date cannot be before delivery date for Item {0},Datum instalacije ne može biti prije datuma isporuke za stavku {0}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Link to Material Request,Veza na Zahtjev materijala
DocType: Warranty Claim,From Company,From Company
DocType: Bank Statement Transaction Settings Item,Mapped Data Type,Mapirani tip podataka
apps/erpnext/erpnext/stock/doctype/item/item.py,Row {0}: An Reorder entry already exists for this warehouse {1},Red {0}: stavka za promjenu redoslijeda već postoji za ovo skladište {1}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Date,Datum
DocType: Monthly Distribution,Distribution Name,Naziv distribucije
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Workday {0} has been repeated.,Radni dan {0} je ponovljen.
apps/erpnext/erpnext/accounts/doctype/account/account.js,Group to Non-Group,Grupa u grupi koja nije grupa
apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Ažuriranje je u toku. Može potrajati.
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 je serija postavljena i serijski broj se ne spominje u transakcijama, automatski će se kreirati serijski broj na temelju ove serije. Ako uvijek želite eksplicitno spomenuti serijske brojeve za ovu stavku. ostavite ovo prazno."
DocType: Stock Entry,Stock Entry (Outward GIT),Unos akcija (Outward GIT)
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Party Addresses,Obrađuje adrese adresa
DocType: Selling Settings,Delivery Note Required,Obavezna isporuka
DocType: Pricing Rule,Sales Partner,Prodajni partner
DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Računovodstveni unos je zamrznut do ovog datuma, niko ne može / ne mijenja unos osim uloge navedene u nastavku."
DocType: Vehicle Log,Fuel Qty,Količina goriva
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Mobile No,Guardian1 Mobile No
DocType: Invoice Discounting,Disbursed,Isplaceno
DocType: Shift Type,Time after the end of shift during which check-out is considered for attendance.,Vrijeme nakon završetka smjene tijekom kojeg se smatra da je check-out prisutan.
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Accounts Payable,Neto promjena na računima
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Not Available,Nije dostupno
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Part-time,Pola radnog vremena
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Delivery,Dostava
DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Tečaj za kreiranje alatki za studentske grupe
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be greater than unadjusted amount,Dodijeljeni iznos ne može biti veći od neusklađenog iznosa
DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Distributer / distributer / treće lice / komisionar / partner / prodavač koji prodaje proizvode kompanije za proviziju.
DocType: BOM Item,Original Item,Original Item
apps/erpnext/erpnext/buying/doctype/supplier/supplier.py,Series is mandatory,Serija je obavezna
apps/erpnext/erpnext/config/crm.py,Potential opportunities for selling.,Potencijalne mogućnosti za prodaju.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show PDC in Print,Prikaži PDC u ispisu
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/sync_product.py,Shopify Supplier,Shopify Supplier
DocType: POS Profile User,POS Profile User,Korisnik POS profila
DocType: Sales Person,Sales Person Name,Ime prodavača
DocType: Packing Slip,Gross Weight,Bruto težina
DocType: Journal Entry,Bill No,Bill No
apps/erpnext/erpnext/assets/doctype/location/location_tree.js,New Location,New Location
,Project wise Stock Tracking,Project wise Stock Tracking
DocType: Vehicle Log,HR-VLOG-.YYYY.-,HR-VLOG-.YYYY.- \ t
DocType: Student,A+,A +
DocType: Issue,Service Level Agreement,Ugovor o nivou usluge
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Item valuation rate is recalculated considering landed cost voucher amount,Stopa vrednovanja pozicije se preračunava uzimajući u obzir iznos vaučera za zemljišne troškove
DocType: Timesheet,Employee Detail,Detalji o zaposlenima
DocType: Tally Migration,Vouchers,Vaučeri
DocType: Student,Guardian Details,Guardian Details
DocType: Shopify Settings,eg: frappe.myshopify.com,npr .: frappe.myshopify.com
apps/erpnext/erpnext/crm/doctype/lead/lead.py,"Email Address must be unique, already exists for {0}","Adresa e-pošte mora biti jedinstvena, već postoji za {0}"
apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Uskladite plaćanja sa fakturama
DocType: Holiday List,Weekly Off,Weekly Off
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Nije dozvoljeno postaviti alternativnu stavku za stavku {0}
apps/erpnext/erpnext/www/lms/program.py,Program {0} does not exist.,Program {0} ne postoji.
apps/erpnext/erpnext/hr/doctype/department/department.js,You cannot edit root node.,Ne možete uređivati korijenski čvor.
DocType: Fee Schedule,Student Category,Kategorija učenika
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Item {0}: {1} qty produced, ","Stavka {0}: {1} proizvedena količina,"
DocType: Identification Document Type,Identification Document Type,Vrsta identifikacijskog dokumenta
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Insufficient Stock,Nedovoljna zaliha
apps/erpnext/erpnext/controllers/selling_controller.py,Row {0}: Conversion Factor is mandatory,Red {0}: faktor konverzije je obavezan
DocType: Buying Settings,Purchase Receipt Required,Potrebna potvrda o kupnji
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM Rate
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! The check digit validation has failed. ,Nevažeći GSTIN! Provjera provjere znamenke nije uspjela.
DocType: HR Settings,Max working hours against Timesheet,Maksimalno radno vreme protiv vremenskog rasporeda
DocType: HR Settings,Include holidays in Total no. of Working Days,Uključite praznike u Ukupno br. radnih dana
DocType: Quality Meeting,Quality Meeting,Quality Meeting
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consulting,Consulting
DocType: Payment Gateway Account,Default Payment Request Message,Default Message Request Message
DocType: GST Settings,GSTIN Email Sent On,GSTIN Email Sent On
DocType: Amazon MWS Settings,Enable Scheduled Synch,Omogući Scheduled Synch
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Please select Employee,Molimo odaberite zaposlenika
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, klijent će biti kreiran, mapiran u Patient. Računi pacijenta će biti kreirani protiv ovog klijenta. Takođe možete odabrati postojećeg klijenta prilikom kreiranja pacijenta."
DocType: Fiscal Year,Stock User,Stock User
apps/erpnext/erpnext/config/support.py,Service Level Agreement.,Ugovor o nivou usluge.
DocType: Additional Salary,Date on which this component is applied,Datum na koji se primjenjuje ova komponenta
apps/erpnext/erpnext/config/accounting.py,List of available Shareholders with folio numbers,Spisak dostupnih akcionara sa brojevima brojeva
apps/erpnext/erpnext/config/accounting.py,Setup Gateway accounts.,Podešavanje Gateway naloga.
DocType: Service Level Priority,Response Time Period,Period odgovora
DocType: Purchase Invoice,Purchase Taxes and Charges,Porezi i naknade za kupovinu
DocType: Course Activity,Activity Date,Datum aktivnosti
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select or add new customer,Izaberite ili dodajte novog kupca
DocType: Contract,Unfulfilled,Neispunjeno
apps/erpnext/erpnext/templates/pages/home.html,Read blog,Pročitajte blog
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Value,Vrijednost projekta
DocType: Task,Expected Time (in hours),Očekivano vrijeme (u satima)
apps/erpnext/erpnext/stock/doctype/item/item.py,Updating Variants...,Ažuriranje varijanti ...
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Sales Person in Print,Prikaži prodajnu osobu u štampi
DocType: Supplier Scorecard,Per Year,Godišnje
DocType: Inpatient Record,Admitted Datetime,Prihvaćeni Datetime
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Template is mandatory.,Šablon poreza je obavezan.
DocType: Clinical Procedure,Patient,Pacijent
DocType: Timesheet Detail,Costing Amount,Iznos troškova
apps/erpnext/erpnext/stock/doctype/item/item.js,Add / Edit Prices,Dodaj / uredi cijene
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non-GST outward supplies,Ne-GST vanjske zalihe
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0}: From time must be less than to time,Red {0}: Od vremena mora biti manje od vremena
apps/erpnext/erpnext/hr/doctype/employee/employee.py,User {0} is already assigned to Employee {1},Korisnik {0} je već dodijeljen zaposleniku {1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Form View,Form View
DocType: Supplier Quotation,Auto Repeat Section,Odeljak za automatsko ponavljanje
DocType: Sales Person,Select company name first.,Najprije odaberite naziv tvrtke.
apps/erpnext/erpnext/public/js/setup_wizard.js,Financial Year,Finansijska godina
DocType: Sales Invoice Item,Deferred Revenue,Odloženi prihod
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Atleast one of the Selling or Buying must be selected,"U svakom slučaju, mora se odabrati jedna od prodaja ili kupovina"
DocType: Shift Type,Working Hours Threshold for Half Day,Prag rada za pola dana
,Item-wise Purchase History,Povijest nabavke
apps/erpnext/erpnext/accounts/deferred_revenue.py,Cannot change Service Stop Date for item in row {0},Nije moguće promijeniti Service Stop Date za stavku u retku {0}
DocType: Production Plan,Include Subcontracted Items,Uključite stavke podugovora
DocType: Salary Structure,Max Benefits (Amount),Maksimalne pogodnosti (iznos)
DocType: Homepage,Hero Section,Hero Section
apps/erpnext/erpnext/config/manufacturing.py,Where manufacturing operations are carried.,Tamo gdje se obavljaju proizvodne operacije.
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Dispatch Notification,Dispatch Notification
DocType: Projects Settings,Timesheets,Timesheets
DocType: Purchase Receipt,Get current stock,Nabavite trenutne zalihe
DocType: Account,Expense,Expense
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,{0} asset cannot be transferred,Ne može se prenijeti {0} sredstvo
,Unpaid Expense Claim,Neplaćeni zahtev za troškove
DocType: Employee,Family Background,Porodična pozadina
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py,Bonus Payment Date cannot be a past date,Datum isplate bonusa ne može biti prošli datum
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,No {0} found for Inter Company Transactions.,Nije pronađeno {0} za transakcije između kompanija.
DocType: Bank Account,Party Type,Party Type
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Finish,Završi
DocType: Sales Invoice,C-Form Applicable,C-Obrazac se primjenjuje
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 dugu, nije vam dozvoljeno da postavite &quot;Stanje mora biti&quot; kao &quot;Kredit&quot;"
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Qty increased by 1,Red # {0}: Količina povećana za 1
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Postavite ciljeve Stavka Grupno za ovu prodajnu osobu.
DocType: Asset Repair,ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-
DocType: Student,Student Mobile Number,Broj mobilnog studenta
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Academic Year: ,Akademska godina:
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 za kupovinu ako je potrebna narudžbenica == &#39;DA&#39;, onda za kreiranje fakture kupovine, korisnik treba da kreira narudžbenicu za stavku {0}"
DocType: Shipping Rule Condition,To Value,Cijeniti
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Please add the account to root level Company - ,Dodajte nalog na korijenski nivo Preduzeće -
DocType: Asset Settings,Number of Days in Fiscal Year,Broj dana u fiskalnoj godini
DocType: Journal Entry,Total Amount Currency,Valuta ukupnog iznosa
DocType: BOM,Allow Same Item Multiple Times,Dozvoli istu stavku više puta
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create BOM,Napravite BOM
DocType: Healthcare Practitioner,Charges,Charges
DocType: Employee,Attendance and Leave Details,Pohađanje i ostavljanje detalja
DocType: Student,Personal Details,Lični podaci
DocType: Sales Order,Billing and Delivery Status,Status naplate i isporuke
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 potrebna za slanje e-pošte
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Investing,Novčani tok od ulaganja
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Approving Role cannot be same as role the rule is Applicable To,Uloga odobravanja ne može biti ista kao uloga za koju se primenjuje pravilo
DocType: Crop,Crop Spacing,Crop Spacing
DocType: Selling Settings,How often should project and company be updated based on Sales Transactions.,Koliko često treba da se ažuriraju projekti i kompanije na osnovu transakcija prodaje.
DocType: Pricing Rule,Period Settings,Podešavanja perioda
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Accounts Receivable,Neto promjena potraživanja
DocType: Quality Feedback Template,Quality Feedback Template,Šablon kvalitete povratnih informacija
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Quantity must be greater than zero,Za količinu mora biti veća od nule
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čunatog iznosa"
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Ostavite prazno ako napravite grupe studenata godišnje
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Loans (Liabilities),Krediti (obaveze)
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js,Send Grant Review Email,Pošalji e-poruku za pregled Grant-a
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,GSTR3B-Form,GSTR3B-Form
DocType: Production Plan Item,Produced Qty,Proizveden kom
DocType: Bank Statement Transaction Invoice Item,Journal Entry,Unos časopisa
DocType: Stock Entry,Purchase Receipt No,Potvrda o kupnji br
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 datuma pridruživanja zaposlenika {1}
DocType: Journal Entry,Debit Note,Debit Note
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Da li je ovaj porez uključen u osnovnu stopu?
DocType: Share Balance,Purchased,Kupljen
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,Stopa po kojoj se valuta cjenika pretvara u osnovnu valutu kompanije
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,View Fees Records,Pogledajte evidenciju naknada
DocType: Training Event,Theory,Teorija
apps/erpnext/erpnext/utilities/activation.py,Create Quotation,Napravite ponudu
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}: Unos dnevnika {1} nema nalog {2} ili se već podudara sa drugim vaučerima
apps/erpnext/erpnext/accounts/page/pos/pos.js,Create a new Customer,Kreirajte novog korisnika
DocType: BOM Website Operation,BOM Website Operation,BOM Web stranica
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Detalji fakture / unosa dnevnika
DocType: Share Balance,Share Balance,Share Balance
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Period Closing Entry,Unos za zatvaranje perioda
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,Purchase Price List,Cjenik kupnje
DocType: Contract,Party User,Party User
DocType: Restaurant Order Entry,Restaurant Order Entry,Restaurant Order Entry
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serijalizirana stavka {0} ne može se ažurirati pomoću usklađivanja zaliha, molimo koristite unos dionica"
DocType: Practitioner Schedule,Time Slots,Time Slots
apps/erpnext/erpnext/stock/doctype/item/item.js,Select at least one value from each of the attributes.,Odaberite najmanje jednu vrijednost iz svakog od atributa.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Bank Draft,Bank Draft
DocType: Email Digest,Send regular summary reports via Email.,Slanje redovnih zbirnih izvještaja putem e-pošte.
DocType: Quality Procedure Table,Step,Korak
DocType: Normal Test Items,Result Value,Vrijednost rezultata
DocType: Cash Flow Mapping,Is Income Tax Liability,Odgovornost za porez na dohodak
DocType: Healthcare Practitioner,Inpatient Visit Charge Item,Stavka za bolničku posjetu
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/templates/emails/training_event.html,Update Response,Ažuriraj odgovor
DocType: Bank Guarantee,Supplier,Dobavljač
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Enter value betweeen {0} and {1},Unesite vrijednost između {0} i {1}
DocType: Purchase Order,Order Confirmation Date,Datum potvrde narudžbe
DocType: Delivery Trip,Calculate Estimated Arrival Times,Izračunajte procijenjeno vrijeme dolaska
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Potrošni
DocType: Instructor,EDU-INS-.YYYY.-,EDU-INS-.YYYY.-
DocType: Subscription,Subscription Start Date,Datum početka pretplate
DocType: Woocommerce Settings,Woocommerce Server URL,URL adresa Woocommerce servera
DocType: Payroll Entry,Number Of Employees,Broj zaposlenih
apps/erpnext/erpnext/regional/india/bank_remittance.py,{0} field is limited to size {1},Polje {0} je ograničeno na veličinu {1}
apps/erpnext/erpnext/education/utils.py,This {0} conflicts with {1} for {2} {3},Ovaj {0} je u sukobu s {1} za {2} {3}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Value Proposition,Vrednosni predlog
DocType: Purchase Invoice,Contact Email,Kontaktni e-mail
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Cannot set authorization on basis of Discount for {0},Nije moguće postaviti ovlaštenje na temelju Popusta za {0}
DocType: Attendance Request,Work From Home,Rad od kuće
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: From Time and To Time is mandatory.,Red {0}: Od vremena i do vremena je obavezan.
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Supplier Id,Id dobavljača
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Invoice can't be made for zero billing hour,Faktura se ne može izvršiti za nulti sat obračuna
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}","Ostaviti se ne može dodijeliti prije {0}, jer je ravnoteža dopusta već prenesena u evidenciji budućeg izdvajanja za odsustvo {1}"
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Last Order Date,Datum poslednjeg naloga
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Course: ,Kurs:
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Dispatch,Dispatch
DocType: Installation Note Item,Installation Note Item,Napomena za instalaciju Stavka
DocType: Journal Entry Account,Journal Entry Account,Account Entry Account
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant,Variant
apps/erpnext/erpnext/templates/pages/help.html,Forum Activity,Forum Activity
DocType: Service Level Priority,Resolution Time Period,Vremenski period rezolucije
DocType: Request for Quotation,Supplier Detail,Detalje dobavljača
DocType: Project Task,View Task,Prikaži zadatak
DocType: Serial No,Purchase / Manufacture Details,Detalji kupovine / proizvodnje
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Automatski unesite iznos amortizacije imovine
DocType: Work Order Operation,Operation completed for how many finished goods?,Operacija završena za koliko gotovih proizvoda?
DocType: Healthcare Settings,Employee name and designation in print,Ime zaposlenika i oznaka u štampi
DocType: Tally Migration,Is Day Book Data Processed,Obrada podataka o dnevnoj knjizi
DocType: Program,Courses,Kursevi
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 kupovine {0}
DocType: Employee Boarding Activity,Employee Boarding Activity,Aktivnost u službi u službi
apps/erpnext/erpnext/stock/utils.py,Warehouse {0} does not belong to company {1},Skladište {0} ne pripada tvrtki {1}
DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Ako je onemogućeno, polje &#39;U riječima&#39; neće biti vidljivo u bilo kojoj transakciji"
DocType: Payment Entry Reference,Allocated,Dodijeljeno
DocType: Project,Time to send,Vreme je za slanje
DocType: Vital Signs,Bloated,Bloated
DocType: Blanket Order,Order Type,Vrsta narudžbe
DocType: POS Closing Voucher,Period Start Date,Datum početka perioda
DocType: Maintenance Schedule,Generate Schedule,Generate Schedule
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Opening Value,Opening Value
DocType: Additional Salary,Additional Salary,Dodatna plata
DocType: Loan,Repayment Method,Metoda otplate
apps/erpnext/erpnext/config/projects.py,Cost of various activities,Troškovi različitih aktivnosti
DocType: Opportunity,Mins to First Response,Min. Do prvog odgovora
DocType: Patient Appointment,Patient Age,Pacijentsko doba
DocType: Patient Encounter,Investigations,Istrage
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Equipments,Uredska oprema
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full , did not save","LocalStorage je pun, nije spasio"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Items for Raw Material Request,Stavke za zahtjev za sirovinu
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Select Item (optional),Izaberi stavku (opcionalno)
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py,Parent Item {0} must not be a Stock Item,Roditeljska stavka {0} ne smije biti dionica
DocType: Stock Entry Detail,Against Stock Entry,Against Stock Entry
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Fetch exploded BOM (including sub-assemblies),Dohvatite eksplodiranu sastavnicu (uključujući podsklopove)
DocType: Sales Invoice,ACC-SINV-.YYYY.-,ACC-SINV-.YYYY.-
DocType: Loan,Loan Application,Zahtjev za kredit
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Job Card,Za Job Card
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Master Data,Glavni podaci procesa
DocType: Cheque Print Template,Is Account Payable,Je li dugovanje na računu
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Total Order Value,Ukupna vrijednost narudžbe
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,Supplier {0} not found in {1},Dobavljač {0} nije pronađen u {1}
apps/erpnext/erpnext/config/settings.py,Setup SMS gateway settings,Postavite postavke SMS gateway-a
DocType: Salary Component,Round to the Nearest Integer,Zaokružite se na Najbliži Integer
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Root cannot have a parent cost center,Root ne može imati matično mjesto troška
DocType: Healthcare Service Unit,Allow Appointments,Dozvoli sastanke
DocType: BOM,Show Operations,Prikaži operacije
DocType: Practitioner Schedule,Practitioner Schedule,Raspored praktičara
DocType: Asset Maintenance Task,Calibration,Kalibracija
DocType: Pricing Rule,Apply On,Apply On
apps/erpnext/erpnext/config/accounting.py,Close Balance Sheet and book Profit or Loss.,Zatvorite bilans stanja i rezervišite dobit ili gubitak.
DocType: Employee,Provide Email Address registered in company,Navedite adresu e-pošte registrovanu u kompaniji
DocType: Item Alternative,Alternative Item Name,Alternativni naziv predmeta
DocType: Assessment Plan,Course,Kurs
DocType: Patient,Patient Details,Detalji o pacijentu
DocType: Employee Separation,Employee Separation,Separacija zaposlenika
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Debtors,Dužnici
DocType: Bank Statement Settings,Mapped Items,Mapped Items
DocType: Leave Control Panel,Department (optional),Odjel (opcionalno)
DocType: Task Type,Task Type,Task Type
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Debit A/C Number,Debitni A / C broj
DocType: Timesheet,Total Billed Amount,Ukupan fakturisani iznos
apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Datum / referentni datum ne može biti nakon {0}
DocType: Leave Allocation,Add unused leaves from previous allocations,Dodajte neiskorištene listove iz prethodnih alokacija
DocType: Employee Transfer,New Company,New Company
DocType: Sales Invoice,Commission Rate (%),Stopa provizije (%)
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Skladište se može mijenjati samo putem ulaska / isporuke dionica / potvrde o kupnji
DocType: Support Settings,Close Issue After Days,Zatvori pitanje posle dana
DocType: Payment Schedule,Payment Schedule,Raspored plaćanja
DocType: Shift Type,Enable Entry Grace Period,Omogući početni period ulaska
DocType: Patient Relation,Spouse,Supružnik
DocType: Purchase Invoice,Reason For Putting On Hold,Razlog za stavljanje na čekanje
DocType: Item Attribute,Increment,Povećanje
DocType: Vital Signs,Cuts,Cuts
DocType: Student Applicant,LMS Only,Samo LMS
DocType: Shopping Cart Settings,Show Contact Us Button,Prikaži gumb Kontakt
apps/erpnext/erpnext/public/js/event.js,Add Employees,Add Employees
DocType: Holiday List,Holidays,Odmor
DocType: Chapter,Chapter Head,Chapter Head
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Not permitted. Please disable the Test Template,Nije dozvoljeno. Isključite testni predložak
DocType: Restaurant Reservation,No Show,No Show
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Selling Amount,Iznos prodaje
DocType: Amazon MWS Settings,AWS Access Key ID,ID ključa za pristup AWS
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py,{0} {1} is not present in the parent company,{0} {1} nije prisutan u matičnoj kompaniji
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,To Date cannot be before From Date,Do datuma ne može biti prije datuma
apps/erpnext/erpnext/public/js/event.js,Add Suppliers,Dodaj dobavljače
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Summary for this month and pending activities,Sažetak za ovaj mjesec i aktivnosti na čekanju
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Mode of Transport,Način transporta
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Bruto plata - ukupni odbitak - otplata kredita
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Datum knjiženja ne može biti datum u budućnosti
,Work Order Stock Report,Izveštaj o stanju radnog naloga
apps/erpnext/erpnext/config/accounting.py,Enable / disable currencies.,Omogućite / onemogućite valute.
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,View in Cart,Prikaži u košarici
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Fetch based on FIFO,Fetch na osnovu FIFO-a
DocType: Timesheet,Total Billable Amount,Ukupan iznos za naplatu
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 materijala od maksimalno {0} može se napraviti za stavku {1} protiv prodajnog naloga {2}
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js,Production Item,Proizvodna stavka
DocType: Share Transfer,Equity/Liability Account,Račun vlasništva / odgovornosti
apps/erpnext/erpnext/www/all-products/index.html,No values,Nema vrijednosti
apps/erpnext/erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py,Cancel the journal entry {0} first,Prvo poništite stavku dnevnika {0}
DocType: GL Entry,Remarks,Napomene
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Supplier must be debit,Red {0}: avans protiv dobavljača mora biti zadužen
DocType: Student Report Generation Tool,Attended by Parents,Prisustvovali su roditelji
DocType: POS Profile,Update Stock,Update Stock
DocType: Account,Old Parent,Old Parent
DocType: Production Plan,Download Materials Required,Potreban materijal za preuzimanje
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Another Period Closing Entry {0} has been made after {1},Drugi unos zatvaranja perioda {0} je izvršen nakon {1}
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,Item Template,Predložak predmeta
DocType: Purchase Invoice Item,Discount on Price List Rate (%),Popust na cijenu popisa (%)
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Skraćenica je obavezna
DocType: Travel Request,Domestic,Domaći
apps/erpnext/erpnext/selling/report/pending_so_items_for_purchase_request/pending_so_items_for_purchase_request.py,SO Qty,SO Qty
DocType: Program Enrollment,Pick/Drop by Guardian,Pick / Drop by Guardian
DocType: Exchange Rate Revaluation Account,Balance In Base Currency,Stanje u osnovnoj valuti
apps/erpnext/erpnext/config/buying.py,All Products or Services.,Svi proizvodi ili usluge.
DocType: Vehicle Service,Brake Pad,Brake Pad
DocType: Pricing Rule,Max Amt,Max Amt
DocType: Shopping Cart Settings,Show Stock Availability,Show Stock Availability
DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,Cijene hotelskih soba
DocType: Project Task,Pending Review,Pending Review
DocType: Employee,Date of Joining,Datum pridruživanja
DocType: Patient,Patient Relation,Odnos pacijenta
DocType: Currency Exchange,For Selling,Za prodaju
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Financing,Novčani tok iz finansiranja
DocType: Blanket Order,Manufacturing,Proizvodnja
apps/erpnext/erpnext/templates/pages/home.html,By {0},Do {0}
DocType: Restaurant Menu,Restaurant Manager,Manager restorana
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Out Value,Out Value
DocType: Volunteer,Availability and Skills,Dostupnost i vještine
DocType: Employee Advance,Advance Account,Advance Account
DocType: GSTR 3B Report,Invoices with no Place Of Supply,Fakture bez mesta snabdevanja
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Ref,Ref
DocType: Invoice Discounting,Loan End Date,Datum završetka kredita
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 redu {0} ({1}) mora biti ista kao proizvedena količina {2}
apps/erpnext/erpnext/utilities/user_progress_utils.py,Commercial,Komercijalno
DocType: Salary Slip,Bank Account No.,Bankovni račun
apps/erpnext/erpnext/controllers/taxes_and_totals.py,Advance amount cannot be greater than {0} {1},Iznos avansa ne može biti veći od {0} {1}
DocType: Cheque Print Template,Width of amount in word,Širina iznosa u riječi
DocType: Delivery Note,MAT-DN-.YYYY.-,MAT-DN-.YYYY.-
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign Salary Structure,Dodeli strukturu plata
DocType: Stock Entry,Stock Entry Type,Vrsta unosa zaliha
DocType: Quality Action Table,Responsible,Odgovoran
DocType: Room,Room Number,Broj sobe
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Fiscal Year...,Odaberite fiskalnu godinu ...
,Trial Balance,Trial Balance
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Employee Transfer cannot be submitted before Transfer Date ,Prenos zaposlenika ne može se podnijeti prije datuma prijenosa
DocType: Grading Scale,Grading Scale Name,Naziv skale za ocjenjivanje
DocType: Location,Area UOM,Područje UOM
DocType: Timesheet,Total Costing Amount,Ukupni iznos troškova
DocType: Material Request Plan Item,Material Issue,Izdavanje materijala
DocType: BOM,Item Image (if not slideshow),Slika stavke (ako nije slideshow)
DocType: Share Balance,Is Company,Is Company
DocType: BOM Update Tool,Update latest price in all BOMs,Ažurirajte najnoviju cijenu u svim sastavnicama
DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Poruke veće od 160 znakova bit će podijeljene u više poruka
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Salary Slip submitted for period from {0} to {1},Isplata zarade poslata za period od {0} do {1}
apps/erpnext/erpnext/controllers/trends.py,Project-wise data is not available for Quotation,Podaci o projektu nisu dostupni za ponudu
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py,Total Outstanding Amt,Total Outstanding Amt
DocType: Purchase Invoice Item,Item Tax Rate,Stopa poreza
DocType: Sales Order Item,Planned Quantity,Planirana količina
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Retention Stock Entry,Retention Stock Entry
DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,In Words (Izvoz) će biti vidljiv kada sačuvate Napomena o isporuci.
DocType: Selling Settings,Each Transaction,Svaka transakcija
DocType: Program Enrollment,Institute's Bus,Autobuski institut
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select the Company first,Prvo izaberite kompaniju
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Attendance for employee {0} is already marked for this day,Pohađanje zaposlenika {0} već je označeno za ovaj dan
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,Opening,Otvaranje
DocType: Crop Cycle,Detected Disease,Detected Disease
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) ne može biti veći od planirane količine ({2}) u proizvodnom nalogu {3}
DocType: Stock Ledger Entry,Stock Queue (FIFO),Red čekanja (FIFO)
apps/erpnext/erpnext/controllers/buying_controller.py,Please enter 'Is Subcontracted' as Yes or No,Molimo vas da unesete &#39;Da li je podugovor&#39; kao Da ili Ne
DocType: Company,Default Holiday List,Default Holiday List
DocType: Naming Series,Current Value,Trenutna vrijednost
apps/erpnext/erpnext/config/accounting.py,"Seasonality for setting budgets, targets etc.","Sezonski za postavljanje budžeta, ciljeva itd."
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Upozorenje: prodajni nalog {0} već postoji protiv narudžbenice kupca {1}
apps/erpnext/erpnext/utilities/user_progress.py,Monthly Sales Target (,Mjesečni cilj prodaje (
DocType: Guardian,Guardian Interests,Guardian Interests
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Batch ID is mandatory,ID serije je obavezan
DocType: Item,Allow over delivery or receipt upto this percent,Dozvolite više isporuke ili prijema do ovog procenta
DocType: Payment Entry,Paid Amount (Company Currency),Plaćeni iznos (valuta kompanije)
DocType: Shipping Rule Condition,Shipping Rule Condition,Stanje pravila otpreme
DocType: Employee Boarding Activity,Required for Employee Creation,Potrebno za kreiranje zaposlenika
DocType: Loyalty Point Entry Redemption,Loyalty Point Entry Redemption,Otkup ulazne tačke lojalnosti
DocType: Job Applicant,Cover Letter,Cover Letter
DocType: Chart of Accounts Importer,Chart Preview,Prikaz karte
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Parametar za provjeru kvalitete proizvoda
DocType: Support Settings,Get Started Sections,Započnite sekcije
DocType: Delivery Note,% of materials delivered against this Delivery Note,% materijala isporučenih uz ovu dostavnicu
DocType: Warranty Claim,Warranty / AMC Status,Status garancije / AMC-a
apps/erpnext/erpnext/utilities/user_progress.py,Gram,Gram
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be negative,Dodijeljeni iznos ne može biti negativan
DocType: POS Profile,Item Groups,Grupe predmeta
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Customer LPO No.,Korisnički LPO broj
,Company Name,Ime kompanije
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 1,Na adresu 1
,Purchase Receipt Trends,Trendovi kupovine računa
DocType: Leave Block List,Leave Block List Dates,Ostavite datum blok-liste
apps/erpnext/erpnext/education/doctype/student/student.py,Student {0} exist against student applicant {1},Student {0} postoji protiv kandidata za studente {1}
DocType: Education Settings,LMS Settings,LMS Settings
apps/erpnext/erpnext/config/settings.py,Titles for print templates e.g. Proforma Invoice.,"Naslovi za predloške za ispis, npr. Proforma faktura."
DocType: Serial No,Delivery Time,Vrijeme dostave
DocType: Loan,Repayment Period in Months,Period otplate u mesecima
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Transporter ID,Transporter ID
apps/erpnext/erpnext/config/buying.py,Price List master.,Cjenovnik Master.
DocType: Department,The first Expense Approver in the list will be set as the default Expense Approver.,Prvi Expense Approver u listi će biti postavljen kao default Expense Approver.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Advertising,Oglašavanje
DocType: Authorization Rule,Customer or Item,Kupac ili artikl
DocType: Vehicle Log,Invoice Ref,Račun Ref
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,C-form is not applicable for Invoice: {0},C-obrazac nije primjenjiv za fakturu: {0}
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Invoice Created,Račun je izrađen
DocType: Shift Type,Early Exit Grace Period,Rani izlazak Grace Period
DocType: Patient Encounter,Review Details,Detalji pregleda
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: Hours value must be greater than zero.,Red {0}: Vrijednost sata mora biti veća od nule.
DocType: Account,Account Number,Broj računa
DocType: Assessment Result Detail,Assessment Result Detail,Detaljan rezultat procjene
apps/erpnext/erpnext/controllers/status_updater.py,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.","Da biste dozvolili over-billing ili over-ordering, ažurirajte &quot;Allowance&quot; u Stock Settings ili Item."
DocType: Support Settings,Auto close Issue after 7 days,Automatsko zatvaranje Izdavanje nakon 7 dana
DocType: Supplier,Is Frozen,Is Frozen
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Total weightage assigned should be 100%. It is {0},Ukupna dodeljena težina treba da bude 100%. To je {0}
apps/erpnext/erpnext/regional/italy/setup.py,"Applicable if the company is SpA, SApA or SRL","Primjenjivo ako je tvrtka SpA, SApA ili SRL"
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Overlapping conditions found between:,Uslovi preklapanja pronađeni između:
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Paid and Not Delivered,Plaćeno i nije isporučeno
DocType: GST HSN Code,HSN Code,HSN kod
DocType: GSTR 3B Report,September,Septembar
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Administrative Expenses,Administrativni troškovi
DocType: C-Form,C-Form No,C-Obrazac br
DocType: Purchase Invoice,End date of current invoice's period,Datum završetka perioda tekuće fakture
DocType: Item,Manufacturers,Proizvođači
DocType: Crop Cycle,Crop Cycle,Crop Cycle
DocType: Serial No,Creation Time,Vreme stvaranja
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Molimo vas da unesete uloga za odobravanje ili korisnika odobrenja
DocType: Inpatient Record,Discharged,Ispušten
DocType: BOM,Raw Material Cost(Company Currency),Troškovi sirovine (valuta kompanije)
apps/erpnext/erpnext/accounts/party.py,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Napomena: Datum / referentni datum premašuje dozvoljene kreditne dane klijenta do {0} dana (a)
DocType: Email Digest,New Sales Orders,New Sales Orders
apps/erpnext/erpnext/buying/report/purchase_analytics/purchase_analytics.js,based_on,based_on
DocType: Employee,Owned,Owned
DocType: Item Default,Item Default,Item Default
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Party can only be one of ,Partija može biti samo jedna
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Entertainment Expenses,Troškovi zabave
DocType: Item,Inspection Required before Delivery,Potrebna inspekcija prije isporuke
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py,Opening Entry Journal,Otvaranje dnevnika upisa
DocType: Purchase Taxes and Charges,Add or Deduct,Dodaj ili oduzmi
DocType: POS Closing Voucher Details,Collected Amount,Prikupljeni iznos
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Commission on Sales,Komisija za prodaju
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Start entering data from here : ,Počnite unositi podatke odavde:
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Rest Of The World,Ostatak svijeta
apps/erpnext/erpnext/templates/pages/home.html,Publications,Publikacije
DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Početni bankovni / gotovinski račun će se automatski ažurirati u unosu dnevnika zarada kada se odabere ovaj način rada.
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Ukupni budžet
DocType: Upload Attendance,Upload HTML,Upload HTML
DocType: Bank Reconciliation Detail,Payment Document,Dokument o plaćanju
DocType: Opportunity Item,Opportunity Item,Opportunity Item
DocType: Travel Itinerary,Travel From,Travel From
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,CWIP Account,CWIP račun
DocType: SMS Log,Sender Name,Ime pošiljatelja
DocType: Pricing Rule,Supplier Group,Group dobavljača
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,"Set Start Time and End Time for  \
					Support Day {0} at index {1}.",Postavite Početno vrijeme i Vrijeme završetka za Dan podrške {0} u indeksu {1}.
DocType: Employee,Date of Issue,Datum izdavanja
,Requested Items To Be Transferred,Tražene stavke koje treba prenijeti
DocType: Employee,Contract End Date,Datum završetka ugovora
DocType: Purchase Order Item,Returned Qty,Vraćena količina
DocType: Sales Order,SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-
DocType: Delivery Note,Required only for sample item.,Potrebno samo za uzorak stavke.
DocType: Healthcare Service Unit,Vacant,Vacant
DocType: Opportunity,Sales Stage,Sales Stage
DocType: Sales Order,In Words will be visible once you save the Sales Order.,In Words će biti vidljive kada sačuvate prodajni nalog.
DocType: Item Reorder,Re-order Level,Nivo re-reda
DocType: Shift Type,Enable Auto Attendance,Omogući automatsko pozivanje
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Preference,Preference
,Department Analytics,Department Analytics
DocType: Crop,Scientific Name,Naučno ime
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: Student Guardian,Relation,Odnos
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py,Name or Email is mandatory,Ime ili Email je obavezno
DocType: Tax Rule,Billing Zipcode,Billing Zipcode
apps/erpnext/erpnext/public/js/hub/marketplace.js,Marketplace,Marketplace
apps/erpnext/erpnext/buying/utils.py,{0} {1} status is {2},Status {0} {1} je {2}
DocType: Quiz Activity,Quiz Activity,Quiz Activity
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 periodu isplate
DocType: Timesheet,Billed,Naplaćeno
apps/erpnext/erpnext/config/support.py,Issue Type.,Type Type.
DocType: Restaurant Order Entry,Last Sales Invoice,Posljednja faktura prodaje
DocType: Payment Terms Template,Payment Terms,Uslovi plaćanja
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čena za prodaju, ali ne isporučena."
apps/erpnext/erpnext/accounts/page/pos/pos.js,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2},{0} je obavezno. Možda zapis razmjene valute nije kreiran za {1} do {2}
DocType: Task,Actual End Date (via Time Sheet),Stvarni datum završetka (putem vremenskog lista)
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js,Score must be less than or equal to 5,Rezultat mora biti manji ili jednak 5
apps/erpnext/erpnext/controllers/buying_controller.py,Please select BOM in BOM field for Item {0},Odaberite BOM u polju BOM za stavku {0}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} is under warranty upto {1},Serijski broj {0} je pod garancijom do {1}
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split,Podijeliti
DocType: Bank Account,Bank Account No,Bankovni račun br
DocType: Payroll Entry,Salary Slip Based on Timesheet,Isplata plata na osnovu vremenskog rasporeda
DocType: Program Enrollment,Mode of Transportation,Način transporta
DocType: Budget,Control Action,Kontrolna akcija
DocType: Employee Tax Exemption Declaration,Total Exemption Amount,Ukupan iznos izuzimanja
DocType: Medical Code,Medical Code Standard,Standard medicinskog koda
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Reqd by Date cannot be before Transaction Date,Red # {0}: Reqd by Date ne može biti prije datuma transakcije
DocType: Education Settings,Current Academic Term,Trenutni akademski mandat
DocType: Employee,Short biography for website and other publications.,Kratka biografija za web stranicu i druge publikacije.
DocType: Purchase Invoice Item,Received Qty,Primljeno Kol
DocType: Purchase Invoice Item,Rate (Company Currency),Rate (Valuta kompanije)
DocType: Item Reorder,Request for,Zahtjev za
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Installing presets,Instaliranje preseta
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter Repayment Periods,Unesite Rok otplate
DocType: Pricing Rule,Advanced Settings,Napredne postavke
DocType: Payment Entry,Paid Amount,Plaćeni iznos
DocType: Setup Progress Action,Setup Progress Action,Podešavanje akcije napredovanja
DocType: Subscription Plan,Billing Interval Count,Count Interval Billing
apps/erpnext/erpnext/public/js/financial_statements.js,Financial Statements,Finansijski izvještaji
DocType: Project,Message will sent to users to get their status on the project,Poruka će biti poslata korisnicima kako bi dobili status na projektu
DocType: Employee Tax Exemption Proof Submission Detail,Employee Tax Exemption Proof Submission Detail,Detalji o oslobađanju od plaćanja poreza na zaposlene
DocType: Purchase Order,Delivered,Isporučeno
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Delivered,{0}% Isporučeno
DocType: Lead,Request for Information,Zahtjev za informacijama
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,End Year,Završna godina
DocType: Vehicle,Diesel,Diesel
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankcionirani iznos ne može biti veći od iznosa polaganja prava u redu {0}.
apps/erpnext/erpnext/controllers/buying_controller.py,From {0} | {1} {2},Od {0} | {1} {2}
apps/erpnext/erpnext/education/api.py,Result already Submitted,Rezultat je već poslan
DocType: Pricing Rule Detail,Rule Applied,Primenjeno pravilo
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Actual Qty is mandatory,Stvarna količina je obavezna
DocType: Purchase Order Item,Expected Delivery Date,Očekivani datum isporuke
DocType: Issue,Resolution Date,Datum rezolucije
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave of type {0} cannot be longer than {1},Ostavljanje tipa {0} ne može biti duže od {1}
DocType: Shopping Cart Settings,Enable Shopping Cart,Omogući korpe za kupovinu
DocType: Pricing Rule,Apply Rule On Other,Primijeni pravilo na drugo
DocType: Vehicle,Last Carbon Check,Last Carbon Check
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Make,Make
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Sales Invoice {0} created as paid,Faktura prodaje {0} kreirana kao plaćena
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Za kreiranje zahtjeva za plaćanje je potreban referentni dokument
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Income Tax,Porez na prihod
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Computer,Computer
DocType: Material Request,% Ordered,% Ordered
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 matične stavke
DocType: Quiz,Passing Score,Passing Score
apps/erpnext/erpnext/config/website.py,Settings for website homepage,Postavke za početnu stranicu web lokacije
DocType: Work Order,Qty To Manufacture,Količina za proizvodnju
apps/erpnext/erpnext/public/js/setup_wizard.js,Non Profit (beta),Neprofitna (beta)
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Outstanding Amt,Outstanding Amt
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Pin Code,Pin code
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Dozvolite sledećim korisnicima da odobre ostavljanje aplikacija za blok dana.
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 završetka
DocType: Production Plan,Get Items For Work Order,Nabavite stavke za radni nalog
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Project and all Tasks to status {0}?,Postavite projekat i svi zadaci na status {0}?
DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Prikažite &quot;In Stock&quot; ili &quot;Not in Stock&quot; na osnovu zaliha dostupnih u ovom skladištu.
apps/erpnext/erpnext/accounts/page/pos/pos.js,Delete permanently?,Želite li trajno izbrisati?
DocType: Blanket Order,MFG-BLR-.YYYY.-,MFG-BLR-.YYYY.-
DocType: Leave Type,Is Leave Without Pay,Ostavlja bez plaćanja
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} must be submitted,Red # {0}: Imovina {1} mora biti poslata
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Dodatni iznos popusta (valuta kompanije)
DocType: Patient,Tobacco Past Use,Prethodna upotreba duvana
DocType: Crop,Materials Required,Potrebni materijali
DocType: POS Profile,POS Profile,POS profil
DocType: Journal Entry,Write Off Entry,Write Off Entry
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, sa ulogama Upravitelja sistema i Upravitelja stavki da biste se registrirali na Marketplace-u."
DocType: Asset,Insured value,Osigurana vrijednost
DocType: Quotation Item,Against Docname,Against Docname
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,"As raw materials projected quantity is more than required quantity, there is no need to create material request.
			Still if you want to make material request, kindly enable <b>Ignore Existing Projected Quantity</b> checkbox","Pošto je projektovana količina sirovina veća od potrebne količine, nema potrebe da se kreira materijalni zahtev. Ipak, ako želite napraviti materijalni zahtjev, ljubazno omogućite polje za <b>ignoriranje postojeće predviđene količine</b>"
DocType: Packed Item,Prevdoc DocType,Prevdoc DocType
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,{0} payment entries can not be filtered by {1},{0} unosa za plaćanje ne može se filtrirati do {1}
DocType: Variant Field,Variant Field,Variant Field
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py,Access token or Shopify URL missing,Nedostaje oznaka pristupa ili URL adresa Shopify
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: Terms and Conditions,Terms and Conditions Help,Odredbe i uvjeti Pomoć
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,From and To dates required,Od i do potrebnih datuma
DocType: Production Plan Item,Product Bundle Item,Stavka paketa proizvoda
DocType: Student Group,Group Based On,Na osnovu grupe
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Mobile No,Guardian2 Mobile No
DocType: Manufacturing Settings,Allow Multiple Material Consumption,Dopusti višestruku potrošnju materijala
DocType: Item Quality Inspection Parameter,Acceptance Criteria,Kriteriji prihvatljivosti
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Pravilo o isporuci je primenljivo samo za prodaju
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Selling Rate,Stopa prodaje
DocType: Account,Asset,Asset
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 majstora zdravstvene prakse
DocType: Vehicle,Chassis No,Chassis No
DocType: Employee,Default Shift,Default Shift
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation,Skraćenica kompanije
apps/erpnext/erpnext/config/manufacturing.py,Tree of Bill of Materials,Drvo materijala
DocType: Article,LMS User,LMS User
DocType: BOM,Allow Alternative Item,Dopusti alternativnu stavku
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Troškovi aktivnosti po zaposlenom
DocType: Email Digest,Open Quotations,Open Quotations
DocType: Cash Flow Mapper,Section Footer,Podnožje odeljka
DocType: Lead,Next Contact By,Next Contact By
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Pending Quantity,Pending Quantity
DocType: Quotation,SAL-QTN-.YYYY.-,SAL-QTN-.YYYY.-
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select to add Serial Number.,Izaberite da biste dodali serijski broj.
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html,modified,modifikovan
DocType: Pricing Rule,Qty,Kol
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Neto ITC dostupan (A) - (B)
,Material Requests for which Supplier Quotations are not created,Zahtjevi materijala za koje nisu kreirane ponude dobavljača
DocType: GST Account,GST Account,GST račun
DocType: Pricing Rule,For Price List,Za cenovnik
DocType: GoCardless Mandate,GoCardless Mandate,Mandat GoCardless
DocType: Work Order,Skip Material Transfer to WIP Warehouse,Preskoči transfer materijala u WIP skladište
DocType: Cheque Print Template,Primary Settings,Primary Settings
DocType: Amazon MWS Settings,Customer Type,Tip klijenta
DocType: Supplier Scorecard Period,PU-SSP-.YYYY.-,PU-SSP-.YYYY.-
DocType: POS Settings,Use POS in Offline Mode,Koristite POS u Offline modu
DocType: Territory,Parent Territory,Parent Territory
DocType: Vehicle Log,Odometer Reading,Odometer Reading
DocType: Additional Salary,Salary Slip,Salis Slip
DocType: Payroll Entry,Payroll Frequency,Frekvencija plaćanja
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}","Početni i završni datumi koji nisu u važećem obračunskom periodu, ne mogu izračunati {0}"
DocType: Products Settings,Home Page is Products,Početna stranica je Proizvodi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Calls,Pozivi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference #{0} dated {1},Reference # {0} sa datumom {1}
DocType: Guardian Interest,Guardian Interest,Guardian Interest
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,PO already created for all sales order items,PO je već kreirana za sve stavke prodajnog naloga
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Subscription,Pretplata
DocType: Stock Entry Detail,Stock Entry Detail,Stock Entry Detail
DocType: Email Digest,Sales Orders to Bill,Prodajni nalozi Billu
DocType: Company,For reference only.,Samo za referencu.
DocType: GL Entry,GL Entry,GL Entry
DocType: Employee Tax Exemption Category,Employee Tax Exemption Category,Kategorija za izuzeće od poreza na zaposlene
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Row {0}: asset is required for item {1},Red {0}: sredstvo je potrebno za stavku {1}
DocType: Expense Claim Detail,Sanctioned Amount,Sankcionisani iznos
DocType: Taxable Salary Slab,Taxable Salary Slab,Oporeziva plata plata
DocType: Grant Application,Grant Application,Grant Application
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 počevši od {0}. Potrebno je da imate stalne rezultate koji pokrivaju 0 do 100
DocType: Fee Structure,EDU-FST-.YYYY.-,EDU-FST-.YYYY.- \ t
DocType: Sales Person,Parent Sales Person,Matična prodajna osoba
DocType: Student Group Creation Tool,Get Courses,Get Courses
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 1, jer je stavka fiksno sredstvo. Molimo koristite poseban red za višestruke količine."
DocType: Shift Type,Working hours below which Absent is marked. (Zero to disable),Radno vrijeme ispod kojeg je Absent označen. (Nula do onemogućavanja)
DocType: Customer Group,Only leaf nodes are allowed in transaction,Samo su čvorovi listova dozvoljeni u transakciji
DocType: Grant Application,Organization,Organizacija
DocType: Fee Category,Fee Category,Kategorija naknade
DocType: Batch,Batch ID,ID serije
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot be a fixed asset item as Stock Ledger is created.,Ne može biti fiksna stavka stavke kada je kreirana Stock Ledger.
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,This Month's Summary,Sažetak ovog mjeseca
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: {1} {2} does not match with {3},Red {0}: {1} {2} se ne podudara s {3}
apps/erpnext/erpnext/utilities/user_progress.py,Go to Suppliers,Idi na Dobavljače
DocType: Payment Order,PMO-,PMO-
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: Volunteer,Morning,Jutro
DocType: Quotation Item,Quotation Item,Stavka ponude
apps/erpnext/erpnext/config/support.py,Issue Priority.,Prioritet problema.
DocType: Journal Entry,Credit Card Entry,Unos kreditne kartice
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 razmak je preskočen, slot {0} do {1} preklapa postojeći slot {2} do {3}"
DocType: Journal Entry Account,If Income or Expense,Ako je prihod ili trošak
DocType: Work Order Operation,Work Order Operation,Rad na radnom nalogu
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/utilities/user_progress.py,Go to Customers,Idi na Kupce
DocType: Student Group,Set 0 for no limit,Postavite 0 bez ograničenja
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} is inactive,{0} {1}: Račun {2} je neaktivan
DocType: Repayment Schedule,Payment Date,Datum plaćanja
DocType: Asset Maintenance Task,Assign To Name,Dodeli ime
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Warning: Material Requested Qty is less than Minimum Order Qty,Upozorenje: Traženi materijal je manji od minimalne količine narudžbe
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Current BOM and New BOM can not be same,Trenutni BOM i New BOM ne mogu biti isti
apps/erpnext/erpnext/config/agriculture.py,Crops & Lands,Crops &amp; Lands
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbr can not be blank or space,Abbr ne može biti prazan ili prazan
DocType: Material Request,MAT-MR-.YYYY.-,MAT-MR-.YYYY.-
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot deliver Serial No {0} of item {1} as it is reserved to \
												fullfill Sales Order {2}",Nije moguće isporučiti serijski broj {0} stavke {1} jer je rezerviran za ispunjavanje prodajnog naloga {2}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Fetching records......,Dohvaćanje zapisa ......
DocType: Delivery Stop,Contact Information,Kontakt informacije
DocType: Sales Order Item,For Production,Za proizvodnju
DocType: Serial No,Asset Details,Detalji o imovini
DocType: Restaurant Reservation,Reservation Time,Vreme rezervacije
DocType: Selling Settings,Default Territory,Default Territory
DocType: Employee Benefit Application,Dispensed Amount (Pro-rated),Iznos iznosa (pro-ocijenjeno)
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Max discount allowed for item: {0} is {1}%,Najveći dopušteni popust za stavku: {0} je {1}%
DocType: Product Bundle,List items that form the package.,Popis stavki koje čine paket.
DocType: Payment Request,Amount in customer's currency,Iznos u valuti klijenta
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Nabavite stavke iz kupovine
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0} (Payment Table): Amount must be positive,Red # {0} (Tabela plaćanja): Iznos mora biti pozitivan
DocType: Employee Tax Exemption Declaration,Employee Tax Exemption Declaration,Deklaracija o izuzeću od poreza na zaposlene
DocType: Project,Expected End Date,Očekivani krajnji datum
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Conversion rate cannot be 0 or 1,Stopa konverzije ne može biti 0 ili 1
DocType: Opportunity,CRM-OPP-.YYYY.-,CRM-OPP-.YYYY.-
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Name,Naziv Instituta
DocType: Serial No,Asset Status,Status imovine
DocType: Salary Slip,Earnings,Zarade
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Total Paid Amount,Ukupan uplaćeni iznos
apps/erpnext/erpnext/stock/doctype/batch/batch.js,To Warehouse,To Warehouse
DocType: Appraisal,Total Score (Out of 5),Ukupan rezultat (od 5)
DocType: Journal Entry,Accounts Receivable,Potraživanja
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Setting defaults,Postavljanje zadanih postavki
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.",Nije moguće osigurati isporuku serijskim brojem kao što je stavka {0} dodana sa i bez Osigurati isporuku od
,Invoiced Amount (Exclusive Tax),Iznos fakture (ekskluzivna taksa)
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Cannot change status as student {0} is linked with student application {1},Nije moguće promijeniti status studenta {0} je povezan sa prijavom učenika {1}
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total leaves allocated is mandatory for Leave Type {0},Ukupno dodijeljeno lišće je obavezno za vrstu ostavljanja {0}
apps/erpnext/erpnext/config/getting_started.py,Data Import and Settings,Uvoz podataka i postavke
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 označena opcija Auto Opt In, klijenti će se automatski povezati sa dotičnim programom lojalnosti (ušteda)"
DocType: Account,Expense Account,Račun troškova
DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"Vreme pre početka smene, tokom kojeg se smatra da je zaposlenje Check-in za prisustvo."
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian1,Odnos sa Guardian-om1
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.js,Create Invoice,Napravite fakturu
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Request already exists {0},Zahtjev za plaćanje već postoji {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Employee relieved on {0} must be set as 'Left',Zaposleni oslobođen od {0} mora biti postavljen kao &quot;Lijevo&quot;
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py,Pay {0} {1},Plati {0} {1}
DocType: Company,Sales Settings,Postavke prodaje
DocType: Sales Order Item,Produced Quantity,Proizvedena količina
apps/erpnext/erpnext/templates/emails/request_for_quotation.html,The request for quotation can be accessed by clicking on the following link,Zahtevu za ponudu možete pristupiti klikom na sledeći link
DocType: Monthly Distribution,Name of the Monthly Distribution,Naziv mjesečne distribucije
DocType: Production Plan,Get Raw Materials For Production,Nabavite sirovine za proizvodnju
DocType: Employee,New Workplace,New Workplace
DocType: Support Search Source,API,API
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py,"Missing value for Password, API Key or Shopify URL","Nedostaje vrijednost za lozinku, API ključ ili Shopify URL"
DocType: Supplier Scorecard Scoring Variable,Parameter Name,Naziv parametra
DocType: Request for Quotation,PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py,Account {0} does not match with Company {1},Račun {0} se ne podudara s tvrtkom {1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select an item in the cart,Molimo odaberite stavku u košarici
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Create Payment Entries,Kreirajte unose za plaćanje
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Select Company,Select Company
DocType: Material Request Plan Item,Material Request Type,Vrsta zahtjeva materijala
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Member ID,Member ID
DocType: Issue,Raised By (Email),Povećano od (Email)
DocType: Employee Health Insurance,Employee Health Insurance,Zdravstveno osiguranje zaposlenih
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Application period cannot be outside leave allocation period,Period za podnošenje zahtjeva ne može biti izvan perioda dodjele dopusta
DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Ako nije označena, stavka neće biti prikazana u fakturi prodaje, ali se može koristiti u kreiranju grupnog testa."
DocType: Healthcare Settings,Registration Fee,Kotizaciju
,Produced,Proizvedeno
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,White,White
DocType: Clinical Procedure,Procedure Template,Šablon postupka
DocType: Account,Frozen,Frozen
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Price not found for item {0} in price list {1},Cijena nije nađena za proizvod {0} u cjeniku {1}
DocType: Student Admission,Publish on website,Objavite na web stranici
apps/erpnext/erpnext/portal/doctype/homepage/homepage.py,This is an example website auto-generated from ERPNext,Ovo je primjer web-lokacije koja se automatski generira iz ERPNext-a
DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Isključite plaćanje prilikom otkazivanja fakture
apps/erpnext/erpnext/templates/pages/projects.html,No tasks,Nema zadataka
DocType: Delivery Note,Print Without Amount,Print Without Amount
apps/erpnext/erpnext/config/buying.py,Purchase Orders given to Suppliers.,Narudžbenice za dobavljače.
,Reserved,Reserved
DocType: Employee,Notice (days),Obaveštenje (dana)
apps/erpnext/erpnext/config/help.py,Setting up Email Account,Podešavanje naloga e-pošte
DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
DocType: Contract,Unsigned,Unsigned
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 (a) na koji se prijavljujete za odmor su praznici. Ne trebate podnijeti zahtjev za dopust.
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Could not submit some Salary Slips,Nisam mogao da podnesem neke plate
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 se izbrisati jer količina postoji za stavku {1}
DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Potvrda o kupovini zemljišta
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Approve,Odobri
apps/erpnext/erpnext/hr/page/team_updates/team_updates.js,No more updates,Nema više ažuriranja
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,Leaves Allocated Successfully for {0},Uspješno ostavlja za {0}
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Report,Izveštaj o proceni
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Da ne primijenimo Pravilo o cijenama u određenoj transakciji, sva primjenjiva Pravila cijena moraju biti onemogućena."
DocType: Company,Default Deferred Revenue Account,Default Deferred Revenue Account
apps/erpnext/erpnext/config/non_profit.py,Donor information.,Informacije o donatorima.
DocType: Authorization Rule,Customerwise Discount,Customerwise Discount
DocType: Stock Ledger Entry,Outgoing Rate,Outgoing Rate
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Molimo vas da odaberete Dodeljeni iznos, vrstu fakture i broj fakture u najmanje jednom redu"
DocType: Asset Category,Asset Category Name,Naziv kategorije imovine
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Receipt document must be submitted,Dokument o prijemu mora biti dostavljen
,Employee Advance Summary,Sažetak unaprijed zaposlenika
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Detailed Reason,Detaljan razlog
apps/erpnext/erpnext/healthcare/setup.py,Low Sensitivity,Low Sensitivity
DocType: Authorization Rule,Applicable To (Designation),Primjenjivo na (oznaka)
DocType: Tax Rule,Billing City,Billing City
DocType: Item,Is Customer Provided Item,Predmet koji je kupac
DocType: Purchase Invoice,Purchase Taxes and Charges Template,Šablon kupovine poreza i naknada
DocType: Sales Invoice Item,Brand Name,Brand Name
DocType: Fee Schedule,Total Amount per Student,Ukupan iznos po studentu
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Apparel & Accessories,Apparel &amp; Accessories
DocType: Compensatory Leave Request,Work From Date,Rad od datuma
apps/erpnext/erpnext/projects/doctype/project/project.py,Project Collaboration Invitation,Poziv za saradnju na projektu
DocType: Student Attendance Tool,Student Attendance Tool,Student Attendance Tool
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Prescribed Procedures,Propisane procedure
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/accounts/report/accounts_receivable/accounts_receivable.py,PDC/LC Amount,Iznos PDC / LC
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Set Details,Set Details
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total claimed amount,Ukupni iznos akontacije ne može biti veći od ukupnog iznosa koji se traži
DocType: POS Item Group,Item Group,Grupa proizvoda
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Trenutno nema zaliha u skladištu
apps/erpnext/erpnext/utilities/user_progress.py,Upload your letter head (Keep it web friendly as 900px by 100px),Otpremite glavu za pisma (zadržite web prijateljski kao 900px od 100px)
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 postavljena za serijske brojeve. Stupac mora biti prazan
DocType: Company,Default Values,Default Values
apps/erpnext/erpnext/setup/doctype/company/company.js,Default tax templates for sales and purchase are created.,Kreirani su predlošci poreza za prodaju i kupnju.
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leave Type {0} cannot be carry-forwarded,Tip ostavljanja {0} se ne može prenositi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To account must be a Receivable account,Zaduženje Račun mora biti račun potraživanja
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 nego danas.
apps/erpnext/erpnext/stock/__init__.py,Please set Account in Warehouse {0} or Default Inventory Account in Company {1},Postavite račun na skladištu {0} ili zadani račun inventara u tvrtki {1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Set as Default,Podesi kao podrazumevano
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Neto težina ovog paketa. (izračunava se automatski kao zbir neto težine artikala)
apps/erpnext/erpnext/stock/doctype/item_variant_settings/item_variant_settings.py,Cannot set the field <b>{0}</b> for copying in variants,Nije moguće postaviti polje <b>{0}</b> za kopiranje u varijantama
DocType: Payment Term,Month(s) after the end of the invoice month,Mjesec (i) nakon kraja mjeseca fakture
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Get Employees,Get Employees
DocType: Student,Leaving Certificate Number,Broj sertifikata
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js,Not Expired,Not Expired
DocType: Company,Unrealized Exchange Gain/Loss Account,Nerealizirani račun dobiti i gubitka
DocType: Employee,Relieving Date,Datum oslobađanja
DocType: Plant Analysis,Plant Analysis Criterias,Kriteriji za analizu biljaka
DocType: Leave Block List Date,Leave Block List Date,Ostavite datum blokiranja
DocType: Payment Entry,Receive,Primite
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Relieving Date must be greater than Date of Joining,Datum oslobađanja mora biti veći od datuma pridruživanja
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Error: Not a valid id?,Greška: Nije važeći ID?
DocType: BOM Update Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.
It also updates latest price in all the BOMs.","Zamijenite određenu sastavnicu u svim drugim sastavnicama gdje se ona koristi. Zamijenit će staru BOM vezu, troškove ažuriranja i obnoviti tablicu &quot;BOM Explosion Item&quot; prema novoj BOM. Takođe ažurira najnoviju cijenu u svim sastavnicama."
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,"Company, Payment Account, From Date and To Date is mandatory","Preduzeće, račun za plaćanje, datum i datum je obavezno"
DocType: Sales Invoice Payment,Base Amount (Company Currency),Osnovni iznos (valuta kompanije)
DocType: Sales Invoice Advance,Sales Invoice Advance,Akontacija prodajne fakture
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Notify Customers via Email,Obavijestite klijente putem e-pošte
DocType: Production Plan Item,Make Work Order for Sub Assembly Items,Napravite radni nalog za stavke pod-skupštine
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Manager,Menadžer
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Expired Batches,Istekle serije
DocType: Shipping Rule,Shipping Rule Type,Vrsta pravila o isporuci
DocType: Job Offer,Accepted,Prihvaćeno
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,You have already assessed for the assessment criteria {}.,Već ste procijenili kriterije procjene {}.
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch Numbers,Izaberite Serijski brojevi
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Age (Days),Dob (Dani)
DocType: Student Batch Name,Batch Name,Naziv serije
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Large,Veliko
apps/erpnext/erpnext/controllers/accounts_controller.py,Accounting Entry for {0}: {1} can only be made in currency: {2},Računovodstveni unos za {0}: {1} može biti samo u valuti: {2}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for hold: ,Razlog za zadržavanje:
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Failed,Kreiranje naknade nije uspelo
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Reorder Level,Reorder Level
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} '{1}' is disabled,{0} &#39;{1}&#39; je onemogućeno
DocType: Stock Ledger Entry,Actual Qty After Transaction,Stvarni broj nakon transakcije
DocType: Subscription,Cancel At End Of Period,Odustani na kraju perioda
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js,Healthcare Service Unit Tree,Stablo jedinice zdravstvene službe
apps/erpnext/erpnext/config/buying.py,Bundle items at time of sale.,U paketu stavke u vrijeme prodaje.
DocType: Payment Reconciliation Payment,Allocated Amount,Dodijeljeni iznos
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,Please select Company and Designation,Molimo odaberite Društvo i oznaku
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,Potreban je datum
DocType: Email Digest,Bank Credit Balance,Saldo kredita banke
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Prikaži kumulativni iznos
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,You don't have enought Loyalty Points to redeem,Nemate dovoljno bodova lojalnosti da biste ih iskoristili
DocType: Purchase Invoice,Additional DIscount Percentage,Dodatni procenat DIscount
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the name of the bank or lending institution before submittting.,Unesite ime banke ili kreditne institucije prije podnošenja prijave.
apps/erpnext/erpnext/controllers/accounts_controller.py,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Upozorenje: Sistem neće proveriti overbilling jer je iznos za stavku {0} u {1} jednak nuli
apps/erpnext/erpnext/public/js/setup_wizard.js,Select your Domains,Izaberite svoje domene
DocType: Agriculture Task,Task Name,Naziv zadatka
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Stock Entries already created for Work Order ,Stock Unosi već kreirani za radni nalog
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 otkažete ovaj dokument"
,Amount to Deliver,Iznos za isporuku
apps/erpnext/erpnext/accounts/doctype/account/account.py,Company {0} does not exist,Kompanija {0} ne postoji
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,No pending Material Requests found to link for the given items.,Nije pronađen nijedan zahtjev za materijalom za povezivanje za date stavke.
apps/erpnext/erpnext/utilities/activation.py,"Students are at the heart of the system, add all your students","Studenti su u srcu sistema, dodajte sve svoje učenike"
DocType: Company,Company Logo,Logo kompanije
DocType: Content Question,Question Link,Link na pitanje
DocType: HR Settings,Leave Approver Mandatory In Leave Application,Ostavite odobrenje obavezno u aplikaciji za napuštanje
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Add notes,Dodajte napomene
apps/erpnext/erpnext/templates/generators/item/item_configure.js,{0} items found.,Pronađeno je {0} stavki.
DocType: Patient,Personal and Social History,Lična i društvena istorija
DocType: Maintenance Visit Purpose,Work Done,Posao završen
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Postavljanje događaja na {0}, budući da zaposlenik koji je priključen na niže prodajne osobe nema ID korisnika {1}"
DocType: Student Guardian,Father,Oče
,Purchase Order Items To Be Received,Stavke narudžbenice koje treba primiti
apps/erpnext/erpnext/accounts/general_ledger.py,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debit i Kredit nisu jednaki za {0} # {1}. Razlika je {2}.
DocType: Marketplace Settings,Custom Data,Custom Data
DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,In Words će biti vidljive kada sačuvate narudžbenicu.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Actual type tax cannot be included in Item rate in row {0},Porez na stvarnu vrstu ne može biti uključen u stavku stavke u redu {0}
DocType: Lab Test Template,Compound,Compound
DocType: Quotation,Rate at which customer's currency is converted to company's base currency,Stopa po kojoj se valuta kupca pretvara u osnovnu valutu kompanije
DocType: Lead,Converted,Converted
DocType: Email Digest,New Income,New Income
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Retention Stock Entry already created or Sample Quantity not provided,Zadržavanje zaliha Unos već kreiran ili uzorak količine nije dostavljen
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Vouchers,Obrada vaučera
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please enter Item Code to get batch no,Molimo unesite Šifru artikla da dobijete serijski br
apps/erpnext/erpnext/public/js/controllers/transaction.js,Service Stop Date cannot be before Service Start Date,Datum servisnog zaustavljanja ne može biti prije datuma početka usluge
DocType: Employee Property History,Employee Property History,Povijest imovine zaposlenika
,Requested Items To Be Ordered,Tražene stavke koje treba naručiti
DocType: Vital Signs,Blood Pressure (systolic),Krvni pritisak (sistolni)
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Leave Without Pay does not match with approved Leave Application records,Ostavi bez plaćanja ne podudara se sa odobrenim zapisima o aplikaciji
DocType: Purchase Invoice Item,Expense Head,Expense Head
DocType: Employee,Reason for Resignation,Razlog za ostavku
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Fetch Subscription Updates,Dohvati ažuriranja pretplate
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Plaćeni iznos + Piši Iznos ne može biti veći od ukupnog iznosa
DocType: Asset Repair,Error Description,Opis greške
DocType: Healthcare Practitioner,Out Patient Consulting Charge Item,Stavka za naplatu pacijenta
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,No replies from,Nema odgovora od
DocType: Shopify Settings,Sales Order Series,Serija prodajnih naloga
DocType: Accounts Settings,Automatically Fetch Payment Terms,Automatski preuzmite uslove plaćanja
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 može se pozvati broj reda veći ili jednak broju tekućeg reda za ovaj tip naplate
apps/erpnext/erpnext/public/js/hub/components/reviews.js,Anonymous,Anonimno
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please select the Company,Molimo izaberite Društvo
apps/erpnext/erpnext/accounts/page/pos/pos.js,"Master data syncing, it might take some time",Sinhronizacija glavnih podataka može potrajati
DocType: Leave Application,HR-LAP-.YYYY.-,HR-LAP-.YYYY.-
DocType: Item,Customer Items,Stavke kupca
DocType: Program Enrollment,Enrolled courses,Upisani kursevi
DocType: Lab Prescription,Test Code,Test Code
DocType: Purchase Taxes and Charges,On Previous Row Total,On Previous Row Total
DocType: Student,Student Email Address,Adresa e-pošte studenta
,Delayed Item Report,Odloženi izvještaj o stavkama
DocType: Academic Term,Education,Obrazovanje
DocType: Supplier Quotation,Supplier Address,Adresa dobavljača
DocType: Salary Detail,Do not include in total,Ne uključujte ukupno
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot set multiple Item Defaults for a company.,Nije moguće postaviti višestruke zadane postavke za tvrtku.
apps/erpnext/erpnext/accounts/party.py,{0}: {1} does not exists,{0}: {1} ne postoji
DocType: Purchase Receipt Item,Rejected Quantity,Odbijena količina
DocType: Cashier Closing,To TIme,To TIme
DocType: Daily Work Summary Group User,Daily Work Summary Group User,Dnevni radni pregled grupe korisnika
DocType: Fiscal Year Company,Fiscal Year Company,Fiskalna godina Kompanija
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Alternative item must not be same as item code,Alternativna stavka ne smije biti ista kao kod stavke
DocType: Payment Schedule,Payment Term,Rok plaćanja
DocType: Quality Action,Quality Review,Quality Review
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,In Stock Qty,In Stock Qty
DocType: Material Request Plan Item,Customer Provided,Customer Provided
apps/erpnext/erpnext/projects/doctype/task/task.py,Child Task exists for this Task. You can not delete this Task.,Zadatak djeteta postoji za ovaj zadatak. Ovaj zadatak ne možete izbrisati.
DocType: Item,Inventory,Inventar
DocType: Supplier Scorecard Criteria,Criteria Name,Naziv kriterijuma
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Total Allocated Leaves,Ukupno dodijeljenih listova
DocType: Chapter,Members,Članovi
DocType: Fees,Student Details,Studentski detalji
DocType: Account,Fixed Asset,Fixed Asset
DocType: Cheque Print Template,Has Print Format,Ima format ispisa
DocType: Training Result Employee,Training Result Employee,Rezultat treninga Zaposleni
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with child nodes cannot be set as ledger,Račun sa čvorovima za dijete ne može se postaviti kao knjiga
apps/erpnext/erpnext/config/buying.py,Purchase Order to Payment,Narudžbenica za plaćanje
apps/erpnext/erpnext/agriculture/doctype/disease/disease.py,Start day is greater than end day in task '{0}',Početni dan je veći od završnog dana u zadatku &#39;{0}&#39;
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Financing,Neto gotovina iz finansiranja
DocType: Quiz,Enter 0 to waive limit,Unesite 0 da biste se odrekli ograničenja
apps/erpnext/erpnext/accounts/doctype/cashier_closing/cashier_closing.py,From Time Should Be Less Than To Time,Od vremena treba da bude manje od vremena
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Newspaper Publishers,Newspaper Publishers
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Dobavljač je obavezan prema računu za plaćanje {2}
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Outstanding Cheques and Deposits to clear,Izvanredni čekovi i depoziti za brisanje
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: Vehicle,Natural Gas,Prirodni gas
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} not found,Serijski broj {0} nije pronađen
DocType: Hub User,Hub Password,Hub Password
,Bank Reconciliation Statement,Izjava o pomirenju banke
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Fixed Asset,Neto promjena osnovnog sredstva
DocType: Payment Request,Paid,Plaćeno
DocType: Maintenance Visit,Completion Status,Status dovršenja
DocType: Job Card,Transferred Qty,Transferred Qty
DocType: Healthcare Service Unit,Occupied,Zauzeto
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Opening {0} Invoice created,Otvaranje {0} Napravljena faktura
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to create website,Kreiranje web lokacije nije uspjelo
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Opportunities by lead source,Mogućnosti od izvora vode
DocType: Grading Scale Interval,Grading Scale Interval,Interval skale za ocjenjivanje
DocType: Education Settings,Instructor Records to be created by,Instruktorski zapisi koje će kreirati
DocType: Student Report Generation Tool,Student Report Generation Tool,Alat za generiranje izvještaja učenika
apps/erpnext/erpnext/stock/doctype/batch/batch.js,View Ledger,View Ledger
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Bilo kakve druge primedbe, vredan napora koje bi trebalo da idu u evidenciju."
DocType: Travel Request,"Details of Sponsor (Name, Location)","Detalji sponzora (ime, lokacija)"
DocType: Project Task,Weight,Težina
DocType: Staffing Plan Detail,Current Count,Current Count
DocType: Sales Team,Incentives,Incentives
DocType: Program Fee,Program Fee,Naknada za program
DocType: Delivery Settings,Delay between Delivery Stops,Kašnjenje između zaustavljanja isporuke
DocType: Stock Settings,Freeze Stocks Older Than [Days],Zamrzavanje zaliha starije od [dana]
DocType: Promotional Scheme,Promotional Scheme Product Discount,Promotivni proizvodni popust na proizvode
apps/erpnext/erpnext/support/doctype/issue_priority/issue_priority.py,Issue Priority Already Exists,Već postoji prioritet problema
DocType: Account,Asset Received But Not Billed,"Primljeno sredstvo, ali nije naplaćeno"
DocType: POS Closing Voucher,Total Collected Amount,Ukupan prikupljeni iznos
DocType: Course,Default Grading Scale,Default Grading Scale
DocType: POS Profile,Allow user to edit Discount,Dozvolite korisniku da uređuje Popust
DocType: POS Closing Voucher,Linked Invoices,Povezani računi
DocType: Volunteer,Weekends,Vikendom
DocType: Employee,Health Details,Health Details
DocType: Employee Education,Graduate,Diplomirati
DocType: Asset Maintenance Task,Asset Maintenance Task,Zadatak održavanja imovine
DocType: Restaurant Order Entry,Restaurant Table,Restoran Table
DocType: Amazon MWS Settings,CN,CN
apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js,Order Entry,Order Entry
DocType: Request for Quotation Supplier,Download PDF,Preuzmite PDF
DocType: Payment Entry,Unallocated Amount,Neraspoređeni iznos
DocType: Travel Itinerary,Rented Car,Rented Car
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Na čekanju
DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Sales Invoice Timesheet
DocType: Subscription,Plans,Planovi
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Iznos vaučera za zemljišne troškove
DocType: Student Log,Medical,Medicinski
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Account {0} is frozen,Račun {0} je zamrznut
DocType: Project,First Email,First Email
DocType: Supplier Scorecard,Criteria Setup,Podešavanje kriterija
DocType: Crop,Yield UOM,Prinos UOM
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Lab Test Prescriptions,Lab Test Prescriptions
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,Service Expense,Rashodi za usluge
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference No & Reference Date is required for {0},Referentni broj i referentni datum je potreban za {0}
DocType: Salary Structure,Leave Encashment Amount Per Day,Ostavite iznos inkasacije po danu
DocType: Student Admission Program,Naming Series (for Student Applicant),Serija imenovanja (za studenta-kandidata)
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per section 17(5),Po članu 17 (5)
apps/erpnext/erpnext/stock/stock_ledger.py,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} jedinice {1} potrebne u {2} na {3} {4} za {5} za dovršenje ove transakcije.
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,Credit Days cannot be a negative number,Dani kredita ne mogu biti negativni brojevi
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
DocType: Customs Tariff Number,Tariff Number,Tarifni broj
DocType: Plant Analysis Criteria,Maximum Permissible Value,Maksimalna dozvoljena vrijednost
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Received Stock Entries,Received Stock Entries
DocType: Opportunity,Opportunity Amount,Opportunity Amount
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount,Iznos narudžbenice
DocType: C-Form,III,III
DocType: Contract,Fulfilment Terms,Uslovi ispunjenja
apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Ne-grupa u grupu
DocType: Student Guardian,Mother,Majko
DocType: Issue,Service Level Agreement Fulfilled,Ispunjen ugovor o nivou usluge
DocType: Payroll Entry,Deduct Tax For Unclaimed Employee Benefits,Porez na odbitak za neplaćene naknade zaposlenima
DocType: Travel Request,Travel Funding,Putno finansiranje
DocType: Shipping Rule,Fixed,Fiksno
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) ne može biti veća od planirane količine ({2}) u radnom nalogu {3}
DocType: Quality Review,Additional Information,Dodatne informacije
DocType: Course Scheduling Tool,Reschedule,Reschedule
apps/erpnext/erpnext/setup/doctype/company/company.py,Please select Existing Company for creating Chart of Accounts,Molimo odaberite postojeću kompaniju za kreiranje kontnog plana
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Active Leads / Customers,Aktivni korisnici / klijenti
apps/erpnext/erpnext/templates/generators/item/item_configure.js,1 exact match.,1 točno podudaranje.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Sports,Sport
DocType: Employee Advance,Claimed Amount,Potraženi iznos
DocType: Plant Analysis Criteria,Plant Analysis Criteria,Kriteriji analize biljaka
DocType: Fee Schedule,Send Payment Request Email,Pošalji e-poruku sa zahtevom za plaćanje
DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,In Words će biti vidljive kada sačuvate fakturu prodaje.
DocType: Sales Invoice,Sales Team1,Prodajni tim1
DocType: Work Order,Required Items,Potrebne stavke
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Read the ERPNext Manual,Pročitajte ERPNext priručnik
DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Provjerite jedinstvenost broja fakture dobavljača
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Search Sub Assemblies,Search Sub Assemblies
DocType: Rename Tool,Type of document to rename.,Vrsta dokumenta za preimenovanje.
apps/erpnext/erpnext/utilities/activation.py,"Leads help you get business, add all your contacts and more as your leads","Vode vam pomažu da dobijete posao, dodate sve svoje kontakte i još mnogo toga kao svoje vodeće"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Indirect Expenses,Indirektni troškovi
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Internet Publishing,Internet Publishing
DocType: Customer,Account Manager,Menadžer računa
DocType: Amazon MWS Settings,BR,BR
DocType: Item,Warranty Period (in days),Period garancije (u danima)
apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js,No items found.,Nema pronađenih stavki.
DocType: Item Attribute,From Range,From Range
DocType: Clinical Procedure,Consumables,Potrošni materijal
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,'employee_field_value' and 'timestamp' are required.,&#39;employee_field_value&#39; i &#39;timestamp&#39; su obavezni.
DocType: Purchase Taxes and Charges,Reference Row #,Referentni redak #
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set 'Asset Depreciation Cost Center' in Company {0},Postavite &#39;Središte troškova amortizacije imovine&#39; u kompaniji {0}
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Row #{0}: Payment document is required to complete the trasaction,Red # {0}: Dokument za plaćanje je potreban da bi se dovršila transakcija
DocType: Amazon MWS Settings,Click this button to pull your Sales Order data from Amazon MWS.,Kliknite na ovo dugme da biste povukli podatke o prodajnom nalogu od Amazon MWS.
DocType: Shift Type,Working hours below which Half Day is marked. (Zero to disable),Radno vrijeme ispod kojeg se obilježava pola dana. (Nula do onemogućavanja)
,Assessment Plan Status,Status plana procjene
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select {0} first,Prvo odaberite {0}
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,Submit this to create the Employee record,Podnesite ovo da biste kreirali zapis zaposlenika
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""","Ovo će biti dodato u šifru artikla varijante. Na primjer, ako je vaša skraćenica &quot;SM&quot;, a kod stavke &quot;T-SHIRT&quot;, kod stavke varijante će biti &quot;T-SHIRT-SM&quot;"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please enter Delivery Date,Unesite datum isporuke
DocType: Purchase Invoice Item,Quality Inspection,Inspekcija kvaliteta
DocType: Account,Root Type,Root Type
DocType: Journal Entry,Write Off Based On,Piši na bazi
DocType: Lab Test,Report Preference,Report Preference
DocType: Products Settings,Products Settings,Postavke proizvoda
DocType: Amazon MWS Settings,Synch Taxes and Charges,Sinkronizirajte poreze i naknade
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Total cannot be zero,Ukupno ne može biti nula
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Cr),Otvaranje (Cr) \ t
DocType: Employee,Company Email,Email kompanije
DocType: Shopping Cart Settings,Show Stock Quantity,Show Stock Quantity
DocType: Student,A-,A-
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0} is added in the child company {1},Račun {0} se dodaje u podređenu tvrtku {1}
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date Of Retirement must be greater than Date of Joining,Datum odlaska u penziju mora biti veći od datuma pridruživanja
DocType: Restaurant Order Entry,Add Item,Dodaj stavku
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Sick Leave,Bolovanje
DocType: Lab Test,Lab Test,Lab Test
DocType: Account,Accumulated Depreciation,Akumuliranu amortizaciju
DocType: Support Search Source,Source Type,Vrsta izvora
DocType: Department Approver,Department Approver,Department Approver
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Qty per BOM Line,Količina po liniji BOM
apps/erpnext/erpnext/controllers/buying_controller.py,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Prihvaćena + Odbijena količina mora biti jednaka primljenoj količini za stavku {0}
apps/erpnext/erpnext/config/hr.py,Expense Claims,Troškovi potraživanja
DocType: Bank Account,Address HTML,Adresa HTML
,Stock Projected Qty,Stock Projected Qty
DocType: Employee Onboarding,Job Offer,Ponudu za posao
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,No Remarks,No Remarks
DocType: Sales Invoice,Change Amount,Change Amount
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Write Off Amount,Napiši iznos
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,No Items available for transfer,Nema dostupnih stavki za prenos
DocType: Work Order,Actual End Date,Stvarni datum završetka
DocType: Loyalty Point Entry,Loyalty Point Entry,Unos bodova lojalnosti
DocType: Travel Itinerary,Train,Voz
DocType: BOM Explosion Item,BOM Explosion Item,BOM Explosion Item
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward Supplies(liable to reverse charge,Unutrašnji dobavljači (podložni obrnutoj naplati)
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,{0}: {1} not found in Invoice Details table,{0}: {1} nije pronađena u tabeli Detalji fakture
DocType: Stock Entry,Total Incoming Value,Ukupna ulazna vrijednost
apps/erpnext/erpnext/public/js/stock_analytics.js,Select Warehouse...,Odaberite skladište ...
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Type of Business,Tip poslovanja
apps/erpnext/erpnext/config/buying.py,All Addresses.,Sve adrese.
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ćavanjem opcije &quot;Koristi za korpe za kupovinu&quot;, kada je korpa za kupovinu omogućena i treba da postoji najmanje jedno poresko pravilo za korpe za kupovinu"
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Course,Molimo izaberite Kurs
DocType: Taxable Salary Slab,Percent Deduction,Percent Deduction
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 nule
DocType: Share Balance,To No,To No
DocType: Leave Control Panel,Allocate Leaves,Allocate Leaves
DocType: Assessment Result,Student Name,Ime studenta
apps/erpnext/erpnext/config/crm.py,Plan for maintenance visits.,Plan za posjete održavanju.
apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Sledeći zahtevi za materijal su podignuti automatski na osnovu re-narudžbine na stavci
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on PO,Akcija ako je akumulirani mjesečni budžet premašen na PO
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Full-time,Puno vrijeme
DocType: Program Enrollment,Vehicle/Bus Number,Broj vozila / autobusa
DocType: Tax Rule,Purchase Tax Template,Šablon poreza za kupovinu
DocType: Production Plan,Material Request Planning,Planiranje zahtjeva materijala
DocType: UOM,Check this to disallow fractions. (for Nos),Označite ovo da biste zabranili frakcije. (za brojeve)
DocType: Retention Bonus,Bonus Payment Date,Datum plaćanja bonusa
DocType: BOM,Operating Cost,Operativni troškovi
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select Items based on Delivery Date,Izaberite stavke na osnovu datuma isporuke
DocType: Homepage,Tag Line,Tag Line
DocType: Customer,From Lead,From Lead
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Unclosed Fiscal Years Profit / Loss (Credit),Nezatvorena dobit / gubitak fiskalne godine (kredit)
DocType: Agriculture Analysis Criteria,Agriculture,Poljoprivreda
DocType: Quality Procedure,Parent Procedure,Parent Procedure
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Set Open,Postavi Otvori
apps/erpnext/erpnext/www/all-products/index.html,Toggle Filters,Toggle Filters
DocType: Production Plan,Material Request Detail,Detail Material Request
DocType: Shift Type,Process Attendance After,Prisustvo procesa nakon
DocType: Material Request Item,Quantity and Warehouse,Količina i skladište
apps/erpnext/erpnext/utilities/user_progress.py,Go to Programs,Idite na Programi
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Duplicate entry in References {1} {2},Red # {0}: Dvostruki unos u Reference {1} {2}
DocType: Loyalty Point Entry,Loyalty Program,Program lojalnosti
DocType: Lost Reason Detail,Opportunity Lost Reason,Opportunity Lost Reason
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is a limited liability company,Primjenjivo ako je društvo društvo s ograničenom odgovornošću
DocType: Patient,"Allergies, Medical and Surgical History","Alergije, medicinska i hirurška istorija"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Capital Stock,Capital Stock
DocType: Share Transfer,From Folio No,Iz Folio No
apps/erpnext/erpnext/templates/pages/order.js,Pay Remaining,Pay Remaining
apps/erpnext/erpnext/accounts/page/pos/pos.js,Search Item,Search Item
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Leaves,Ukupno lišća
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update rate as per last purchase,Stopa ažuriranja po posljednjoj kupnji
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please select a table,Odaberite tablicu
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} is blocked so this transaction cannot proceed,{0} je blokiran tako da se ova transakcija ne može nastaviti
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get Items From,Get Items From
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.","Bodovi lojalnosti će se obračunavati od izvršenog iznosa (preko fakture prodaje), na osnovu navedenog faktora naplate."
DocType: Setup Progress Action,Min Doc Count,Min Doc Count
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} must be a non-stock item,Stavka {0} mora biti stavka koja nije na zalihama
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge Account,Merge Account
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to Group,Pretvori u grupu
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 default u pos profilu {0} za korisnika {1}, ljubazno onemogućili default"
DocType: Fiscal Year,Companies,Kompanije
,Minutes to First Response for Opportunity,Minuta do prvog odgovora za priliku
DocType: Hotel Room Amenity,Hotel Room Amenity,Hotel Room Amenity
apps/erpnext/erpnext/config/selling.py,Invoices for Costumers.,Fakture za kupce.
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.js,No Staffing Plans found for this Designation,Za ovu oznaku nisu pronađeni planovi zapošljavanja
DocType: BOM Update Tool,Current BOM,Current BOM
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Casual Leave
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Cost Updated,Cost Updated
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,One customer can be part of only single Loyalty Program.,Jedan korisnik može biti dio samo jednog programa lojalnosti.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Cannot cancel transaction for Completed Work Order.,Ne može se otkazati transakcija za Kompletiran radni nalog.
DocType: Grant Application,Grant Application Details ,Grant Application Details
DocType: Purchase Invoice,Apply Additional Discount On,Primijeni dodatni popust na
,Sales Partner Commission Summary,Sažetak Komisije za prodajnog partnera
apps/erpnext/erpnext/controllers/selling_controller.py,Order Type must be one of {0},Vrsta narudžbe mora biti jedna od {0}
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry already exists,Unos za plaćanje već postoji
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No Work Orders created,Nije kreiran nijedan radni nalog
DocType: Assessment Plan,Grading Scale,Grading Scale
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/crm/doctype/lead/lead.py,Next Contact Date cannot be in the past,Datum sljedećeg kontakta ne može biti u prošlosti
DocType: Shopify Settings,Webhooks Details,Webhooks Details
DocType: Authorization Rule,Authorization Rule,Pravilo autorizacije
apps/erpnext/erpnext/config/non_profit.py,Volunteer Type information.,Informacije o tipu volontera.
DocType: Naming Series,This is the number of the last created transaction with this prefix,Ovo je broj zadnje kreirane transakcije s ovim prefiksom
DocType: Supplier Scorecard,Indicator Color,Boja indikatora
DocType: Item Variant Settings,Copy Fields to Variant,Kopirajte polja u Variant
DocType: Soil Texture,Sandy Loam,Sandy Loam
DocType: Question,Single Correct Answer,Single Correct Answer
apps/erpnext/erpnext/hr/utils.py,From date can not be less than employee's joining date,Od datuma ne može biti manji od datuma pridruživanja zaposlenog
DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Dozvolite višestruke narudžbe prodaje protiv narudžbenice naručioca
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,PDC/LC,PDC / LC
DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Ako je označeno, iznos poreza će se smatrati već uključenim u Stopu ispisa / Iznos štampe"
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Datum se ponavlja
DocType: Pricing Rule,Party Information,Informacije o zabavi
apps/erpnext/erpnext/shopping_cart/cart.py,Debtors ({0}),Dužnici ({0})
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 otpuštanja zaposlenog
DocType: Shift Type,Enable Exit Grace Period,Omogući Exit Grace Period
DocType: Expense Claim,Employees Email Id,Id zaposlenika e-pošte
DocType: Shopify Settings,Update Price from Shopify To ERPNext Price List,Ažuriraj cenu iz Shopify u ERPNext cenovnik
DocType: Healthcare Settings,Default Medical Code Standard,Default Medical Code Standard
DocType: Woocommerce Settings,Tax Account,Porezni račun
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py,Total Paid Amt,Ukupno plaćeni amt
DocType: BOM,Website Specifications,Specifikacije veb sajta
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 po shemi kompozicije, izuzeti i Nil ocijenjeni"
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 prisutnost? <br> Prisutni: {0} \ t <br> Odsutno: {1}
DocType: Leave Control Panel,Employee (optional),Zaposleni (opcionalno)
DocType: Purchase Invoice,Supplier Invoice Details,Detalji fakture dobavljača
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Korisnik {0} je kreiran.
DocType: Company,Default Cost of Goods Sold Account,Podrazumevani trošak prodanog računa robe
apps/erpnext/erpnext/accounts/utils.py,{0} Number {1} already used in account {2},{0} Broj {1} je već korišten u računu {2}
DocType: Mode of Payment Account,Default Account,Default Account
DocType: Purchase Invoice,Disable Rounded Total,Onemogući Zaokruženo Ukupno
DocType: Contract,Signee,Signee
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/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to group.,Skladišta sa postojećom transakcijom ne mogu se pretvoriti u grupu.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Both Warehouse must belong to same Company,Oba skladišta moraju pripadati istoj kompaniji
DocType: Maintenance Visit Purpose,Against Document Detail No,Protiv dokumenta Detalj br
apps/erpnext/erpnext/public/js/queries.js,Please set {0},Postavite {0}
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Prvo odaberite prefiks
apps/erpnext/erpnext/config/buying.py,Managing Subcontracting,Upravljanje podugovaranjem
DocType: Activity Cost,Projects User,Korisnik projekata
DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Variable
DocType: Item Group,Item Group Name,Naziv grupe stavke
DocType: Budget,Applicable on Material Request,Primjenjivo na zahtjev za materijal
DocType: Support Settings,Search APIs,API-ji za pretraživanje
DocType: Manufacturing Settings,Overproduction Percentage For Sales Order,Postotak prekomjerne proizvodnje za prodajni nalog
DocType: Purchase Invoice,Supplied Items,Priložene stavke
DocType: Leave Control Panel,Select Employees,Izaberite Zaposleni
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Select interest income account in loan {0},Odaberite račun prihoda od kamata u zajmu {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Sve stavke su već prebačene za ovaj radni nalog.
DocType: Certification Application,Payment Details,Detalji plaćanja
apps/erpnext/erpnext/config/settings.py,Printing and Branding,Štampanje i brendiranje
DocType: Item Group,HTML / Banner that will show on the top of product list.,HTML / Banner koji će se prikazati na vrhu liste proizvoda.
,Sales Payment Summary,Sažetak plaćanja prodaje
DocType: Salary Component,Is Flexible Benefit,Je fleksibilna prednost
DocType: GST Account,IGST Account,IGST račun
DocType: Shopping Cart Settings,Checkout Settings,Checkout Settings
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the customer '%s',Postavite fiskalni kod za klijenta &quot;% s&quot;
DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,** Mjesečna distribucija ** vam pomaže da distribuirate budžet / cilj kroz mjesece ako imate sezonalnost u svom poslovanju.
DocType: Guardian,Students,Studenti
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Expense Claim {0} already exists for the Vehicle Log,Tvrdnja rashoda {0} već postoji za Dnevnik vozila
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, vrijednost navedena ili izračunata u ovoj komponenti neće doprinijeti zaradama ili odbitcima. Međutim, na njegovu vrijednost se mogu pozivati druge komponente koje se mogu dodati ili oduzeti."
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter repayment Amount,Unesite iznos otplate
DocType: Sales Invoice,Is Opening Entry,Otvara se unos
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Set New Release Date,Postavite novi datum izdavanja
DocType: Account,Expenses Included In Valuation,Troškovi uključeni u procjenu
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Serial Numbers,Serijski brojevi
DocType: Salary Slip,Deductions,Odbijanja
,Supplier-Wise Sales Analytics,Analitika prodaje dobavljača
DocType: GSTR 3B Report,February,februar
DocType: Appraisal,For Employee,Za zaposlenika
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Actual Delivery Date,Stvarni datum isporuke
DocType: Sales Partner,Sales Partner Name,Ime partnera za prodaju
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Depreciation Start Date is entered as past date,Redosled amortizacije {0}: Početni datum amortizacije se unosi kao datum prethodnog datuma
DocType: GST HSN Code,Regional,Regional
DocType: Lead,Lead is an Organization,Olovo je organizacija
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select Charge Type first,Prvo odaberite Vrsta punjenja
DocType: Purchase Receipt Item,Accepted Quantity,Prihvaćena količina
DocType: Amazon MWS Settings,DE,DE
apps/erpnext/erpnext/templates/pages/product_search.html,Search Results,Rezultati pretrage
DocType: Item Default,Default Buying Cost Center,Default Buying Cost Center
DocType: Production Plan,Include Non Stock Items,Uključite ne-dionice
DocType: Student,AB+,AB +
DocType: Upload Attendance,Upload Attendance,Upload Attendance
DocType: Drug Prescription,Drug Code,Drug Code
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Booking Actual Expenses,Molimo vas da omogućite Primjenjivo za rezervacije stvarnih troškova
apps/erpnext/erpnext/accounts/report/account_balance/account_balance.js,Chargeble,Chargeble
DocType: Purchase Order,Supply Raw Materials,Supply Raw Materials
,Item-wise Price List Rate,Cena-cijena po stavkama
DocType: Purchase Invoice Item,BOM,BOM
DocType: Quality Inspection,Readings,Čitanja
apps/erpnext/erpnext/accounts/deferred_revenue.py,Error while processing deferred accounting for {0},Pogreška pri obradi odgođenog računovodstva za {0}
apps/erpnext/erpnext/regional/italy/utils.py,Please set either the Tax ID or Fiscal Code on Company '%s',Molimo vas da postavite ili porezni broj ili fiskalni kod na kompaniji &#39;% s&#39;
apps/erpnext/erpnext/public/js/utils.js,Add Serial No,Dodaj serijski broj
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Avg. Selling Rate,Avg. Stopa prodaje
DocType: Payment Request,payment_url,payment_url
DocType: Delivery Note,Excise Page Number,Broj stranice akcize
,Sales Partner Target Variance based on Item Group,Varijacija cilja prodajnog partnera na osnovu grupe proizvoda
DocType: Stock Settings,Naming Series Prefix,Prefiks serije Imenovanja
DocType: BOM Operation,Workstation,Workstation
DocType: Employee Boarding Activity,Task Weight,Težina zadatka
apps/erpnext/erpnext/public/js/utils.js,Annual Billing: {0},Godišnja naplata: {0}
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Ne možete izbrisati fiskalnu godinu {0}. Fiskalna godina {0} je postavljena kao podrazumevana u globalnim postavkama
apps/erpnext/erpnext/public/js/pos/pos.html,No Customers yet!,Još nema kupaca!
DocType: Company,Enable Perpetual Inventory,Omogući perpetual Inventory
DocType: Opportunity,Potential Sales Deal,Potencijalni prodajni posao
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Excise Invoice,Akcizna faktura
DocType: Supplier Scorecard,Supplier Scorecard,Supplier Scorecard
DocType: Travel Itinerary,Travel To,Putovati u
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Mark Attendance,Mark Attendance
DocType: Shift Type,Determine Check-in and Check-out,Odredite prijavu i odjavu
DocType: POS Closing Voucher,Difference,Razlika
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Small,Mala
DocType: Work Order Item,Work Order Item,Stavka radne narudžbe
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py,Sales and Returns,Prodaja i povrat
DocType: Budget,Monthly Distribution,Monthly Distribution
DocType: Quality Action,Quality Action,Quality Action
DocType: Work Order,Work-in-Progress Warehouse,Skladište za napredovanje
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Dividends Paid,Dividend Paid
DocType: Program Enrollment Tool,New Academic Year,Nova akademska godina
DocType: Sales Person,Name and Employee ID,Ime i ID zaposlenika
DocType: Subscription,Generate Invoice At Beginning Of Period,Generišite fakturu na početku perioda
DocType: Item,Minimum Order Qty,Minimalna količina narudžbe
DocType: Leave Block List,Block Holidays on important days.,Blokirajte praznike u važnim danima.
apps/erpnext/erpnext/public/js/conf.js,Documentation,Dokumentacija
DocType: Item Alternative,Alternative Item Code,Alternative Item Code
DocType: Sales Partner,Partner website,Partner website
DocType: Loan,Applicant,Podnosilac prijave
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.","Jedno za rezultate koji zahtijevaju samo jedan ulaz, rezultat UOM i normalna vrijednost <br> Sastavite se za rezultate koji zahtijevaju višestruka polja za unos s odgovarajućim imenima događaja, rezultat UOM i normalne vrijednosti <br> Opisni za testove koji imaju više komponenti rezultata i odgovarajuća polja unosa rezultata. <br> Grupisano za probne predloške koji su grupa drugih testnih predložaka. <br> Ne Rezultat za testove bez rezultata. Takođe, nema Lab testa. npr. Podtestovi za rezultate grupiranja."
apps/erpnext/erpnext/accounts/general_ledger.py,Please mention Round Off Cost Center in Company,Molimo vas da navedete Okrugli centar troškova u kompaniji
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Napomene o isporuci {0} moraju biti otkazane prije otkazivanja ovog prodajnog naloga
DocType: Grant Application,Show on Website,Prikaži na web stranici
DocType: Sales Invoice,Shipping Address Name,Naziv adrese za isporuku
apps/erpnext/erpnext/healthcare/setup.py,Drug,Lijek
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is closed,{0} {1} je zatvoren
DocType: Patient,Medical History,Medicinska istorija
DocType: Expense Claim,Expense Taxes and Charges,Troškovi poreza i naknada
DocType: Subscription Settings,Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,Broj dana nakon isteka datuma fakture prije otkazivanja pretplate ili označavanja pretplate kao neplaćene
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Installation Note {0} has already been submitted,Napomena za instalaciju {0} je već poslana
DocType: Patient Relation,Family,Porodica
DocType: Work Order Operation,Updated via 'Time Log',Ažurirano putem &#39;Dnevnik vremena&#39;
DocType: Quality Inspection,Sample Size,Veličina uzorka
DocType: Journal Entry,Reference Number,Referentni broj
DocType: UOM Conversion Detail,UOM Conversion Detail,Detalji UOM konverzije
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Opening Accumulated Depreciation must be less than equal to {0},Otvaranje akumulirane amortizacije mora biti manje od {0}
DocType: Antibiotic,Antibiotic Name,Ime antibiotika
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js,"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",U tabeli ispod biće izabran samo kandidat sa statusom &quot;Odobreno&quot;.
DocType: Task,% Progress,% Napredak
DocType: UOM Category,UOM Category,Kategorija UOM
apps/erpnext/erpnext/config/help.py,Publish Items on Website,Objavite stavke na web-lokaciji
DocType: Chapter,Meetup Embed HTML,Meetup Embed HTML
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.js,Please select Party Type first,Prvo odaberite tip benda
DocType: Loan,Repayment Start Date,Datum početka otplate
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Not authroized since {0} exceeds limits,Nije autorizovano jer {0} premašuje ograničenja
DocType: Procedure Prescription,Procedure Created,Postupak stvoren
,Serial No Warranty Expiry,Serijski br
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Against Supplier Invoice {0} dated {1},Protiv fakture dobavljača {0} od {1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Change POS Profile,Promijenite POS profil
apps/erpnext/erpnext/utilities/activation.py,Create Lead,Create Lead
DocType: Shopify Settings,Default Customer,Default Customer
DocType: Payment Entry Reference,Supplier Invoice No,Faktura dobavljača br
DocType: Pricing Rule,Mixed Conditions,Mixed Conditions
DocType: Woocommerce Settings,"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".",Ovo je podrazumevani UOM koji se koristi za stavke i naloge za prodaju. Rezervni UOM je &quot;Nos&quot;.
DocType: Payment Request,Mute Email,Mute Email
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 2,Tačka 2
apps/erpnext/erpnext/config/accounting.py,Tax Withholding rates to be applied on transactions.,Stopa zadržavanja poreza koja se primjenjuje na transakcije.
DocType: Dosage Strength,Strength,Snaga
apps/erpnext/erpnext/stock/stock_ledger.py,{0} units of {1} needed in {2} to complete this transaction.,{0} jedinica {1} potrebne u {2} za dovršetak ove transakcije.
DocType: Buying Settings,Backflush Raw Materials of Subcontract Based On,Backflush sirovine na temelju podugovora
DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Ako je omogućeno, polje Academic Term će biti obavezno u alatu za upis programa."
DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Za studentsku grupu zasnovanu na šaržama, studentska grupa će biti validirana za svakog učenika iz programa za upis u program."
DocType: Course,Topics,Teme
apps/erpnext/erpnext/stock/doctype/item/item.py,Row #{0}: Please set reorder quantity,Red # {0}: Molimo vas da postavite količinu redosleda
DocType: Crop Cycle,Linked Location,Linked Location
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Batch number is mandatory for Item {0},Broj serije je obavezan za stavku {0}
apps/erpnext/erpnext/accounts/party.py,Not permitted for {0},Nije dopušteno za {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is fully billed,{0} {1} je potpuno naplaćeno
DocType: Payment Request,Inward,Unutra
apps/erpnext/erpnext/templates/pages/help.html,See All Articles,Vidi sve članke
DocType: Bank Reconciliation Detail,Payment Entry,Uplata plaćanja
DocType: Payment Request,Recipient Message And Payment Details,Poruka primatelja i detalji plaćanja
DocType: Payment Terms Template Detail,Payment Terms Template Detail,Uvjeti plaćanja Plaćanje detalj
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Select Quantity,Izaberite Količina
DocType: Student Attendance,Student Attendance,Student Attendance
DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Automatski postavi serijske brojeve na osnovu FIFO-a
,Available Qty,Available Qty
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invoices based on Filters,Nabavite fakture na osnovu filtera
DocType: Operation,Default Workstation,Default Workstation
DocType: Salary Slip,Salary Structure,Struktura plata
DocType: Products Settings,Enable Attribute Filters,Omogući filtre atributa
DocType: Member,Non Profit Member,Član neprofitne organizacije
DocType: Material Request Plan Item,Material Request Plan Item,Planska stavka zahtjeva materijala
DocType: Holiday List,Add to Holidays,Add to Holidays
apps/erpnext/erpnext/controllers/status_updater.py,Limit Crossed,Limit Crossed
DocType: Company,Transactions Annual History,Godišnja istorija transakcija
DocType: Company,Delete Company Transactions,Izbriši transakcije kompanije
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To State,To State
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Department Stores,Robne kuće
DocType: Healthcare Service Unit,Inpatient Occupancy,Inpatient Occupancy
apps/erpnext/erpnext/controllers/accounts_controller.py,Row {0}: Due Date cannot be before posting date,Red {0}: Datum dospijeća ne može biti prije datuma knjiženja
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please set default customer in Restaurant Settings,Postavite zadanog korisnika u postavkama restorana
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py, Group Roll No,Grupni broj br
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please specify a valid Row ID for row {0} in table {1},Navedite važeći ID retka za redak {0} u tablici {1}
DocType: Asset Movement,To Employee,Za zaposlenika
DocType: Item,End of Life,Kraj života
DocType: Lab Test Template,Sensitivity,Osetljivost
DocType: Territory,Territory Targets,Ciljevi teritorije
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 izdvajanja za sljedeće zaposlenike, jer evidencija o alociranju ostavljanja već postoji protiv njih. {0}"
DocType: Quality Action Resolution,Quality Action Resolution,Rezolucija akcije kvalitete
DocType: Sales Invoice Item,Delivered By Supplier,Isporučeno od dobavljača
DocType: Agriculture Analysis Criteria,Plant Analysis,Plant Analysis
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Expense account is mandatory for item {0},Račun troškova je obavezan za stavku {0}
,Subcontracted Raw Materials To Be Transferred,Podugovorene sirovine koje treba prenijeti
DocType: Cashier Closing,Cashier Closing,Zatvaranje blagajnika
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Item {0} has already been returned,Stavka {0} je već vraćena
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! Unos koji ste uneli ne odgovara GSTIN formatu za UIN nositelje ili nerezidentne OIDAR pružatelje usluga
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Child warehouse exists for this warehouse. You can not delete this warehouse.,Za ovo skladište postoji dječje skladište. Ne možete izbrisati ovo skladište.
DocType: Diagnosis,Diagnosis,Dijagnoza
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,There is no leave period in between {0} and {1},Ne postoji period odlaska između {0} i {1}
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} Budžet za račun {1} za {2} {3} je {4}. Preći će za {5}
DocType: Purchase Invoice Item,Asset Location,Asset Location
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Please enter Difference Account,Unesite Račun razlike
DocType: Journal Entry,Total Credit,Ukupni kredit
DocType: Certified Consultant,Name of Consultant,Ime konsultanta
DocType: Driver,License Number,Broj licence
DocType: Program Enrollment Tool,Program Enrollment Tool,Alat za upis programa
DocType: Amazon MWS Settings,US,US
DocType: Sales Order,Track this Sales Order against any Project,Pratite ovaj prodajni nalog protiv bilo kojeg projekta
DocType: QuickBooks Migrator,Authorization Settings,Postavke autorizacije
DocType: Homepage,Products,Proizvodi
,Profit and Loss Statement,Izvještaj o dobiti i gubitku
apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py,Rooms Booked,Sobe Rezervirano
apps/erpnext/erpnext/stock/doctype/item_manufacturer/item_manufacturer.py,Duplicate entry against the item code {0} and manufacturer {1},Dvostruki unos u odnosu na kôd stavke {0} i proizvođač {1}
DocType: Item Barcode,EAN,EAN
DocType: Purchase Invoice Item,Total Weight,Ukupna tezina
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Travel,Putovanje
,Stock Ledger,Stock Ledger
DocType: Volunteer,Volunteer Name,Ime volontera
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 2 cifre GSTIN-a bi se trebale podudarati s brojem države {0}.
DocType: Quality Inspection,Report Date,Datum izveštaja
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Create Inter Company Journal Entry,Kreirajte inter unos dnevnika
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Enough Parts to Build,Dovoljno delova za izgradnju
DocType: Member,NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Issued Items,Troškovi izdatih artikala
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: Chapter,Chapter Members,Članovi poglavlja
DocType: Warranty Claim,Service Address,Adresa servisa
DocType: Journal Entry,Remark,Napomena
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}),Red {0}: količina nije dostupna za {4} u skladištu {1} u vrijeme objavljivanja unosa ({2} {3})
DocType: Patient Encounter,Encounter Time,Encounter Time
DocType: Serial No,Invoice Details,Detalji fakture
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Further accounts can be made under Groups, but entries can be made against non-Groups","Dodatni računi mogu se vršiti u grupi, ali unosi se mogu vršiti protiv ne-grupa"
apps/erpnext/erpnext/public/js/pos/pos.html,Stock Items,Stock Items
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 neplaćenog iznosa {2}
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Reqd Qty,Reqd Qty
DocType: Vital Signs,Body Temperature,Body Temperature
DocType: Customer Group,Customer Group Name,Naziv grupe korisnika
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total allocated leaves are more than days in the period,Ukupno izdvojeno lišće je više od dana u periodu
DocType: Homepage Section,Section Cards,Section Cards
apps/erpnext/erpnext/config/selling.py,Rules for adding shipping costs.,Pravila za dodavanje troškova dostave.
DocType: Item Price,Valid From,Vrijedi od
DocType: Travel Itinerary,Preferred Area for Lodging,Željena oblast za smještaj
DocType: Student Attendance,Absent,Absent
DocType: Global Defaults,Hide Currency Symbol,Sakrij simbol valute
DocType: Additional Salary,Overwrite Salary Structure Amount,Prepisati iznos strukture plata
DocType: Supplier Quotation,Is Subcontracted,Subcontracted
apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py,Loan Amount cannot exceed Maximum Loan Amount of {0},Iznos kredita ne može premašiti maksimalni iznos kredita od {0}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,BOM does not contain any stock item,Sastav ne sadrži nijednu stavku zaliha
DocType: Employee Skill Map,Employee Skill Map,Mapu vještina zaposlenika
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Marketing,Marketing
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Red # {0}: Nije dozvoljeno menjati dobavljača jer narudžbenica već postoji
DocType: Item,Maximum sample quantity that can be retained,Maksimalna količina uzorka koja se može zadržati
DocType: Staffing Plan,Total Estimated Budget,Ukupni procijenjeni budžet
DocType: Supplier Scorecard Scoring Standing,Standing Name,Stalno ime
DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Potvrdi upisani kurs za studente u studentskoj grupi
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 slanja zaposlenika {1}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,"The total Issue / Transfer quantity {0} in Material Request {1}  \
							cannot be greater than requested quantity {2} for Item {3}",Ukupna količina izdavanja / prenosa {0} u zahtjevu za materijal {1} ne može biti veća od tražene količine {2} za stavku {3}
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js,Please select {0},Odaberite {0}
DocType: Selling Settings,Default Customer Group,Default Customer Group
DocType: Journal Entry Account,Debit in Company Currency,Zaduženje u valuti kompanije
DocType: Woocommerce Settings,"The fallback series is ""SO-WOO-"".",Povratna serija je &quot;SO-WOO-&quot;.
DocType: Quality Meeting Agenda,Quality Meeting Agenda,Program sastanaka o kvalitetu
DocType: Cash Flow Mapper,Section Header,Zaglavlje sekcije
apps/erpnext/erpnext/utilities/user_progress.py,Your Products or Services,Vaše proizvode ili usluge
DocType: Crop,Perennial,Perennial
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Freight and Forwarding Charges,Troškovi špedicije i špedicije
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Last Purchase Price,Poslednja kupovna cijena
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Tax Assets,Poreska imovina
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 za određivanje cijene za &#39;Rate&#39;, on će zamijeniti cjenik. Cenovnik Pravila o cenama je konačna stopa, tako da ne treba primenjivati dodatni popust. Prema tome, u transakcijama kao što su prodajni nalog, narudžbenica i sl., Ona će biti preuzeta u polju &#39;Rate&#39;, a ne u polju &#39;Price List Rate&#39;."
DocType: Share Balance,Share Type,Share Type
DocType: Agriculture Analysis Criteria,Soil Analysis,Analiza tla
DocType: Water Analysis,Water Analysis Criteria,Kriteriji za analizu vode
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,Napomena: Ukupno dodijeljeni listovi {0} ne bi trebali biti manji od već odobrenih listova {1} za period
DocType: Salary Component,Deduction,Odbijanje
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.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Employee Advances,Predujmi zaposlenika
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Provisional Profit / Loss (Credit),Privremeni profit / gubitak (kredit)
DocType: Employee Tax Exemption Category,Max Exemption Amount,Maksimalni iznos izuzimanja
DocType: Timesheet,TS-.YYYY.-,TS-.YYYY.-
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,Različiti UOM za stavke će dovesti do netačne (ukupne) neto težine. Uvjerite se da je neto težina svake stavke u istom UOM-u.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Supplier Quotation,Ponuda dobavljača
DocType: Item,Auto re-order,Auto re-order
DocType: Expense Claim,Total Advance Amount,Ukupni avansni 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 odobrenja {1} ne može biti prije datuma provjere {2}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Can only make payment against unbilled {0},Moguće je izvršiti plaćanje samo za neplaćene {0}
DocType: BOM,Thumbnail,Thumbnail
DocType: Production Plan Item,Planned Qty,Planirana količina
DocType: Tax Withholding Category,Rates,Cijene
DocType: Asset,Journal Entry for Scrap,Unos dnevnika za otpad
DocType: GL Entry,Voucher Detail No,Detalj vaučera br
apps/erpnext/erpnext/stock/doctype/item/item.py,Variant Based On cannot be changed,Variant Based On se ne može promijeniti
DocType: Task,Review Date,Datum pregleda
DocType: Crop,Biennial,Bijenale
DocType: Woocommerce Settings,Endpoints,Krajnje tačke
DocType: Subscription Plan Detail,Plan,Plan
DocType: Employee Education,Year of Passing,Godina prolaska
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Total Tax,Total Tax
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please enter default currency in Company Master,Molimo Vas da unesete valutu valuta u default
DocType: Tally Migration,Processed Files,Obrađene datoteke
DocType: Leave Type,Is Earned Leave,Zaslužuje se odlazak
DocType: Support Search Source,Search Term Param Name,Search Term Param Name
DocType: Sales Invoice,Time Sheets,Time Sheets
DocType: Installation Note,Installation Time,Vreme instalacije
apps/erpnext/erpnext/config/buying.py,Templates of supplier scorecard variables.,Predlošci varijabli pokazatelja dobavljača.
DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Proizvod ili usluga koja se kupuje, prodaje ili drži na skladištu."
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Closing (Opening + Total),Zatvaranje (otvaranje + ukupno)
DocType: Supplier Scorecard Criteria,Criteria Formula,Formula kriterija
apps/erpnext/erpnext/config/support.py,Support Analytics,Support Analytics
DocType: Employee,Attendance Device ID (Biometric/RF tag ID),ID uređaja za prisustvo (Biometric / RF tag ID)
apps/erpnext/erpnext/config/quality_management.py,Review and Action,Pregled i akcija
DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Ako je račun zamrznut, unosi su dozvoljeni ograničenim korisnicima."
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py,Amount After Depreciation,Iznos nakon amortizacije
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Master Data,Uvezite glavne podatke
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} must be active,BOM {0} mora biti aktivan
,GST Sales Register,GST prodajni registar
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice Date cannot be greater than Posting Date,Datum fakture dobavljača ne može biti veći od datuma knjiženja
apps/erpnext/erpnext/utilities/activation.py,Manage your orders,Upravljajte svojim narudžbama
DocType: Supplier Scorecard,Notify Supplier,Notify Supplier
,GSTR-2,GSTR-2
DocType: Sales Invoice,Credit Note Issued,Kreditna oznaka izdata
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py,This covers all scorecards tied to this Setup,Ovo pokriva sve pokazatelje koji su vezani za ovu postavku
DocType: Payment Order,Payment Order Type,Vrsta platnog naloga
DocType: Account,Parent Account,Parent Account
DocType: Maintenance Visit,Unscheduled,Unscheduled
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Issue Material,Materijali za izdavanje
DocType: Work Order,Use Multi-Level BOM,Koristite sastavnicu sa više nivoa
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Qty for {0},Količina za {0}
DocType: Salary Slip,Loan Repayment,Otplata kredita
DocType: Employee Education,Major/Optional Subjects,Glavni / opcioni predmeti
DocType: Soil Texture,Silt,Silt
apps/erpnext/erpnext/config/buying.py,Supplier Addresses And Contacts,Adrese i kontakti dobavljača
DocType: Bank Guarantee,Bank Guarantee Type,Vrsta bankarske garancije
DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Ako je onemogućeno, polje &#39;Zaokruženo ukupno&#39; neće biti vidljivo u bilo kojoj transakciji"
DocType: Pricing Rule,Min Amt,Min Amt
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js,This is a root healthcare service unit and cannot be edited.,Ovo je osnovna jedinica zdravstvene službe i ne može se uređivati.
apps/erpnext/erpnext/regional/italy/setup.py,Set this if the customer is a Public Administration company.,Postavite ovo ako je klijent kompanija za javnu upravu.
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Max benefits should be greater than zero to dispense benefits,Maksimalne beneficije bi trebale biti veće od nule da bi se izostavile koristi
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},Red # {0}: Operacija {1} nije dovršena za {2} količina gotovih proizvoda u radnom nalogu # {3}. Ažurirajte status rada putem Job Card # {4}
DocType: Production Plan Item,Planned Start Date,Planirani datum početka
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Maintenance,Održavanje imovine
DocType: Lead,Interested,Zainteresiran
DocType: Purchase Invoice,Net Total (Company Currency),Neto Ukupno (Valuta Kompanije)
DocType: Salary Component,Depends on Payment Days,Zavisi od dana plaćanja
DocType: Subscription,Taxes,Porezi
DocType: Bank Account,Bank Account,Bankovni račun
DocType: Homepage Section,Section HTML,Odeljak HTML
DocType: Sales Invoice,Packed Items,Packed Items
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,New {0} pricing rules are created,Stvorena su nova {0} pravila za određivanje cijena
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Achieved ({}),Postignuto ({})
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Investment Banking,Investment Banking
DocType: Contract Template,Contract Terms and Conditions,Uvjeti i odredbe ugovora
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Fetch Data,Fetch Data
DocType: Stock Settings,Default Item Group,Default Item Group
DocType: Sales Invoice Timesheet,Billing Hours,Sati plaćanja
apps/erpnext/erpnext/education/doctype/student_leave_application/student_leave_application.py,Leave application {0} already exists against the student {1},Ostavi aplikaciju {0} već postoji protiv studenta {1}
DocType: Pricing Rule,Margin Type,Margin Type
DocType: Purchase Invoice Item,Rejected Serial No,Odbijena serijska br
DocType: Stock Reconciliation Item,Current Amount,Trenutni iznos
apps/erpnext/erpnext/config/retail.py,Setup default values for POS Invoices,Podesite zadane vrijednosti za POS račune
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost as on,Cost as on
apps/erpnext/erpnext/config/projects.py,Project Update.,Project Update.
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root Type is mandatory,Tip Root je obavezan
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}. Molimo vas da ručno kreirate evidenciju valutne razmene
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Billed,{0} Naplaćeno
DocType: Purchase Invoice,Overdue,Zakasnio
DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Količina predmeta dobivenog nakon proizvodnje / prepakiranja iz zadanih količina sirovina
DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Otvaranje stavke alata za kreiranje fakture
DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
DocType: Bank Reconciliation,Include POS Transactions,Uključi POS transakcije
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,No Employee found for the given employee field value. '{}': {},Nema zaposlenika za datu vrijednost polja zaposlenika. &#39;{}&#39;: {}
DocType: Payment Entry,Received Amount (Company Currency),Primljeni iznos (valuta kompanije)
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full, did not save","LocalStorage je pun, nije spasio"
DocType: Chapter Member,Chapter Member,Član ogranka
DocType: Certified Consultant,Certification Validity,Validnost sertifikacije
DocType: Share Transfer,Asset Account,Asset Account
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Suplier,Suplier
DocType: POS Closing Voucher Details,POS Closing Voucher Details,Detalji o kupovini POS-a
DocType: Patient Medical Record,HLC-PMR-.YYYY.-,FHP-PMR-.YYYY.- \ t
DocType: Delivery Settings,Delivery Settings,Postavke isporuke
DocType: Email Digest,Receivables,Potraživanja
DocType: Crop,Annual,Godišnje
DocType: Item Tax Template Detail,Tax Rate,Stopa poreza
DocType: Patient Encounter,Medical Coding,Medical Coding
DocType: Purchase Invoice,Total Quantity,Total Quantity
DocType: Asset,Comprehensive Insurance,Sveobuhvatno osiguranje
DocType: Purchase Invoice Item,Quantity and Rate,Količina i stopa
DocType: Employee Benefit Claim,Max Amount Eligible,Max Amount Eligible
DocType: Salary Slip,Employee Loan,Zajam za zaposlene
DocType: Payment Entry,Account Paid To,Račun plaćen
DocType: Lab Test Template,Single,Jednokrevetna
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Customer required for 'Customerwise Discount',Korisnik potreban za &#39;Customerwise Discount&#39;
DocType: Purchase Invoice,Advance Payments,Advance Payments
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.",Nije moguće osigurati isporuku serijskim brojem kao što je stavka {0} dodana sa i bez Osigurati isporuku od
DocType: Inpatient Record,Discharge Date,Datum otpuštanja
,Open Work Orders,Otvoreni radni nalozi
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 ,"Spisak bolesti otkrivenih na terenu. Kada se izabere, automatski će dodati listu zadataka za rješavanje bolesti"
DocType: SMS Center,All Lead (Open),Sve vode (otvoreno)
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,No Student Groups created.,Nije formirana nijedna studentska grupa.
apps/erpnext/erpnext/utilities/transaction_base.py,Duplicate row {0} with same {1},Dvostruki red {0} sa istim {1}
DocType: Employee,Salary Details,Detalji plata
DocType: Employee Checkin,Exit Grace Period Consequence,Izlazak iz posledice grejs perioda
DocType: Bank Statement Transaction Invoice Item,Invoice,Faktura
DocType: Special Test Items,Particulars,Posebni podaci
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Please set filter based on Item or Warehouse,Postavite filter na osnovu stavke ili skladišta
DocType: Bank Statement Transaction Invoice Item,Outstanding Amount,Preostali iznos
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py,Transactions can only be deleted by the creator of the Company,Transakcije se mogu brisati samo od strane kreatora kompanije
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 stavke &#39;Product Bundle&#39;, Warehouse, Serial No i Batch No će se razmatrati iz tabele &#39;Packing List&#39;. Ako su Skladište i Serijski broj isti za sve pakirne stavke za bilo koju stavku „Paket proizvoda“, te vrijednosti se mogu unijeti u glavnu tablicu artikala, vrijednosti će se kopirati u tablicu „Spisak pakiranja“."
DocType: Lab Test,Submitted Date,Datum slanja
DocType: Delivery Settings,Send with Attachment,Pošalji sa prilogom
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Account {0} does not exists,Račun {0} ne postoji
DocType: BOM Item,BOM No,BOM br
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Avg Daily Outgoing,Avg Daily Outgoing
DocType: Patient,Allergies,Alergije
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order/Quot %,Narudžba / kvota%
DocType: Delivery Note,Transporter Info,Transporter Info
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py,Please select the assessment group other than 'All Assessment Groups',Molimo izaberite grupu za procenu osim &quot;Sve grupe za procenu&quot;
DocType: Leave Encashment,Payroll,Platni spisak
DocType: POS Closing Voucher,Expense Amount,Iznos troškova
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Received On,Received On
DocType: Travel Itinerary,Flight,Let
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Porezi i takse za troškove sletanja
apps/erpnext/erpnext/hr/utils.py,More than one selection for {0} not allowed,Više od jedne selekcije za {0} nije dozvoljeno
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Equity,Neto promjena u kapitalu
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Leaves has been granted sucessfully,Lišće je uspješno izdano
DocType: Loyalty Point Entry,Expiry Date,Datum isteka
DocType: Project Task,Working,Rad
apps/erpnext/erpnext/quality_management/doctype/quality_procedure/quality_procedure.py,{0} already has a Parent Procedure {1}.,{0} već ima nadređenu proceduru {1}.
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py,This is based on transactions against this Patient. See timeline below for details,Ovo se zasniva na transakcijama protiv ovog pacijenta. Za detalje pogledajte vremensku liniju ispod
DocType: Material Request,Requested For,Requested For
DocType: SMS Center,All Sales Person,Sva prodajna osoba
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set default account in Salary Component {0},Molimo vas da postavite podrazumevani račun u Komponenti plata {0}
apps/erpnext/erpnext/www/all-products/not_found.html,No products found,Nema pronađenih proizvoda
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Rezervisana količina za proizvodnju: Količina sirovina za izradu proizvodnih predmeta.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Optional. This setting will be used to filter in various transactions.,Opcionalno. Ova postavka će se koristiti za filtriranje različitih transakcija.
DocType: Stock Entry,Target Warehouse Address,Adresa ciljnog skladišta
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Outward taxable supplies(zero rated),Spoljne oporezive isporuke (nulto)
DocType: Sales Invoice,Customer Address,Adresa klijenta
DocType: Leave Allocation,HR-LAL-.YYYY.-,HR-LAL-.YYYY.-
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Asset {0} does not belong to company {1},Imovina {0} ne pripada tvrtki {1}
apps/erpnext/erpnext/utilities/user_progress.py,Room Capacity,Kapacitet sobe
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select a batch,Molimo odaberite paket
apps/erpnext/erpnext/stock/doctype/item/item.js,Select Attribute Values,Izaberite Vrednosti atributa
DocType: Cheque Print Template,Signatory Position,Pozicija potpisnika
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}: Vrsta stranke i stranka su potrebni za račun potraživanja {1}
apps/erpnext/erpnext/config/manufacturing.py,Production,Proizvodnja
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup post company fixtures,Nije uspelo da se postave instalacije post kompanije
apps/erpnext/erpnext/config/support.py,Communication log.,Dnevnik komunikacije.
DocType: Purchase Invoice Item,Enable Deferred Expense,Omogući Deferred Expense
DocType: Purchase Order,Customer Contact Email,E-pošta za kontakt klijenta
DocType: Clinical Procedure Template,Collection Details,Detalji o zbirci
DocType: Stock Entry Detail,Stock Entry Child,Dijete za upis dionica
DocType: Request for Quotation Supplier,No Quote,No Quote
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Sorry, Serial Nos cannot be merged","Žao nam je, Serijski brojevi se ne mogu spojiti"
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,Ovo se zasniva na transakcijama protiv ove Prodajne osobe. Za detalje pogledajte vremensku liniju ispod
DocType: Course Content,Quiz,Kviz
DocType: Sales Invoice Item,Delivered Qty,Delivered Qty
DocType: Material Request Plan Item,Minimum Order Quantity,Minimalna količina narudžbe
DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Warn Purchase Orders
DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,Uloga koja je dozvoljena za podnošenje transakcija koje prelaze postavljena ograničenja kredita.
DocType: Employee Boarding Activity,Activity Name,Naziv aktivnosti
DocType: Item Barcode,UPC-A,UPC-A
DocType: Shopify Webhook Detail,Shopify Webhook Detail,Shopify Webhook Detail
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Variant Of,Variant Of
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Target warehouse is mandatory for row {0},Ciljno skladište je obavezno za redak {0}
apps/erpnext/erpnext/config/support.py,Warranty,Garancija
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 Email ID
DocType: Expense Claim Detail,Expense Claim Type,Tip potraživanja rashoda
DocType: Email Digest,Bank Balance,Bank Balance
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.","Pravilo određivanja cijena je napravljeno kako bi se prepisao cjenik / definisao postotak popusta, na osnovu nekih kriterija."
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Customer Group is Required in POS Profile,Korisnička grupa je potrebna u POS profilu
DocType: Authorization Rule,Applicable To (Employee),Primjenjivo na (zaposleni)
DocType: Tally Migration,Day Book Data,Podaci o danu knjige
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py,Gross Profit / Loss,Bruto dobit / gubitak
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Credit Note Amount,Iznos kredita
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Payment,Plaćanje
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Capacity Planning Error,Greška planiranja kapaciteta
DocType: Supplier,Prevent POs,Spriječiti PO
DocType: QuickBooks Migrator,Authorization Endpoint,Krajnja točka autorizacije
DocType: Payment Gateway Account,Payment Gateway Account,Račun za Gateway plaćanja
,BOM Variance Report,Izvještaj o odstupanju od sastavnice
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 organizacije kao svoje korisnike. Klijente možete pozvati i na svoj portal tako što ćete ih dodati iz Kontakata
DocType: Training Event,Employee Emails,E-poruke zaposlenika
DocType: Travel Request,Any other details,Bilo koji drugi detalj
DocType: Patient,Inpatient Status,Stanje pacijenta
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Repayment Entry,Kreirajte unos za otplatu
apps/erpnext/erpnext/hr/utils.py,A {0} exists between {1} and {2} (,Postoji {0} između {1} i {2} (
DocType: BOM,Scrap,Scrap
DocType: Clinical Procedure,Clinical Procedure,Klinički postupak
DocType: Supplier,Hold Type,Tip zadržavanja
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Day Book Data,Podaci o danu knjige procesa
DocType: Fee Validity,Fee Validity,Validnost naknade
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Create Fees
DocType: Cheque Print Template,Date Settings,Podešavanja datuma
DocType: BOM Operation,Operation Time,Vreme rada
DocType: Asset,Value After Depreciation,Vrijednost nakon amortizacije
apps/erpnext/erpnext/projects/doctype/project/project.py,Start date of task <b>{0}</b> cannot be less than <b>{1}</b> expected start date <b>{2}</b>,Datum početka zadatka <b>{0}</b> ne može biti manji od <b>{1}</b> očekivanog datuma početka <b>{2}</b>
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Remaining,Preostalo
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Lead Count,Lead Count
apps/erpnext/erpnext/public/js/setup_wizard.js,The name of your company for which you are setting up this system.,Ime vaše kompanije za koju postavljate ovaj sistem.
DocType: Serial No,Out of AMC,Izvan AMC-a
DocType: Job Opening,"Job profile, qualifications required etc.","Profil posla, potrebne kvalifikacije itd."
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Ship To State,Ship to State
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Želite li podnijeti zahtjev za materijal
DocType: Opportunity Item,Basic Rate,Basic Rate
DocType: Compensatory Leave Request,Work End Date,Datum završetka posla
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Request for Raw Materials,Zahtjev za sirovine
apps/erpnext/erpnext/config/quality_management.py,Quality Goal.,Cilj kvaliteta.
apps/erpnext/erpnext/templates/pages/projects.js,Show Open,Show Open
DocType: Item Attribute,Attribute Name,Ime atributa
apps/erpnext/erpnext/config/non_profit.py,Donor Type information.,Informacije o tipu donatora.
DocType: Supplier,Is Transporter,Is Transporter
DocType: Loan Type,Maximum Loan Amount,Maksimalni iznos kredita
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Email not found in default contact,E-pošta nije pronađena u zadanom kontaktu
DocType: Hotel Room Reservation,Booked,Booked
DocType: Maintenance Visit,Partially Completed,Delimično završeno
DocType: Quality Procedure Process,Process Description,Opis procesa
DocType: Company,Default Employee Advance Account,Default Account Advance Account
DocType: Leave Type,Allow Negative Balance,Dopusti negativno stanje
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Assessment Plan Name,Naziv plana procjene
DocType: Supplier,Default Payment Terms Template,Temeljni uvjeti plaćanja
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Add more items or open full form,Dodajte još stavki ili otvorite pun obrazac
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,Work Summary for {0},Sažetak posla za {0}
DocType: Academic Term,Academic Term,Akademski mandat
DocType: Pricing Rule,Quantity and Amount,Količina i iznos
DocType: Stock Entry,Target Warehouse Name,Naziv ciljnog skladišta
DocType: Employee Tax Exemption Declaration Category,Maximum Exempted Amount,Maksimalni izuzeti iznos
DocType: Stock Settings,Sample Retention Warehouse,Skladište za zadržavanje uzorka
DocType: Pricing Rule,Discount Percentage,Procenat popusta
DocType: Company,Company Description,Opis kompanije
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Item {1},Serijski broj {0} ne pripada stavci {1}
DocType: Work Order,Scrap Warehouse,Skladište otpada
apps/erpnext/erpnext/config/non_profit.py,Chapter information.,Informacije o poglavlju.
apps/erpnext/erpnext/hr/utils.py,) for {0},) za {0}
DocType: Sales Invoice Item,References,Reference
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Reserved Qty,Reserved Qty
DocType: Shift Assignment,Shift Type,Shift Type
DocType: Delivery Stop,Delivery Stop,Dostava Stop
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,No Result to submit,Nema rezultata za slanje
DocType: Loyalty Program,Redemption,Redemption
DocType: Material Request,Transferred,Preneseno
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} has fee validity till {1},{0} ima valjanost naknade do {1}
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,All Student Admissions,Sve studentske prijave
DocType: Travel Request,Address of Organizer,Adresa organizatora
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Values of exempt, nil rated and non-GST inward supplies","Vrednosti oslobođenih, nultog i ne-GST unutrašnjih isporuka"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Poseta za održavanje {0} mora biti otkazana pre otkazivanja ovog prodajnog naloga
DocType: Quotation Item,Stock Balance,Stock Balance
DocType: Delivery Note Item,Available Qty at From Warehouse,Dostupan komad od skladišta
DocType: Stock Entry,Repack,Repack
DocType: UOM,Must be Whole Number,Mora biti cijeli broj
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Credit limit has been crossed for customer {0} ({1}/{2}),Prekoračen je kreditni limit za klijenta {0} ({1} / {2})
apps/erpnext/erpnext/accounts/page/pos/pos.js,Submitted orders can not be deleted,Poslani nalozi se ne mogu brisati
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html,Hello,zdravo
DocType: Vehicle Service,Change,Promjena
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,Activity Cost exists for Employee {0} against Activity Type - {1},Troškovi aktivnosti postoje za zaposlenika {0} u odnosu na vrstu aktivnosti - {1}
DocType: Request for Quotation Item,Request for Quotation Item,Zahtjev za stavku ponude
apps/erpnext/erpnext/accounts/doctype/item_tax_template/item_tax_template.py,{0} entered twice in Item Tax,{0} dvaput je uneseno u porez na stavku
DocType: Additional Salary,Deduct Full Tax on Selected Payroll Date,Oduzmi punu porez na izabrani datum plata
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Last carbon check date cannot be a future date,Zadnji datum provjere ugljika ne može biti budući datum
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Select change amount account,Odaberite račun za promjenu iznosa
DocType: Support Settings,Forum Posts,Forum Posts
DocType: Timesheet Detail,Expected Hrs,Očekivani sati
DocType: Subscription Plan,Payment Plan,Plan plaćanja
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Earliest,Najranije
DocType: Program Enrollment Tool,Enroll Students,Upišite studente
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customer Revenue,Ponovite prihode klijenata
DocType: Company,Date of Commencement,Datum početka
DocType: Bank,Bank Name,Ime banke
DocType: GSTR 3B Report,December,Decembar
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from date must be less than valid upto date,Važeći od datuma mora biti manji od važećeg datuma
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,This is based on the attendance of this Employee,Ovo se zasniva na prisustvu ovog zaposlenog
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 grupa predmeta za web lokaciju"
DocType: Crop,Row Spacing UOM,Razmak redova UOM
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Mogu se poslati samo aplikacije koje imaju status &quot;Odobreno&quot; i &quot;Odbijeno&quot;
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Import in Bulk
DocType: Material Request,Terms and Conditions Content,Uvjeti korištenja Sadržaj
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount(Company Currency),Iznos narudžbenice (valuta kompanije)
DocType: Healthcare Practitioner,Hospital,Hospital
,Stock Analytics,Stock Analytics
apps/erpnext/erpnext/controllers/selling_controller.py,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Stopa prodaje za stavku {0} niža je od njene {1}. Stopa prodaje treba da bude najmanje {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Application of Funds (Assets),Primjena sredstava (imovine)
apps/erpnext/erpnext/config/buying.py,Templates of supplier standings.,Šabloni poretka dobavljača.
DocType: Patient,HLC-PAT-.YYYY.-,FHP-PAT-.YYYY.- \ t
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js,Grant,Grant
apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Cjenik Valuta nije odabrana
DocType: Salary Slip,Total in words,Ukupno rečima
DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Ako je omogućeno, sistem će automatski knjižiti knjiženja za inventar."
DocType: BOM Item,BOM Item,BOM Item
DocType: Maintenance Schedule Detail,Scheduled Date,Planirani datum
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please enter Maintaince Details first,Molimo prvo unesite Maintaince Details
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Projected Quantity Formula,Formula projicirane količine
DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Postavljanje rezultata ocjenjivanja dobavljača dobavljača
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the correct code on Mode of Payment {1},Red {0}: postavite ispravan kod na način plaćanja {1}
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of previous claimed\
			amount",Maksimalna korist zaposlenog {0} premašuje {1} za iznos {2} prethodnog traženog iznosa
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 biti postavljen na &quot;Lijevo&quot; jer sljedeći zaposlenici trenutno prijavljuju ovom zaposleniku:
DocType: BOM Explosion Item,Source Warehouse,Izvorno skladište
apps/erpnext/erpnext/utilities/user_progress.py,Add Users,Dodaj korisnike
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Payment Tems,Payment Tems
DocType: SMS Center,All Sales Partner Contact,Svi kontakti prodajnog partnera
apps/erpnext/erpnext/controllers/trends.py,Total(Amt),Ukupno (Amt)
DocType: Bank Statement Transaction Invoice Item,Payment Description,Opis plaćanja
apps/erpnext/erpnext/accounts/page/pos/pos.js,ZIP Code,Poštanski broj
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js,Accumulated Values,Akumulirane vrijednosti
DocType: Grading Scale,Intervals,Intervali
apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py,Training Events,Training Events
DocType: Production Plan Item,Quantity and Description,Količina i opis
DocType: Payment Entry,Payment Type,Vrsta plaćanja
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The folio numbers are not matching,Brojevi folija se ne podudaraju
DocType: C-Form,ACC-CF-.YYYY.-,ACC-CF-.YYYY.-
apps/erpnext/erpnext/controllers/stock_controller.py,Quality Inspection: {0} is not submitted for the item: {1} in row {2},Inspekcija kvalitete: {0} nije poslana za stavku: {1} u redu {2}
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.js,Show {0},Prikaži {0}
apps/erpnext/erpnext/templates/generators/item/item_configure.js,{0} item found.,Pronađena je {0} stavka.
,Stock Ageing,Stock Aging
DocType: Customer Group,Mention if non-standard receivable account applicable,Navedite ako je primjenjiv račun nestandardnog potraživanja
,Subcontracted Item To Be Received,Podugovorna stavka koju treba primiti
DocType: Item,Synced With Hub,Sinhronizovano sa Hubom
apps/erpnext/erpnext/hr/utils.py,To date can not be less than from date,Do danas ne može biti manje od datuma
DocType: Guardian,Work Address,Adresa posla
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Total completed qty can not be greater than for quantity,Ukupna završena količina ne može biti veća od količine
DocType: POS Item Group,POS Item Group,POS Item Group
DocType: Homepage,Company Description for website homepage,Opis kompanije za početnu stranicu sajta
,Delivery Note Trends,Trendovi napomene za isporuku
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,"Stopped Production Order cannot be cancelled, Unstop it first to cancel",Zaustavljeni proizvodni nalog se ne može otkazati
DocType: Share Balance,Current State,Trenutna drzava
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open Item {0},Otvori stavku {0}
,Batch-Wise Balance History,Batch-Wise Balance History
DocType: Monthly Distribution Percentage,Percentage Allocation,Dodeljivanje procenta
DocType: Vital Signs,One Sided,One Sided
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian2,Odnos sa Guardian2
DocType: Asset,Disposal Date,Datum odlaganja
DocType: Opportunity,Opportunity Type,Opportunity Type
DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Predložak za mapiranje novčanog toka
DocType: Asset Settings,Depreciation Options,Opcije amortizacije
DocType: Student Admission,Admission Start Date,Datum početka prijema
DocType: Manufacturing Settings,Update BOM Cost Automatically,Automatsko ažuriranje BOM troškova
DocType: Subscription Settings,Subscription Settings,Postavke pretplate
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CGST Amount,CGST Iznos
DocType: Amazon MWS Settings,Seller ID,ID prodavca
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,'To Case No.' cannot be less than 'From Case No.',&#39;Za slučaj br.&#39; ne može biti manja od &quot;Iz slučaja br.&quot;
DocType: Fee Schedule,EDU-FSH-.YYYY.-,EDU-FSH-.YYYY.- \ t
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 su slijedeća svojstva u oba zapisa ista. Da li je Grupa, Root Type, Company"
DocType: SMS Log,SMS Log,SMS Log
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please specify either Quantity or Valuation Rate or both,Navedite količinu ili stopu procjene ili oboje
DocType: Salary Component,Amount based on formula,Iznos na osnovu formule
DocType: Clinical Procedure Item,Transfer Qty,Transfer Qty
apps/erpnext/erpnext/setup/doctype/company/company.js,Cost Centers,Centri troškova
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Serija je obavezna u redu {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Error in formula or condition: {0},Greška u formuli ili uslovu: {0}
apps/erpnext/erpnext/controllers/accounts_controller.py,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Da biste uključili porez u redu {0} u stavku Stavka, porezi u redovima {1} takođe moraju biti uključeni"
,Trial Balance (Simple),Probno stanje (jednostavno)
DocType: Purchase Order,Customer Contact,Kontakt sa kupcima
DocType: Marketplace Settings,Registered,Registriran
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Gross Purchase Amount is mandatory,Bruto iznos kupovine je obavezan
DocType: Fee Structure,Components,Komponente
DocType: Pricing Rule,Promotional Scheme,Promotivna šema
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Account {1} does not belong to company {2},Red # {0}: Korisnički račun {1} ne pripada tvrtki {2}
DocType: Quotation Item,Against Doctype,Against Doctype
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Total flexible benefit component amount {0} should not be less than max benefits {1},Ukupna fleksibilna visina komponente kompenzacije {0} ne smije biti manja od maksimalne koristi {1}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From GSTIN,From GSTIN
DocType: Sales Invoice,Return Against Sales Invoice,Povratak protiv fakture prodaje
DocType: Item Variant Settings,Rename Attribute Value in Item Attribute.,Preimenuj vrijednost atributa u atributu stavke.
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 za ažuriranje najnovije cijene u svim materijalima. Može potrajati nekoliko minuta.
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select a warehouse,Molimo odaberite skladište
DocType: Purchase Invoice Item,Weight UOM,Težina UOM
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Accounts Payable Summary,Sažetak obaveza prema računima
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Order {1},{0} protiv prodajnog naloga {1}
DocType: Payroll Employee Detail,Payroll Employee Detail,Payroll Employee Detail
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Admission and Enrollment,Prijem i upis
DocType: Budget Account,Budget Amount,Iznos budžeta
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py,Account {0} does not match with Company {1} in Mode of Account: {2},Račun {0} se ne podudara sa kompanijom {1} u načinu korisničkog računa: {2}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Please enter Receipt Document,Molimo vas da unesete dokument o prijemu
DocType: Naming Series,Change the starting / current sequence number of an existing series.,Promijenite početni / trenutni redni broj postojeće serije.
apps/erpnext/erpnext/config/hr.py,Employee Lifecycle,Životni ciklus zaposlenika
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Quantity must be less than quantity {0},Za količinu mora biti manja od količine {0}
DocType: Assessment Plan,Assessment Plan,Plan procjene
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js,Warranty Claim,Warranty Claim
DocType: Company,Date of Incorporation,Datum osnivanja
DocType: Asset,Double Declining Balance,Double Declining Balance
DocType: Payroll Entry,Validate Attendance,Validate Attendance
DocType: Lab Test,LP-,LP-
DocType: POS Customer Group,POS Customer Group,POS Customer Group
,Qty to Deliver,Količina za isporuku
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} is required,Potrebna je fiskalna godina {0}
DocType: HR Settings,Employee Records to be created by,Zapise o zaposlenicima koje će kreirati
DocType: Depreciation Schedule,Depreciation Amount,Amortizacija Iznos
DocType: Sales Order Item,Gross Profit,Bruto dobit
DocType: Quality Inspection,Item Serial No,Serijska br
DocType: Asset,Insurer,Osiguravatelj
DocType: Employee Checkin,OUT,OUT
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Buying Amount,Kupovni iznos
DocType: Asset Maintenance Task,Certificate Required,Potreban certifikat
DocType: Retention Bonus,Retention Bonus,Bonus za zadržavanje
DocType: Item,Asset Naming Series,Serije imenovanja imovine
DocType: Healthcare Settings,Laboratory Settings,Laboratorijske postavke
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Amount of Integrated Tax,Iznos integrisanog poreza
DocType: Branch,Branch,Branch
DocType: Request for Quotation Item,Required Date,Potreban datum
DocType: Cashier Closing,Returns,Returns
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Negotiation/Review,Pregovaranje / pregled
,Stock Summary,Stock Summary
DocType: Bank Reconciliation,From Date,From Date
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 tražiti samo iznos od {0}, ostatak iznosa {1} treba da bude u aplikaciji kao pro-rata komponenta"
DocType: Warehouse,A logical Warehouse against which stock entries are made.,Logičko skladište prema kojem se vrši unos zaliha.
DocType: Stock Entry Detail,Difference Account,Račun razlike
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Ovo će dostaviti Isplate plata i kreirati unos dnevnika obračuna. Želite li nastaviti?
DocType: Manufacturer,Manufacturers used in Items,Proizvođači koji se koriste u artiklima
apps/erpnext/erpnext/education/__init__.py,Student {0} does not belong to group {1},Student {0} ne pripada grupi {1}
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Održavati istu stopu tokom ciklusa kupovine
apps/erpnext/erpnext/setup/doctype/company/company.py,Set default inventory account for perpetual inventory,Postavite standardni račun inventara za trajni inventar
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Pending,Stvaranje naknade na čekanju
DocType: Accounts Settings,Unlink Advance Payment on Cancelation of Order,Isključite plaćanje unaprijed prilikom otkaza naloga
apps/erpnext/erpnext/config/crm.py,Visit report for maintenance call.,Posjetite izvješće za poziv na održavanje.
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 od ERPNexta, preporučujemo vam da odvojite malo vremena i pogledate ove video snimke pomoći."
DocType: Fertilizer Content,Fertilizer Content,Sadržaj đubriva
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot delete Serial No {0}, as it is used in stock transactions","Nije moguće obrisati serijski broj {0}, jer se koristi u transakcijama sa zalihama"
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Charges are updated in Purchase Receipt against each item,Troškovi se ažuriraju u Potvrdi kupovine za svaku stavku
DocType: Account,Credit,Kredit
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Download JSON,Download JSON
DocType: Sales Invoice,Loyalty Amount,Iznos lojalnosti
DocType: Account,Accounts,Računi
DocType: Loyalty Program,Expiry Duration (in days),Trajanje isteka (u danima)
DocType: Pricing Rule,Product Discount Scheme,Šema proizvoda za popust
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Creating Company and Importing Chart of Accounts,Kreiranje kompanijskog i uvoznog kontnog plana
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Stock Available,Stock Available
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign to Employees,Dodeli zaposlenima
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,No employees for the mentioned criteria,Nema zaposlenih za navedene kriterije
apps/erpnext/erpnext/accounts/page/pos/pos.js,Not items found,Nije pronađena nijedna stavka
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Job card {0} created,Napravljena je kartica posla {0}
DocType: Delivery Note,Is Return,Is Return
DocType: Soil Analysis Criteria,Soil Analysis Criteria,Kriteriji analize tla
DocType: Quiz Result,Selected Option,Selected Option
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Preview Salary Slip,Preview Salary Slip
DocType: Asset,Assets,Imovina
DocType: Pricing Rule,Rate or Discount,Rate ili Discount
DocType: Travel Itinerary,Non-Vegetarian,Non-Vegetarian
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Outstanding: {0},Total Outstanding: {0}
DocType: Appraisal,For Employee Name,Za Ime zaposlenika
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js,Unknown,Nepoznato
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Offline Invoices,Sync Offline Invoices
DocType: Practitioner Schedule,Schedule Name,Schedule Name
DocType: Shopify Settings,Shopify Settings,Shopify Settings
DocType: Company,Sales Monthly History,Povijest prodaje
apps/erpnext/erpnext/stock/doctype/item/item.py,'Has Serial No' can not be 'Yes' for non-stock item,&#39;Ima serijski broj&#39; ne može biti &#39;Da&#39; za ne-zalihu stavku
apps/erpnext/erpnext/regional/report/hsn_wise_summary_of_outward_supplies/hsn_wise_summary_of_outward_supplies.py,Total Taxable Amount,Ukupno oporezivi iznos
apps/erpnext/erpnext/controllers/item_variant.py,Invalid attribute {0} {1},Nevažeći atribut {0} {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial no {0} has been already returned,Serijski broj {0} je već vraćen
DocType: Maintenance Schedule,MAT-MSH-.YYYY.-,MAT-MSH-.YYYY.-
DocType: Student Group Student,Group Roll Number,Group Roll Number
DocType: QuickBooks Migrator,Default Shipping Account,Default Shipping Account
DocType: Work Order,MFG-WO-.YYYY.-,MFG-WO-.YYYY.-
DocType: Subscription,Trialling,Trialling
DocType: Loyalty Program,Single Tier Program,Program jednog reda
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Against Loan: {0},Protiv zajma: {0}
DocType: Tax Withholding Category,Tax Withholding Rates,Cijene po odbitku poreza
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Community Forum,Community Forum
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Account Type for {0} must be {1},Vrsta računa za {0} mora biti {1}
DocType: Purchase Receipt Item Supplied,Required Qty,Potreban kom
apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py,Please select Completion Date for Completed Repair,Odaberite Datum završetka za dovršenu popravku
DocType: Clinical Procedure,Medical Department,Medical Department
DocType: Share Transfer,From Shareholder,From Shareholder
DocType: Company,Default Terms,Default Terms
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Time Slots,Dodajte vremenske slotove
DocType: Sales Order Item,Ensure Delivery Based on Produced Serial No,Obezbedite isporuku na osnovu proizvedenog serijskog broja
,Eway Bill,Eway Bill
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Sub Type,Sub Type
DocType: Task,Closing Date,Datum zatvaranja
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Go to the Desktop and start using ERPNext,Idite na radnu površinu i počnite koristiti ERPNext
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Duplicate Serial No entered for Item {0},Dvostruki serijski broj unesen za stavku {0}
DocType: Item Price,Packing Unit,Packing Unit
DocType: Travel Request,International,International
DocType: Item Tax Template Detail,Item Tax Template Detail,Detalji šablona poreza na stavku
DocType: BOM Update Tool,New BOM,New BOM
DocType: Supplier,Is Internal Supplier,Je unutrašnji dobavljač
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Reject,Odbaci
DocType: Salary Slip,net pay info,net pay info
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Duties and Taxes,Dužnosti i porezi
DocType: Appraisal Goal,Score Earned,Score Earned
DocType: Task,Dependent Tasks,Zavisni zadaci
DocType: Tax Rule,Shipping Zipcode,Shipping Zipcode
DocType: Naming Series,Update Series,Update Series
apps/erpnext/erpnext/public/js/setup_wizard.js,"e.g. ""Build tools for builders""",npr. &quot;Build tools for builders&quot;
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Prospecting,Prospecting
DocType: Bank Statement Transaction Entry,Bank Statement,Izjava banke
DocType: Appointment Type,Default Duration,Default Duration
apps/erpnext/erpnext/config/buying.py,Default settings for buying transactions.,Podrazumevana podešavanja za kupovinu transakcija.
DocType: Work Order Operation,Actual Time and Cost,Stvarno vrijeme i trošak
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Evaluation,Evaluacija
apps/erpnext/erpnext/controllers/accounts_controller.py,Account: {0} with currency: {1} can not be selected,Račun: {0} sa valutom: {1} nije moguće odabrati
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Lifecycle,Životni ciklus
DocType: Student Sibling,Studying in Same Institute,Studira u istom institutu
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Course Code: ,Šifra predmeta:
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution %,Doprinos%
DocType: Journal Entry,Credit Note,Napomena o kreditu
DocType: Batch,Parent Batch,Parent Batch
DocType: Payment Reconciliation,Get Unreconciled Entries,Get Unreconciled Entries
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Please set the Company,Molimo postavite kompaniju
DocType: Lead,Lead Type,Lead Type
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 mora biti isti kao i datum kupovine {1} imovine {2}
DocType: Payment Entry,Difference Amount (Company Currency),Iznos razlike (valuta kompanije)
DocType: Invoice Discounting,Sanctioned,Sankcionirano
DocType: Course Enrollment,Course Enrollment,Upis predmeta
DocType: Item,Supplier Items,Artikli dobavljača
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,"Start Time can't be greater than or equal to End Time \
					for {0}.",Vrijeme početka ne može biti veće ili jednako vremenu završetka za {0}.
DocType: Sales Order,Not Applicable,Nije primjenjivo
DocType: Support Search Source,Response Options,Opcije odgovora
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py,{0} should be a value between 0 and 100,{0} treba da bude vrednost između 0 i 100
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Sales Person,Prodajna osoba
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Packing Slip,Otpremnici
apps/erpnext/erpnext/config/manufacturing.py,Global settings for all manufacturing processes.,Globalne postavke za sve proizvodne procese.
DocType: Shopify Settings,Customer Group will set to selected group while syncing customers from Shopify,"Korisnička grupa postaviće se na odabranu grupu, a sinhronizira kupce iz Shopify-a"
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Apply Now,Apply Now
DocType: Accounts Settings,Credit Controller,Credit Controller
DocType: BOM,Exploded_items,Exploded_items
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Done,Gotovo
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Manufacturing Quantity is mandatory,Količina proizvodnje je obavezna
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Bypass credit check at Sales Order ,Zaobiđite provjeru kredita kod prodajnog naloga
DocType: Bin,Stock Value,Stock Value
apps/erpnext/erpnext/config/accounting.py,Tax template for item tax rates.,Šablon poreza za stope poreza na artikle.
apps/erpnext/erpnext/accounts/party.py,{0} {1} is not active,{0} {1} nije aktivan
DocType: Inpatient Record,O Positive,O Positive
DocType: Training Event,Training Program,Program obuke
DocType: Cashier Closing Payments,Cashier Closing Payments,Blagajnik Zatvaranje plaćanja
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;Od paketa br.&#39; polje ne smije biti prazno niti je vrijednost manja od 1.
,Purchase Order Trends,Trendovi narudžbenice
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Please enter parent cost center,Unesite matično troškovno mjesto
DocType: Purchase Receipt,Supplier Delivery Note,Napomena za isporuku dobavljača
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Drug,Izaberite Drug
DocType: Support Settings,Post Route Key,Ključ za putanju posta
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Student Admissions,Student Admissions
apps/erpnext/erpnext/config/non_profit.py,Memebership Details,Memebership Details
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Probation,Probation
,Inactive Sales Items,Neaktivne prodajne jedinice
DocType: Amazon MWS Settings,AU,AU
DocType: Vital Signs,Abdomen,Abdomen
DocType: HR Settings,Employee Settings,Postavke zaposlenika
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Arrear,Arrear
apps/erpnext/erpnext/config/buying.py,Supplier Group master.,Master Group dobavljača.
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py,A customer with the same name already exists,Korisnik s istim imenom već postoji
DocType: Course Enrollment,Program Enrollment,Program Enrollment
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}",Otvorena radna mjesta za oznaku {0} već otvorena ili zapošljavanje završeno prema planu osoblja {1}
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Ovlašteni potpisnik
DocType: Pricing Rule,Discount on Other Item,Popust na drugu stavku
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot Count,Quot Count
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Nema studenata
DocType: Journal Entry,Bank Entry,Ulazak banke
DocType: Antibiotic,Antibiotic,Antibiotik
DocType: Stock Settings,Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.,"Postotak kojem je dozvoljeno da primite ili dostavite više u odnosu na naručenu količinu. Na primjer: Ako ste naručili 100 jedinica. i vaša dozvola je 10%, onda vam je dozvoljeno da primite 110 jedinica."
apps/erpnext/erpnext/config/support.py,Support queries from customers.,Podrška upitima od kupaca.
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Actual,Actual
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Material Requests in the above table,Molimo vas da u gornju tabelu unesete Upit za materijal
DocType: Item Reorder,Item Reorder,Item Reorder
DocType: Company,Stock Settings,Stock Settings
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No is mandatory,Red # {0}: Serijski broj je obavezan
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. 3 kartice će biti prikazane po redu ako odaberete 3 stupca.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py,Consultations,Konsultacije
DocType: Employee Benefit Claim,Claim Benefit For,Zahtjev za korist za
DocType: Fiscal Year,Year Name,Ime godine
DocType: Bank Statement Transaction Entry,Reconciled Transactions,Usklađene transakcije
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: Sistem neće proveravati over-delivery i over-booking za stavku {0} jer je količina ili iznos 0
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,Opening Balance,Otvaranje balansa
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,'From Date' must be after 'To Date',&#39;Od datuma&#39; mora biti nakon &#39;Datum&#39;
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Total Amount {0},Ukupan iznos {0}
DocType: Employee Skill,Evaluation Date,Datum ocjene
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot be Purchase Item also",&quot;Korisnički dostavljena stavka&quot; ne može biti i predmet kupovine
DocType: C-Form Invoice Detail,Grand Total,Grand Total
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 manji od tekućeg iznosa za klijenta. Kreditni limit mora biti atleast {0}
apps/erpnext/erpnext/shopping_cart/cart.py,Only {0} in stock for item {1},Samo {0} na lageru za stavku {1}
DocType: Payment Reconciliation,Bank / Cash Account,Bankovni / gotovinski račun
apps/erpnext/erpnext/projects/doctype/project/project.py,Task weight cannot be negative,Težina zadatka ne može biti negativna
DocType: Serial No,Creation Date,Datum kreiranja
apps/erpnext/erpnext/manufacturing/report/bom_variance_report/bom_variance_report.py,Finished Good,Gotovo dobro
DocType: Healthcare Settings,Manage Sample Collection,Upravljajte prikupljanje uzoraka
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Unable to find DocType {0},Nije moguće pronaći DocType {0}
DocType: Purchase Invoice Item,Item Weight Details,Stavka Težina Detalji
DocType: POS Closing Voucher,Modes of Payment,Načini plaćanja
DocType: Naming Series,Series List for this Transaction,Lista serija za ovu transakciju
DocType: Crop,Produce,Proizvesti
DocType: Woocommerce Settings,API consumer key,Ključ potrošača API
DocType: Quality Inspection Reading,Reading 2,Čitanje 2
DocType: Driver,Driving License Categories,Kategorije vozačke dozvole
DocType: Asset Repair,Asset Repair,Popravka imovine
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation,Revalorizacija deviznog kursa
DocType: Warehouse,Warehouse Contact Info,Informacije o skladištu skladišta
DocType: Request for Quotation Supplier,Request for Quotation Supplier,Zahtjev za dobavljač ponude
DocType: Travel Request,Costing,Costing
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Fixed Assets,Fiksna sredstva
DocType: Purchase Order,Ref SQ,Ref SQ
DocType: Salary Structure,Total Earning,Totalna zarada
DocType: Share Balance,From No,From No
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Račun poravnanja plaćanja
DocType: Purchase Invoice,Taxes and Charges Added,Dodati porezi i naknade
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Razmotrite porez ili nadoknadu za
DocType: Authorization Rule,Authorized Value,Ovlašćena vrijednost
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Received From,Primljeno od
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} does not exist,Skladište {0} ne postoji
DocType: Item Manufacturer,Item Manufacturer,Item Manufacturer
DocType: Sales Invoice,Sales Team,Prodajni tim
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,Bundle Qty,Bundle Qty
DocType: Purchase Order Item Supplied,Stock UOM,Stock UOM
DocType: Installation Note,Installation Date,Datum instalacije
DocType: Email Digest,New Quotations,New Quotations
DocType: Production Plan Item,Ordered Qty,Naređen kom
,Minutes to First Response for Issues,Minuta do prvog odgovora na pitanja
DocType: Vehicle Log,Refuelling Details,Detalji o punjenju goriva
DocType: Sales Partner,Targets,Ciljevi
DocType: Buying Settings,Settings for Buying Module,Postavke za modul kupovine
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Purchase Order {0} is not submitted,Nalog za kupovinu {0} nije dostavljen
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Material Request {0} submitted.,Podnesen je zahtev za materijal {0}.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Posting date and posting time is mandatory,Datum i vrijeme knjiženja su obavezni
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,{} of {},{} od {}
DocType: Lab Test Template,Lab Routine,Lab Routine
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Failed. Please check your GoCardless Account for more details,Plaćanje nije uspelo. Molimo Vas da provjerite svoj GoCardless račun za više detalja
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 završnog datuma
apps/erpnext/erpnext/config/education.py,LMS Activity,LMS Activity
DocType: Asset,Next Depreciation Date,Sledeći datum amortizacije
DocType: Healthcare Settings,Appointment Reminder,Podsetnik za sastanak
DocType: Cost Center,Cost Center Name,Naziv centra troškova
DocType: Pricing Rule,Margin Rate or Amount,Margina ili iznos
DocType: Healthcare Settings,Clinical Procedure Consumable Item,Klinički postupak Potrošna jedinica
DocType: Asset,Manual,Manual
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Raw Materials cannot be blank.,Sirovine ne mogu biti prazne.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please enter Cost Center,Unesite Centar troškova
DocType: Support Search Source,Source DocType,Source DocType
DocType: Assessment Group,Parent Assessment Group,Grupa za procjenu roditelja
DocType: Purchase Invoice Item,Accepted Warehouse,Prihvaćeno skladište
DocType: Sales Invoice Item,Discount and Margin,Popust i marža
,Student and Guardian Contact Details,Detalji kontakta sa studentima i starateljima
DocType: Pricing Rule,Buying,Kupovina
DocType: Student Attendance,Present,Present
DocType: Membership,Member Since,Član od
DocType: Tax Rule,Use for Shopping Cart,Koristite za Košaricu
DocType: Loan,Loan Account,Kreditni račun
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,All the mandatory Task for employee creation hasn't been done yet.,Svi obavezni zadaci za kreiranje zaposlenika još nisu obavljeni.
DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Minimalna dužina između svakog postrojenja u polju za optimalan rast
DocType: Budget,Applicable on Purchase Order,Primjenjivo na narudžbenici
DocType: Stock Entry,Receive at Warehouse,Primite na skladištu
DocType: Cash Flow Mapping,Is Income Tax Expense,Trošak poreza na dohodak
DocType: Journal Entry,Make Difference Entry,Make Difference Entry
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Total (Credit),Ukupno (kredit)
apps/erpnext/erpnext/public/js/setup_wizard.js,The Brand,The Brand
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 3,Tačka 3
DocType: Purchase Invoice Item,Deferred Expense Account,Odloženi račun troškova
DocType: Depreciation Schedule,Accumulated Depreciation Amount,Iznos akumulirane amortizacije
apps/erpnext/erpnext/controllers/stock_controller.py,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Centar troška je obavezan za stavku {2}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,No accounting entries for the following warehouses,Nema računovodstvenih unosa za sljedeća skladišta
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Please save first,Prvo sačuvajte
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Extra Small,Extra Small
DocType: Assessment Group,Assessment Group,Grupa za procenu
DocType: Pricing Rule,UOM,UOM
apps/erpnext/erpnext/config/accounting.py,Bills raised by Suppliers.,Računi koje podnose dobavljači.
DocType: Additional Salary,HR User,HR User
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py,Profit for the year,Dobit za godinu
DocType: Codification Table,Medical Code,Medical Code
apps/erpnext/erpnext/config/accounting.py,Update bank payment dates with journals.,Ažurirajte datume plaćanja banaka sa časopisima.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Current Assets,Tekuća imovina
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} does not belong to company {2},Red # {0}: Imovina {1} ne pripada tvrtki {2}
DocType: Purchase Invoice,Contact Person,Kontakt osoba
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Batch {2},{0} - {1} nije upisano u paket {2}
DocType: Holiday List,Holiday List Name,Ime praznične liste
DocType: Water Analysis,Collection Temperature ,Temperature Collection
DocType: Healthcare Settings,Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Upravljajte dostavnicom za naplatu i automatski otkažite za Pacijentov susret
DocType: Employee Benefit Claim,Claim Date,Datum potraživanja
DocType: Supplier,Leave blank if the Supplier is blocked indefinitely,Ostavite prazno ako je dobavljač blokiran na neodređeno vrijeme
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Attendance From Date and Attendance To Date is mandatory,Prisustvo od datuma i prisustva do datuma je obavezno
DocType: Serial No,Out of Warranty,Izvan garancije
apps/erpnext/erpnext/buying/utils.py,Same item cannot be entered multiple times.,Ista stavka se ne može unijeti više puta.
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Select students manually for the Activity based Group,Ručno izaberite učenike za grupu baziranu na aktivnosti
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Series Updated,Series Updated
DocType: Employee,Date Of Retirement,Datum povlačenja
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Please select Patient,Odaberite Pacijent
DocType: Asset,Straight Line,Duž
DocType: Quality Action,Resolutions,Rezolucije
DocType: SMS Log,No of Sent SMS,Broj poslanih SMS poruka
,GST Itemised Sales Register,GST Detaljan prodajni registar
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Ukupni iznos akontacije ne može biti veći od ukupnog iznosa sankcije
DocType: Lab Test,Test Name,Test Name
DocType: Task,Total Billing Amount (via Time Sheet),Ukupni iznos naplate (putem vremenskog lista)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Quotation {0} is cancelled,Ponuda {0} je otkazana
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Clear values,Clear values
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Traceability,Sljedivost
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py,Same Company is entered more than once,Ista kompanija se unosi više od jednom
DocType: Delivery Stop,Contact Name,ime kontakta
DocType: Customer,Is Internal Customer,Je li interni korisnik
DocType: Purchase Taxes and Charges,Account Head,Account Head
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Lower Income,Lower Income
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py,Start date should be less than end date for task {0},Početni datum treba biti manji od završnog datuma za zadatak {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Customer Service,Korisnička podrška
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Fee
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} does not belong to Item {1},BOM {0} ne pripada stavci {1}
DocType: Daily Work Summary,Daily Work Summary Group,Dnevna grupa za pregled rada
apps/erpnext/erpnext/config/help.py,Customizing Forms,Prilagođavanje obrazaca
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Cancel Material Visit {0} before cancelling this Warranty Claim,Otkazivanje materijala Posetite {0} pre otkazivanja ovog zahteva za garanciju
DocType: POS Profile,Ignore Pricing Rule,Zanemari pravilo o cenama
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Food,Hrana
DocType: Lost Reason Detail,Lost Reason Detail,Izgubljeni razlog Detalj
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,The following serial numbers were created: <br> {0},Kreirani su sljedeći serijski brojevi: <br> {0}
DocType: Maintenance Visit,Customer Feedback,Povratne informacije klijenta
DocType: Serial No,Warranty / AMC Details,Detalji garancije / AMC-a
DocType: Issue,Opening Time,Vreme otvaranja
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,View a list of all the help videos,Pogledajte listu svih videozapisa za pomoć
DocType: Purchase Invoice,Party Account Currency,Valuta računa računa
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 numeričke tipkovnice
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Kriteriji plana procjene
DocType: Products Settings,Item Fields,Field Fields
apps/erpnext/erpnext/config/selling.py,Manage Sales Partners.,Upravljanje prodajnim partnerima.
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 napravljena kotacija.
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Ovdje možete održavati obiteljske detalje kao što su ime i zanimanje roditelja, supružnika i djece"
DocType: Tax Rule,Shipping City,Shipping City
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update Items,Ažuriraj stavke
,Customer Ledger Summary,Sažetak knjige
DocType: Inpatient Record,B Positive,B Positive
apps/erpnext/erpnext/config/accounting.py,Accounting journal entries.,Računovodstveni unosi u dnevnik.
DocType: Buying Settings,Purchase Order Required,Obavezna narudžbenica
DocType: Program Enrollment Tool,New Student Batch,New Student Batch
DocType: Account,Account Type,Vrsta računa
DocType: Vehicle,Fuel Type,Vrsta goriva
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Email sent to {0},E-pošta poslana na {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Change Release Date,Promijeni datum izdavanja
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Default BOM for {0} not found,Default BOM za {0} nije pronađen
,HSN-wise-summary of outward supplies,HSN-mudar sažetak spoljnih zaliha
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py,Appointments and Encounters,Sastanci i susreti
DocType: Tax Withholding Category,Tax Withholding Category,Kategorija zadržavanja poreza
DocType: Agriculture Analysis Criteria,Linked Doctype,Linked Doctype
DocType: Account,Cost of Goods Sold,Troškovi prodane robe
DocType: Quality Inspection Reading,Reading 3,Čitanje 3
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Voucher,Grupa po vaučeru
,Delivered Items To Be Billed,Isporučene stavke koje će se naplaćivati
DocType: Employee Transfer,Employee Transfer Details,Detalji o transferu zaposlenih
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Registracijski brojevi za vašu referencu. Poreski brojevi itd.
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Warehouse {1},Serijski broj {0} ne pripada Warehouseu {1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Del,Del
apps/erpnext/erpnext/templates/pages/task_info.html,on,on
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 koje je potrebno izvršiti za ovaj usjev. Dansko polje se koristi da označi dan na koji je potrebno izvršiti zadatak, 1 je prvi dan, itd."
DocType: Asset Maintenance Log,Task,Zadatak
DocType: Naming Series,Help HTML,Help HTML
DocType: Drug Prescription,Dosage by time interval,Doziranje po vremenskom intervalu
DocType: Batch,Batch Description,Opis serije
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py,Please set associated account in Tax Withholding Category {0} against Company {1},Postavite pridruženi račun u kategoriji zadržavanja poreza {0} protiv tvrtke {1}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Needs Analysis,Analiza potreba
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Allocated Leaves,Dodijeljeni listovi
DocType: Payment Request,Transaction Details,Detalji transakcije
DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Objavite &quot;In Stock&quot; ili &quot;Not in Stock&quot; na Hub-u na osnovu zaliha dostupnih u ovom skladištu.
apps/erpnext/erpnext/setup/doctype/company/company.js,Company name not same,Ime kompanije nije isto
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Employee Promotion cannot be submitted before Promotion Date ,Promocija zaposlenika ne može se podnijeti prije datuma promocije
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Not allowed to update stock transactions older than {0},Nije dozvoljeno ažurirati transakcije zalihama starije od {0}
DocType: Employee Checkin,Employee Checkin,Zaposleni Checkin
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Start date should be less than end date for Item {0},Datum početka treba biti manji od datuma završetka za stavku {0}
apps/erpnext/erpnext/utilities/activation.py,Create customer quotes,Kreirajte ponude za kupce
DocType: Buying Settings,Buying Settings,Buying Settings
DocType: Restaurant Menu Item,Restaurant Menu Item,Menu Menu Item
DocType: Appraisal,Calculate Total Score,Izračunaj ukupan rezultat
DocType: Issue,Issue Type,Type Type
apps/erpnext/erpnext/projects/doctype/project/project.py,Start date of task <b>{0}</b> cannot be greater than <b>{1}</b> expected end date <b>{2}</b>,Datum početka zadatka <b>{0}</b> ne može biti veći od <b>{1}</b> očekivanog datuma završetka <b>{2}</b>
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Balance Value,Balance Value
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Groups,Grupe
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 redu {0} mora biti isto kao i radni nalog
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Serial Number: {0} is already referenced in Sales Invoice: {1},Serijski broj: {0} je već naveden u dostavnici: {1}
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 klijenta u narudžbi, onda dok sinhronizuje narudžbe, sistem će uzeti u obzir zadanog klijenta za narudžbu"
DocType: Shopify Settings,Shopify Tax Account,Shopify Tax Account
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.,Provjerite da li zaista želite izbrisati sve transakcije za ovu tvrtku. Vaši matični podaci ostaju onakvi kakvi jesu. Ova akcija se ne može poništiti.
DocType: Purchase Receipt,Auto Repeat Detail,Auto Repeat Detail
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Please supply the specified items at the best possible rates,Molimo Vas da dostavite navedene artikle po najboljoj mogućoj cijeni
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} in row {1},{0} u redu {1}
DocType: Job Card Time Log,Job Card Time Log,Dnevnik radnog vremena
DocType: Patient,Patient Demographics,Patient Demographics
DocType: Share Transfer,To Folio No,Za Folio No
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Operations,Novčani tok iz poslovanja
DocType: Employee Checkin,Log Type,Log Type
DocType: Stock Settings,Allow Negative Stock,Dopusti negativnu zalihu
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,None of the items have any change in quantity or value.,Nijedna stavka nema nikakvu promjenu u količini ili vrijednosti.
DocType: Asset,Purchase Date,Datum kupovine
DocType: Bank Statement Transaction Settings Item,Bank Statement Transaction Settings Item,Stavka bankovnog izvoda transakcije
,BOM Stock Report,BOM Stock Report
apps/erpnext/erpnext/public/js/payment/pos_payment.html,Write Off,Otpisati
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Red {0}: Očekivana vrijednost nakon korisnog vijeka trajanja mora biti manja od bruto iznosa kupovine
DocType: Employee,Personal Bio,Personal Bio
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Duplicate Entry. Please check Authorization Rule {0},Duplicate Entry. Molimo proverite Pravilo autorizacije {0}
apps/erpnext/erpnext/hr/doctype/shift_assignment/shift_assignment.py,Employee {0} has already applied for {1} on {2} : ,Zaposleni {0} se već prijavio za {1} dana {2}:
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Selling,Standardna prodaja
DocType: Clinical Procedure,Invoiced,Fakturirano
apps/erpnext/erpnext/education/doctype/guardian/guardian.py,User {0} already exists,Korisnik {0} već postoji
DocType: Account,Profit and Loss,Dobitak i gubitak
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Diff Qty,Diff Qty
DocType: Asset Finance Book,Written Down Value,Zapisana vrijednost
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Opening Balance Equity,Početni bilans stanja
DocType: GSTR 3B Report,April,April
DocType: Supplier,Credit Limit,Kreditni limit
apps/erpnext/erpnext/public/js/setup_wizard.js,Distribution,Distribucija
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,debit_note_amt,debit_note_amt
DocType: Quality Inspection,Inspected By,Inspected By
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get Items from Product Bundle,Nabavite artikle iz paketa proizvoda
DocType: Employee Benefit Claim,Employee Benefit Claim,Zahtev za beneficije zaposlenih
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date not mentioned,Datum odobrenja nije naveden
DocType: Company,Default Receivable Account,Račun potraživanja po defaultu
DocType: Location,Check if it is a hydroponic unit,Proverite da li je to hidroponska jedinica
DocType: Student Guardian,Others,Others
DocType: Patient Appointment,Patient Appointment,Imenovanje pacijenta
DocType: Inpatient Record,AB Positive,AB Positive
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py,Depreciation Date,Datum amortizacije
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Upcoming Calendar Events,Predstojeći kalendarski događaji
apps/erpnext/erpnext/config/hr.py,"Appraisals, Expense Claims and Loans","Procjene, potraživanja i zajmovi"
apps/erpnext/erpnext/utilities/activation.py,Create Student Batch,Kreirajte studentsku seriju
DocType: Travel Itinerary,Travel Advance Required,Potreban putni avans
apps/erpnext/erpnext/config/manufacturing.py,Orders released for production.,Nalozi izdati za proizvodnju.
DocType: Loyalty Program,Collection Rules,Pravila prikupljanja
DocType: Asset Settings,Disable CWIP Accounting,Onemogući CWIP računovodstvo
DocType: Homepage Section,Section Based On,Odeljak na osnovu
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,{0} already allocated for Employee {1} for period {2} to {3},{0} je već dodijeljen za zaposlenika {1} za period {2} do {3}
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0}: From Time and To Time of {1} is overlapping with {2},Red {0}: od vremena do vremena od {1} se preklapa sa {2}
DocType: Vital Signs,Very Hyper,Very Hyper
apps/erpnext/erpnext/public/js/setup_wizard.js,Select the nature of your business.,Odaberite prirodu vašeg poslovanja.
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Please select month and year,Odaberite mjesec i godinu
DocType: Service Level,Default Priority,Default Priority
DocType: Student Log,Student Log,Studentski dnevnik
DocType: Shopping Cart Settings,Enable Checkout,Omogući Checkout
apps/erpnext/erpnext/config/settings.py,Human Resources,Ljudski resursi
DocType: Stock Entry,Total Value Difference (Out - In),Razlika ukupne vrijednosti (Out - In)
DocType: Work Order Operation,Actual End Time,Actual End Time
apps/erpnext/erpnext/config/help.py,Setting up Taxes,Postavljanje poreza
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Investing,Neto gotovina od ulaganja
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Accounting Ledger,Knjigovodstvena knjiga
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,Item Group Tree,Tree Group Tree
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,'Total',&#39;Ukupno&#39;
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 1,Tačka 1
apps/erpnext/erpnext/utilities/user_progress.py,Student Batches,Studentske serije
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Priložite .csv datoteku sa dva stupca, jedan za staro ime i drugi za novo ime"
DocType: Bank Statement Transaction Payment Item,outstanding_amount,preostali iznos
apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Osjetljivo
DocType: Purchase Invoice,Total (Company Currency),Ukupno (valuta kompanije)
DocType: Item,Website Content,Sadržaj web stranice
DocType: Driver,Driving License Category,Kategorija vozačke dozvole
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
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Make Payment,Plaćanje
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Tip stranke je obavezan
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: Customer Feedback,Quality Management,Upravljanje kvalitetom
DocType: BOM,Transfer Material Against,Prenos materijala protiv
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,Temporarily on Hold,Privremeno na čekanju
apps/erpnext/erpnext/config/integrations.py,Connect Shopify with ERPNext,Povežite Shopify sa ERPNext
DocType: Homepage Section Card,Subtitle,Subtitle
DocType: Soil Texture,Loam,Loam
DocType: BOM,Scrap Material Cost(Company Currency),Trošak materijala za otpad (valuta kompanije)
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Delivery Note {0} must not be submitted,Napomena za isporuku {0} ne smije biti poslana
DocType: Task,Actual Start Date (via Time Sheet),Stvarni datum početka (putem vremenskog lista)
DocType: Sales Order,Delivery Date,Datum dostave
,Item Shortage Report,Izvještaj o nestašici predmeta
DocType: Subscription Plan,Price Determination,Određivanje cijena
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Retail & Wholesale,Retail &amp; Wholesale
DocType: Project,Twice Daily,Twice Daily
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Integrated Tax,Integrated Tax
DocType: Payment Entry,Deductions or Loss,Odbijanja ili gubitak
apps/erpnext/erpnext/regional/italy/utils.py,"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","Fiskalni režim je obavezan, ljubazno odredite fiskalni režim u preduzeću {0}"
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Time slots added,Dodani vremenski slotovi
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leaves must be allocated in multiples of 0.5,"Lišće se mora rasporediti u višekratnicima od 0,5"
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} deducted against {2},Iznos {0} {1} odbijen od {2}
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Plaćanje usklađivanja plaćanja
apps/erpnext/erpnext/config/buying.py,Template of terms or contract.,Obrazac termina ili ugovora.
DocType: Item,Barcodes,Barkodovi
DocType: Course Enrollment,Enrollment Date,Datum upisa
DocType: Holiday List,Clear Table,Clear Table
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Setting up company,Postavljanje kompanije
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Free item code is not selected,Kôd slobodne stavke nije odabran
apps/erpnext/erpnext/public/js/utils.js,Total Unpaid: {0},Ukupno neplaćeno: {0}
DocType: Account,Balance must be,Balans mora biti
DocType: Supplier,Default Bank Account,Default Bank Account
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Creating Fees,Creating Fees
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select Qty against item {0},Odaberite Količina od stavke {0}
DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,Nemojte potvrditi da li je sastanak kreiran za isti dan
DocType: Loan,Repaid/Closed,Repaid / Closed
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Red {0}: {1} Serijski brojevi potrebni za stavku {2}. Dali ste {3}.
DocType: Exchange Rate Revaluation Account,Gain/Loss,Gain / Loss
DocType: POS Profile,Sales Invoice Payment,Plaćanje fakture prodaje
DocType: Timesheet,Payslip,Payslip
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,HSN,HSN
apps/erpnext/erpnext/config/buying.py,Request for quotation.,Request for quotation.
,Procurement Tracker,Praćenje nabavki
DocType: Employee Tax Exemption Proof Submission Detail,Type of Proof,Type of Proof
DocType: Purchase Receipt,Vehicle Date,Datum vozila
DocType: Delivery Settings,Dispatch Settings,Postavke slanja
DocType: Task,Dependencies,Zavisnosti
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js,Lost,Izgubljen
DocType: BOM Update Tool,Replace BOM,Zamijeni BOM
DocType: Patient,Marital Status,Bračni status
DocType: HR Settings,Enter retirement age in years,Upisuje se starosna granica za penzionisanje u godinama
apps/erpnext/erpnext/templates/generators/item_group.html,No items listed,Nema stavki
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,No data to export,Nema podataka za izvoz
DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,Molimo odaberite Proslijedi ako želite uključiti i bilans prethodne fiskalne godine u ovu fiskalnu godinu
apps/erpnext/erpnext/config/help.py,Opening Stock Balance,Opening Stock Balance
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave Blocked,Ostavi blokirano
apps/erpnext/erpnext/stock/doctype/item/item.py,Asset Category is mandatory for Fixed Asset item,Kategorija imovine je obavezna za stavku fiksnog sredstva
DocType: Purchase Receipt Item,Required By,Required By
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Add to Details,Dodaj u Detalji
,Inactive Customers,Neaktivni klijenti
DocType: Drug Prescription,Dosage,Doziranje
DocType: Cheque Print Template,Starting position from top edge,Početna pozicija od gornje ivice
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Appointment Duration (mins),Trajanje sastanka (min)
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 dnevnik istog datuma. {0}
DocType: Accounting Dimension,Disable,Onemogući
DocType: Email Digest,Purchase Orders to Receive,Nalozi za kupovinu za primanje
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Productions Orders cannot be raised for:,Porudžbine za proizvodnju se ne mogu podići za:
DocType: Projects Settings,Ignore Employee Time Overlap,Zanemari preklapanje vremena zaposlenika
DocType: Employee Skill Map,Trainings,Treninzi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Lost Reasons,Lost Reasons
DocType: Inpatient Record,A Positive,A Positive
DocType: Quality Inspection Reading,Reading 7,Čitanje 7
DocType: Purchase Invoice Item,Serial No,Serijski br
DocType: Material Request Plan Item,Required Quantity,Potrebna količina
DocType: Location,Parent Location,Parent Location
DocType: Production Plan,Material Requests,Materijalni zahtjevi
DocType: Buying Settings,Material Transferred for Subcontract,Preneseni materijal za podugovor
DocType: Job Card,Timing Detail,Timing Detail
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html,Required On,Obavezno Uključeno
DocType: Job Offer Term,Job Offer Term,Trajanje ponude za posao
DocType: SMS Center,All Contact,Svi kontakti
DocType: Project Task,Project Task,Zadatak projekta
DocType: Item Barcode,Item Barcode,Item Barcode
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Levels,Nivoi zaliha
DocType: Vital Signs,Height (In Meter),Visina (u metrima)
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Value,Vrijednost narudžbe
DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Sve prodajne transakcije mogu biti označene na više ** prodajnih osoba **, tako da možete postaviti i nadzirati ciljeve."
apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Već ste odabrali stavke iz {0} {1}
DocType: Request for Quotation,Get Suppliers,Get Suppliers
DocType: Sales Team,Contribution (%),Doprinos (%)
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Cannot set a received RFQ to No Quote,Nije moguće podesiti primljeni RFQ na No Quote
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Sales Order,Kreirajte prodajni nalog
apps/erpnext/erpnext/accounts/general_ledger.py,Account: {0} can only be updated via Stock Transactions,Račun: {0} se može ažurirati samo putem transakcija dionicama
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} Request for {1},{0} Zahtjev za {1}
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js,Please select a value for {0} quotation_to {1},Odaberite vrijednost za {0} quotation_to {1}
DocType: Opportunity,Opportunity Date,Opportunity Date
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Next Steps,Sljedeći koraci
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Feedback,Povratne informacije o obuci
DocType: Purchase Invoice,ACC-PINV-.YYYY.-,ACC-PINV-.YYYY.-
DocType: Holiday List,Total Holidays,Total Holidays
DocType: Fertilizer,Fertilizer Name,Naziv gnojiva
apps/erpnext/erpnext/regional/india/utils.py,House rented dates required for exemption calculation,Datumi iznajmljivanja kuće potrebni za obračun izuzeća
,Expiring Memberships,Expiring Memberships
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Supplier(s),Dobavljač (i)
DocType: GL Entry,To Rename,Za preimenovanje
apps/erpnext/erpnext/templates/generators/item/item_configure.html,Contact Us,Kontaktiraj nas
DocType: POS Closing Voucher,Cashier,Blagajna
DocType: Drug Prescription,Hour,Hour
DocType: Support Settings,Show Latest Forum Posts,Show Latest Forum Posts
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Distributor,Distributer
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"Please add the remaining benefits {0} to the application as \
				pro-rata component",Molimo vas da dodate preostale beneficije {0} aplikaciji kao proporcionalnu komponentu
DocType: Invoice Discounting,Short Term Loan Account,Kratkoročni kreditni račun
DocType: Cash Flow Mapper,Section Subtotal,Odjeljak Subtotal
apps/erpnext/erpnext/config/buying.py,Material Request to Purchase Order,Materijalni zahtjev za narudžbenicu
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CESS Amount,CESS iznos
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Not authorized to edit frozen Account {0},Nije ovlašteno za uređivanje zamrznutog računa {0}
DocType: POS Closing Voucher Details,Expected Amount,Očekivani iznos
DocType: Customer,Default Price List,Default Price List
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,No Items selected for transfer,Nema odabranih stavki za prijenos
DocType: Payment Schedule,Payment Amount,Iznos plaćanja
DocType: Grant Application,Assessment  Manager,Menadžer procene
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Chemical,Hemijski
apps/erpnext/erpnext/config/education.py,Assessment Reports,Izvještaji o procjeni
DocType: C-Form,IV,IV
DocType: Student Log,Academic,Akademski
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item {0} is not setup for Serial Nos. Check Item master,Stavka {0} nije podešena za serijske brojeve
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From State,From State
DocType: Leave Type,Maximum Continuous Days Applicable,Maksimalni broj neprekidnih dana koji se primjenjuje
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Please enter company name first,Prvo unesite ime kompanije
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Import Successful,Import Successful
DocType: Guardian,Alternate Number,Alternativni broj
apps/erpnext/erpnext/patches/v11_0/create_department_records_for_each_company.py,All Departments,All Departments
apps/erpnext/erpnext/config/projects.py,Make project from a template.,Napravite projekat iz predloška.
DocType: Purchase Order,Inter Company Order Reference,Referenca za interne narudžbe
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
DocType: Education Settings,Employee Number,Broj radnika
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Avg. Buying Rate,Avg. Buying Rate
DocType: Manufacturing Settings,Capacity Planning For (Days),Planiranje kapaciteta za (dane)
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,From value must be less than to value in row {0},Iz vrijednosti mora biti manja od vrijednosti u redu {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select BOM and Qty for Production,Izaberite BOM i količinu za proizvodnju
DocType: Price List Country,Price List Country,Cjenovnik Država
apps/erpnext/erpnext/setup/doctype/company/company.js,Create Tax Template,Napravite šablon poreza
DocType: Item Attribute,Numeric Values,Numeric Values
DocType: Delivery Note,Instructions,Instrukcije
DocType: Blanket Order Item,Blanket Order Item,Deka porudžbina
DocType: Accounting Dimension,Mandatory For Profit and Loss Account,Obavezno za račun dobiti i gubitka
apps/erpnext/erpnext/controllers/selling_controller.py,Commission rate cannot be greater than 100,Stopa Komisije ne može biti veća od 100
DocType: Course Topic,Course Topic,Tema kursa
DocType: Employee,This will restrict user access to other employee records,Ovo će ograničiti pristup korisnika drugim evidencijama zaposlenih
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Please create Customer from Lead {0},Molimo kreirajte klijenta od Lead {0}
DocType: QuickBooks Migrator,Company Settings,Postavke kompanije
DocType: Travel Itinerary,Vegetarian,Vegetarijansko
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}), promijenite naziv grupe stavki ili preimenujte stavku"
DocType: Hotel Room,Hotel Room Type,Hotel Room Type
,Cash Flow,Priliv novca
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Plaćanje za {0} {1} ne može biti veće od nepodmirenog iznosa {2}
DocType: Student Log,Achievement,Postignuće
apps/erpnext/erpnext/projects/doctype/task/task_tree.js,Add Multiple Tasks,Dodajte više zadataka
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant {0} already exists with same attributes,Stavka Variant {0} već postoji sa istim atributima
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Invoice {0} no longer exists,Faktura {0} više ne postoji
DocType: Item,Will also apply for variants unless overrridden,Također će se primjenjivati za varijante osim ako je prebrzo
DocType: Cash Flow Mapping Accounts,Account,Račun
DocType: Sales Order,To Deliver,Dostaviti
,Customers Without Any Sales Transactions,Kupci bez ikakvih transakcija prodaje
DocType: Maintenance Visit Purpose,Against Document No,Protiv dokumenta br
apps/erpnext/erpnext/config/education.py,Content Masters,Masters sadržaja
apps/erpnext/erpnext/config/accounting.py,Subscription Management,Upravljanje pretplatom
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Get customers from,Odvedite klijente
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,{0} Digest,{0} Digest
DocType: Employee,Reports to,Reports to
DocType: Video,YouTube,YouTube
DocType: Party Account,Party Account,Account Party
DocType: Assessment Plan,Schedule,Raspored
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please enter ,Unesite
DocType: Lead,Channel Partner,Channel Partner
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Invoiced Amount,Iznos fakture
DocType: Project,From Template,From Template
,DATEV,DATEV
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,Subscriptions,Pretplate
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Quantity to Make,Količina za izradu
DocType: Quality Review Table,Achieved,Postignuto
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution Amount,Iznos doprinosa
DocType: Budget,Fiscal Year,Fiskalna godina
DocType: Supplier,Prevent RFQs,Prevent RFQs
DocType: Company,Discount Received Account,Račun primljenih popusta
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py, (Half Day),(Pola dana)
DocType: Email Digest,Email Digest,Email Digest
DocType: Crop,Crop,Rezati
DocType: Email Digest,Profit & Loss,Profit i gubitak
DocType: Homepage Section,Section Order,Redoslijed sekcija
DocType: Healthcare Settings,Result Printed,Rezultat štampan
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js,Student Group,Studentska grupa
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 predložak poreza koji se može primijeniti na sve transakcije kupovine. Ovaj predložak može sadržati popis poreznih glava, kao i druge glave za troškove kao što su &quot;Špedicija&quot;, &quot;Osiguranje&quot;, &quot;Rukovanje&quot; itd. *. Ako postoje ** stavke ** koje imaju različite stope, one se moraju dodati u tablicu ** Item Tax ** u ** Item ** master. #### Opis kolona 1. Vrsta kalkulacije: - To može biti na ** Neto Ukupan ** (to je zbir osnovnog iznosa). - ** Na prethodni red Ukupno / iznos ** (za kumulativne poreze ili naknade). Ako odaberete ovu opciju, porez će se primjenjivati kao postotak od prethodnog reda (u poreznoj tablici) iznosa ili ukupnog iznosa. - ** Actual ** (kao što je spomenuto). 2. Voditelj računa: Knjigovodstvena knjiga pod kojom će se ovaj porez rezervirati 3. Centar troška: Ako je porez / naknada prihod (kao što je otprema) ili trošak, potrebno ga je knjižiti na mjesto troška. 4. Opis: Opis poreza (koji će biti odštampan u fakturama / navodnicima). 5. Stopa: Stopa poreza. 6. Iznos: Iznos poreza. 7. Ukupno: Kumulativni ukupni iznos za ovu tačku. 8. Unesite red: Ako se na osnovu &quot;Prethodni redak ukupno&quot; možete izabrati broj reda koji će se uzeti kao osnova za ovaj izračun (podrazumevani je prethodni red). 9. Razmotrite porez ili nadoknadu za: U ovom odeljku možete navesti da li je porez / naplata samo za procenu (ne deo ukupnog iznosa) ili samo za ukupan iznos (ne dodaje vrednost stavci) ili za oba. 10. Dodati ili oduzeti: da li želite dodati ili odbiti porez."
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Connect to Quickbooks,Povežite se s QuickBook-ovima
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root cannot be edited.,Root se ne može uređivati.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Engineer,Inženjer
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Item added,Red # {0}: stavka je dodata
DocType: Student Admission,Eligibility and Details,Podobnost i detalji
DocType: Staffing Plan,Staffing Plan Detail,Detalj plana osoblja
DocType: Shift Type,Late Entry Grace Period,Grejs period za kasni ulazak
DocType: Email Digest,Annual Income,Godišnji prihod
DocType: Journal Entry,Subscription Section,Sekcija za pretplatu
DocType: Salary Slip,Payment Days,Dani plaćanja
apps/erpnext/erpnext/config/non_profit.py,Volunteer information.,Informacije o volonterima.
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py,`Freeze Stocks Older Than` should be smaller than %d days.,`Freeze Stocks Older Than` (Zamrznuti stokove starije od) trebao bi biti manji od% d dana.
DocType: Bank Reconciliation,Total Amount,Ukupan iznos
DocType: Certification Application,Non Profit,Non Profit
DocType: Subscription Settings,Cancel Invoice After Grace Period,Otkazivanje fakture nakon perioda otplate
DocType: Loyalty Point Entry,Loyalty Points,Bodovi lojalnosti
DocType: Purchase Order,Set Target Warehouse,Set Target Warehouse
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} trenutno ima status {1} dobavljača rezultata, a RFQ-ovi za ovog dobavljača trebaju biti izdati s oprezom."
DocType: Travel Itinerary,Check-in Date,Datum prijave
DocType: Tally Migration,Round Off Account,Round Off Account
DocType: Serial No,Warranty Period (Days),Period garancije (Dani)
DocType: Expense Claim Detail,Expense Claim Detail,Detalji troškova potraživanja
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Program: ,Program:
DocType: Patient Medical Record,Patient Medical Record,Patient Medical Record
DocType: Item,Variant Based On,Variant Based On
DocType: Vehicle Service,Brake Oil,Brake Oil
DocType: Employee,Create User,Kreiranje korisnika
DocType: Codification Table,Codification Table,Codification Table
DocType: Training Event Employee,Optional,Opcionalno
DocType: HR Settings,Show Leaves Of All Department Members In Calendar,Pokaži lišće svih članova Odjela u kalendaru
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đena prenesena stavka {0} u radnom nalogu {1}, stavka koja nije dodana u unos zaliha"
apps/erpnext/erpnext/templates/pages/help.html,See all open tickets,Pogledajte sve otvorene karte
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Operations cannot be left blank,Operacije se ne mogu ostaviti prazne
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,At least one mode of payment is required for POS invoice.,Za POS račun je potreban najmanje jedan način plaćanja.
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Email ID,Guardian1 Email ID
DocType: Sales Order Item,Supplier delivers to Customer,Dobavljač dostavlja Kupcu
DocType: Procedure Prescription,Appointment Booked,Imenovanje rezervirano
DocType: Crop,Target Warehouse,Target Warehouse
DocType: Accounts Settings,Stale Days,Stale Days
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Credit entry can not be linked with a {1},Red {0}: unos kredita ne može se povezati s {1}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Healthcare Practitioner {0} not available on {1},Zdravstveni radnik {0} nije dostupan na {1}
DocType: SMS Center,All Customer Contact,Svi kontakti kupaca
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žavanje uzorka se zasniva na seriji, provjerite Ima li serijski broj da zadrži uzorak stavke"
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Disc,Disc
DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Napravite unos za svako kretanje dionica
DocType: Travel Itinerary,Check-out Date,Datum odjave
DocType: Agriculture Analysis Criteria,Fertilizer,Đubrivo
DocType: Supplier,Default Tax Withholding Config,Određen forumom Tax Withholding Config
DocType: Production Plan,Total Produced Qty,Ukupna proizvedena količina
DocType: Leave Allocation,Leave Period,Leave Period
apps/erpnext/erpnext/education/doctype/fees/fees.py,Payment request {0} created,Napravljen je zahtjev za plaćanje {0}
DocType: Healthcare Service Unit Type,UOM Conversion in Hours,UOM konverzija u satima
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Avg. Selling Price List Rate,Avg. Stopa prodajne cijene
apps/erpnext/erpnext/config/manufacturing.py,Generate Material Requests (MRP) and Work Orders.,Generirajte materijalne zahtjeve (MRP) i radne naloge.
DocType: Journal Entry Account,Account Balance,Stanje računa
DocType: Asset Maintenance Log,Periodicity,Periodicity
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Medical Record,Medical Record
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,Log Type is required for check-ins falling in the shift: {0}.,Log-tip je potreban za check-inove koji padaju u smjeni: {0}.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Execution,Izvršenje
DocType: Item,Valuation Method,Metoda vrednovanja
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Invoice {1},{0} protiv fakture prodaje {1}
DocType: Quiz Activity,Pass,Pass
DocType: Sales Partner,Sales Partner Target,Cilj prodaje prodajnog partnera
DocType: Patient Appointment,Referring Practitioner,Referent praktičar
DocType: Account,Expenses Included In Asset Valuation,Troškovi uključeni u procjenu imovine
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Publishing,Publishing
DocType: Production Plan,Sales Orders Detail,Detalje narudžbenica prodaje
DocType: Salary Slip,Total Deduction,Ukupno oduzimanje
apps/erpnext/erpnext/hr/report/loan_repayment/loan_repayment.py,EMI,EMI
DocType: Naming Series,Set prefix for numbering series on your transactions,Postavite prefiks za serije brojeva na vašim transakcijama
apps/erpnext/erpnext/accounts/utils.py,Journal Entries {0} are un-linked,Unosi dnevnika {0} nisu povezani
apps/erpnext/erpnext/config/buying.py,Other Reports,Other Reports
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,All items have already been invoiced,Sve stavke su već fakturirane
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset scrapped via Journal Entry {0},Sredstvo je otpisano putem unosa dnevnika {0}
DocType: Employee,Prefered Email,Preferred Email
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Ne može se mijenjati metoda vrednovanja, jer postoje transakcije protiv nekih stavki koje nemaju vlastiti metod procjene"
DocType: Cash Flow Mapper,Section Name,Naziv odjeljka
DocType: Packed Item,Packed Item,Packed Item
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Potreban je iznos debitnog ili kreditnog iznosa za {2}
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Submitting Salary Slips...,Slanje slomova plata ...
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,No Action,Nema akcije
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Budžet se ne može dodijeliti protiv {0}, jer to nije račun prihoda ili rashoda"
apps/erpnext/erpnext/config/accounting.py,Masters and Accounts,Majstori i računi
DocType: Quality Procedure Table,Responsible Individual,Odgovorna osoba
apps/erpnext/erpnext/education/doctype/course/course.py,Total Weightage of all Assessment Criteria must be 100%,Ukupna težina svih kriterijuma procjene mora biti 100%
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,An error occurred during the update process,Došlo je do greške tokom procesa ažuriranja
DocType: Sales Invoice,Customer Name,Ime korisnika
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Amount should not be less than zero.,Iznos ne treba da bude manji od nule.
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Average Age,Prosečno doba
DocType: Shopping Cart Settings,Show Price,Prikaži cijenu
DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Program za učlanjenje u program
DocType: Tax Rule,Shipping State,Država transporta
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.js,Please set Company,Molimo postavite kompaniju
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Balance (Dr - Cr),Balans (Dr - Cr)
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Supply Type,Supply Type
DocType: Healthcare Settings,Create documents for sample collection,Kreirajte dokumente za prikupljanje uzoraka
DocType: Selling Settings,Close Opportunity After Days,Zatvori priliku nakon dana
DocType: Item Customer Detail,Ref Code,Ref Code
DocType: Employee,Widowed,Udovac
DocType: Tally Migration,ERPNext Company,ERPNext Company
DocType: Delivery Settings,Leave blank to use the standard Delivery Note format,Ostavite prazno da biste koristili standardni format isporuke
DocType: Purchase Invoice Item,Accepted Qty,Accepted Qty
DocType: Pricing Rule,Apply Rule On Brand,Primijeni pravilo o robnoj marki
DocType: Products Settings,Show Availability Status,Prikaži status dostupnosti
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Import Successfull,Import Successfull
DocType: Agriculture Analysis Criteria,Soil Texture,Tekstura tla
DocType: Maintenance Schedule Item,No of Visits,Broj posjeta
DocType: Customer Feedback Table,Qualitative Feedback,Qualitative Feedback
DocType: Service Level,Response and Resoution Time,Vreme odgovora i izlaganja
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Expiring On,Expiring On
DocType: Supplier Scorecard,Scorecard Actions,Actionscard Actions
DocType: Account,Stock Adjustment,Stock Adjustment
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Health Care,Health Care
DocType: Restaurant Table,No of Seats,Broj sjedišta
apps/erpnext/erpnext/setup/doctype/company/company.js,Delete all the Transactions for this Company,Obrišite sve transakcije za ovu kompaniju
,Lead Details,Lead Details
DocType: Service Level Agreement,Default Service Level Agreement,Uobičajeni ugovor o nivou usluge
apps/erpnext/erpnext/portal/doctype/products_settings/products_settings.py,"Filter Fields Row #{0}: Fieldname <b>{1}</b> must be of type ""Link"" or ""Table MultiSelect""",Polja filtra Red # {0}: Ime polja <b>{1}</b> mora biti tipa &quot;Link&quot; ili &quot;Table MultiSelect&quot;
DocType: Lead,Suggestions,Sugestije
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Get from,Get from
DocType: Tax Rule,Tax Rule,Tax Rule
DocType: Payment Entry,Payment Order Status,Status naloga za plaćanje
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Duplicate entry,Duplicate entry
apps/erpnext/erpnext/utilities/user_progress.py,Example: Masters in Computer Science,Primjer: magistar računarstva
DocType: Purchase Invoice Item,Purchase Invoice Item,Stavka fakture kupovine
DocType: Certified Consultant,Non Profit Manager,Non Profit Manager
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,For Warehouse is required before Submit,Za skladište je potrebno prije slanja
DocType: Authorization Rule,Applicable To (User),Primjenjivo na (korisnik)
DocType: Appraisal Goal,Appraisal Goal,Cilj procene
DocType: Supplier Scorecard,Warn for new Purchase Orders,Upozorenje za nove narudžbenice
apps/erpnext/erpnext/public/js/setup_wizard.js,View Chart of Accounts,Pogledajte kontni plan
apps/erpnext/erpnext/templates/pages/rfq.html,Quotations: ,Citati:
DocType: Opportunity,To Discuss,Raspravljati
DocType: Quality Inspection Reading,Reading 9,Čitanje 9
DocType: Authorization Rule,Applicable To (Role),Primjenjivo na (uloga)
DocType: Quotation Item,Additional Notes,Dodatne napomene
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} can not be negative,{0} ne može biti negativan
apps/erpnext/erpnext/utilities/activation.py,Create Purchase Orders,Kreirajte narudžbenice
DocType: Staffing Plan Detail,Estimated Cost Per Position,Procijenjena cijena po poziciji
DocType: Loan Type,Loan Name,Naziv zajma
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Set default mode of payment,Postavite zadani način plaćanja
DocType: Quality Goal,Revision,Revizija
DocType: Shift Type,The time before the shift end time when check-out is considered as early (in minutes).,Vrijeme prije završetka smjene kada se check-out smatra ranim (u minutama).
DocType: Healthcare Service Unit,Service Unit Type,Tip uslužne jedinice
DocType: Purchase Invoice,Return Against Purchase Invoice,Povratak protiv fakture kupovine
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Generate Secret,Generate Secret
DocType: Loyalty Program Collection,Loyalty Program Collection,Zbirka programa lojalnosti
apps/erpnext/erpnext/config/crm.py,Send mass SMS to your contacts,Šaljite masovne SMS poruke svojim kontaktima
apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js,Create Fee Schedule,Napravite raspored naknada
DocType: Rename Tool,File to Rename,Datoteka za Preimenuj
apps/erpnext/erpnext/public/js/projects/timer.js,Timer exceeded the given hours.,Tajmer je prekoračio zadate sate.
DocType: Shopify Tax Account,ERPNext Account,ERPNext Account
DocType: Item Supplier,Item Supplier,Item Supplier
apps/erpnext/erpnext/stock/get_item_details.py,Price List {0} is disabled or does not exist,Cenovnik {0} je onemogućen ili ne postoji
DocType: Sales Invoice Item,Deferred Revenue Account,Račun odloženih prihoda
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py,Soil compositions do not add up to 100,Kompozicije zemljišta ne daju 100
DocType: Salary Slip,Salary Slip Timesheet,Isplata plata
DocType: Budget,Warn,Warn
DocType: Grant Application,Email Notification Sent,Email Notification Sent
DocType: Work Order,Planned End Date,Planirani krajnji datum
DocType: QuickBooks Migrator,Quickbooks Company ID,QuickBooks ID kompanije
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Skladište se ne može mijenjati za serijski broj
DocType: Loan Type,Rate of Interest (%) Yearly,Kamatna stopa (%) Godišnje
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Scrapped Asset,Troškovi rashodovane imovine
apps/erpnext/erpnext/regional/italy/utils.py,Please set an Address on the Company '%s',Postavite adresu na kompaniju &#39;% s&#39;
DocType: Patient Encounter,Encounter Date,Datum susreta
DocType: Shopify Settings,Webhooks,Webhooks
apps/erpnext/erpnext/config/non_profit.py,Memebership Type Details,Memebership Type Details
apps/erpnext/erpnext/healthcare/setup.py,Resistant,Otporan
DocType: Hotel Room Package,Hotel Room Package,Paket hotelskih soba
DocType: Sales Team,Contribution to Net Total,Doprinos neto ukupnom iznosu
DocType: Customer,"Reselect, if the chosen contact is edited after save",Ponovo odaberite ako se odabrani kontakt uređuje nakon spremanja
DocType: Employee Tax Exemption Sub Category,Employee Tax Exemption Sub Category,Sub Category Category Exemption Tax Exemption
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Row {0}# Paid Amount cannot be greater than requested advance amount,Red {0} # Plaćeni iznos ne može biti veći od traženog iznosa avansa
DocType: Asset Settings,This value is used for pro-rata temporis calculation,Ova vrijednost se koristi za pro-rata temporis obračun
DocType: Company,Change Abbreviation,Change Abbreviation
DocType: Project,Total Consumed Material Cost  (via Stock Entry),Ukupni utrošeni materijalni troškovi (putem unosa zaliha)
DocType: Purchase Invoice,Raw Materials Supplied,Isporučene sirovine
DocType: Salary Detail,Condition and Formula Help,Stanje i formula pomoći
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Balance ({0}),Stanje ({0})
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student ID: ,Student ID:
DocType: Leave Control Panel,New Leaves Allocated (In Days),Dodeljeni novi listovi (u danima)
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py,To Datetime,To Datetime
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab result datetime cannot be before testing datetime,Datetime rezultat laboratorijskog rezultata ne može biti prije testiranja datetime
apps/erpnext/erpnext/setup/doctype/company/company.js,Please re-type company name to confirm,Molimo da ponovo potvrdite ime kompanije
DocType: Subscription,Subscription Period,Period pretplate
DocType: Cash Flow Mapper,Position,Pozicija
DocType: Student,Sibling Details,Sibling Details
DocType: Cash Flow Mapping,Is Finance Cost Adjustment,Je finansijska prilagodba troškova
DocType: Patient Encounter,Encounter Impression,Encounter Impression
DocType: Contract,N/A,N / A
DocType: Lab Test,Lab Technician,Laboratorijski tehničar
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"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,How Pricing Rule is applied?,Kako se primjenjuje Pravilo određivanja cijena?
DocType: Email Digest,Email Digest Settings,Podešavanja e-pošte
DocType: Journal Entry,Inter Company Journal Entry,Unos inter kompanijskog dnevnika
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Create Delivery Trip,Napravite put isporuke
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Red # {0}: Serijski broj {1} se ne podudara s {2} {3}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Sales Order required for Item {0},Potreban prodajni nalog za stavku {0}
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_proof_submission/employee_tax_exemption_proof_submission.js,Get Details From Declaration,Saznajte detalje iz deklaracije
,Support Hour Distribution,Distribucija sata podrške
DocType: Company,Allow Account Creation Against Child Company,Omogućite kreiranje računa protiv kompanije za djecu
DocType: Payment Entry,Company Bank Account,Bankovni račun kompanije
DocType: Amazon MWS Settings,UK,UK
DocType: Normal Test Items,Normal Test Items,Normalne test stavke
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}: Naručena količina {1} ne može biti manja od minimalne količine narudžbe {2} (definirana u stavci).
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,Not in Stock,Nije na skladištu
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Cart
DocType: Course Activity,Course Activity,Aktivnost kursa
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Thank you for your business!,Hvala vam na poslu!
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Against Journal Entry {0} is already adjusted against some other voucher,Protiv unosa dnevnika {0} je već podešen prema nekom drugom vaučeru
DocType: Journal Entry,Bill Date,Datum naplate
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please enter Write Off Account,Molimo Vas da unesete Account Off
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Biotechnology,Biotechnology
apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py,Setup your Institute in ERPNext,Postavite svoj Institut u ERPNext
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} does not exist,Stavka {0} ne postoji
DocType: Asset Maintenance Log,Asset Maintenance Log,Dnevnik održavanja imovine
DocType: Accounts Settings,Settings for Accounts,Postavke za račune
DocType: Bank Guarantee,Reference Document Name,Naziv referentnog dokumenta
DocType: Warehouse,"If blank, parent Warehouse Account or company default will be considered","Ako se razmotri prazan, nadređeni Warehouse račun ili podrazumevana kompanija"
DocType: BOM,Rate Of Materials Based On,Brzina materijala na osnovu
DocType: Water Analysis,Container,Kontejner
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Available slots,Dostupni slotovi
DocType: Quiz,Max Attempts,Max Attempts
apps/erpnext/erpnext/public/js/financial_statements.js,Cash Flow Statement,Izvještaj o novčanom toku
DocType: Loyalty Point Entry,Redeem Against,Redeem Against
DocType: Sales Invoice,Offline POS Name,Offline POS Ime
DocType: Crop Cycle,ISO 8601 standard,ISO 8601 standard
DocType: Purchase Taxes and Charges,Deduct,Deduct
DocType: C-Form Invoice Detail,C-Form Invoice Detail,Detalji o fakturi C-Forma
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Inventory,Neto promjena u inventaru
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Amount during the period,Amortizacija Iznos tokom perioda
DocType: Shopify Settings,App Type,Tip aplikacije
DocType: Lead,Blog Subscriber,Blog Subscriber
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,[Error],[Greška]
DocType: Restaurant,Active Menu,Active Menu
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Transactions against the company already exist! ,Transakcije protiv kompanije već postoje!
DocType: Customer,Sales Partner and Commission,Prodajni partner i Komisija
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Goals cannot be empty,Ciljevi ne mogu biti prazni
DocType: Work Order,Warehouses,Skladišta
DocType: Crop Cycle,Detected Diseases,Detected Diseases
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the Bank Guarantee Number before submittting.,Unesite broj bankarske garancije prije slanja.
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Items and UOMs,Stavke obrade i UOM-ovi
DocType: Payment Request,Is a Subscription,Je pretplata
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Preuzmite kao Json
,Appointment Analytics,Appointment Analytics
DocType: Quality Inspection,Inspection Type,Tip inspekcije
DocType: Sales Invoice,Sales Taxes and Charges,Porezi i naknade za prodaju
DocType: Employee,Health Insurance Provider,Pružatelj zdravstvenog osiguranja
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,This is a root item group and cannot be edited.,Ovo je grupa korijenskih stavki i ne može se uređivati.
DocType: Production Plan,Projected Qty Formula,Predviđena formula za količinu
DocType: Payment Order,Payment Order Reference,Referenca naloga za plaćanje
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Tree Type,Vrsta drveta
DocType: Activity Type,Default Costing Rate,Default Costing Rate
DocType: Vital Signs,Constipated,Zatvor
DocType: Salary Detail,Default Amount,Default Amount
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,Budget List,Spisak budžeta
DocType: Job Offer,Awaiting Response,Čeka odgovor
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant creation has been queued.,Stvaranje varijante je stavljeno u red čekanja.
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 od {0} koji je već tvrdio za komponentu {1}, određuje iznos jednak ili veći od {2}"
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Please add the remaining benefits {0} to any of the existing component,Molimo dodajte preostale koristi {0} bilo kojoj od postojećih komponenti
DocType: Vehicle Log,Odometer,Odometer
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Transaction currency must be same as Payment Gateway currency,Valuta transakcije mora biti ista kao i valuta Payment Gateway
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: Additional Salary,Payroll Date,Datum plata
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Mode of payment is required to make a payment,Način plaćanja je potreban za plaćanje
DocType: BOM,Materials,Materijali
DocType: Delivery Note Item,Against Sales Order,Protiv prodajnog naloga
DocType: Supplier Quotation,PUR-SQTN-.YYYY.-,PUR-SQTN-.YYYY.-
DocType: Delivery Note Item,Against Sales Order Item,Protiv stavke prodajnog naloga
DocType: Appraisal,Goals,Ciljevi
DocType: Employee,ERPNext User,ERPNext User
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Available Leaves,Available Leaves
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root Account must be a group,Root račun mora biti grupa
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
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Type...,Odaberite Vrsta ...
DocType: Workstation Working Hour,Workstation Working Hour,Workstation Working Hour
apps/erpnext/erpnext/config/agriculture.py,Analytics,Analitika
DocType: Maintenance Team Member,Maintenance Role,Uloga održavanja
apps/erpnext/erpnext/config/buying.py,Terms and Conditions Template,Pravila i uslovi
DocType: Fee Schedule Program,Fee Schedule Program,Program naknada
DocType: Project Task,Make Timesheet,Napravite timesheet
DocType: Production Plan Item,Production Plan Item,Proizvodni plan stavka
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Total Student,Total Student
DocType: Packing Slip,From Package No.,From Package No.
DocType: Accounts Settings,Shipping Address,Adresa za dostavu
DocType: Vehicle Service,Clutch Plate,Clutch Plate
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} does not linked to Item {2},Red # {0}: Sredstvo {1} nije povezano sa stavkom {2}
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Entry {0} created,Stvoren je unos zaliha {0}
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Date,Datum narudžbenice
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Company currencies of both the companies should match for Inter Company Transactions.,Valute kompanija oba preduzeća treba da se podudaraju za transakcije između kompanija.
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Shortage Qty,Količina nedostatka
DocType: Employee Attendance Tool,Marked Attendance,Označeno prisustvo
DocType: Pricing Rule,System will notify to increase or decrease quantity or amount ,Sistem će obavestiti da poveća ili smanji količinu ili količinu
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Cosmetics,Kozmetika
DocType: Naming Series,Check this if you want to force the user to select a series before saving. There will be no default if you check this.,"Označite ovo ako želite prisiliti korisnika da odabere seriju prije spremanja. Ako to označite, neće biti zadane postavke."
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 mogu postaviti zamrznute račune i kreirati / modificirati računovodstvene unose za zamrznute račune
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Šifra artikla&gt; Item Group&gt; Brand
DocType: Expense Claim,Total Claimed Amount,Ukupni traženi iznos
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Unable to find Time Slot in the next {0} days for Operation {1},Nije moguće pronaći vremenski termin u sljedećih {0} dana za rad {1}
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Wrapping up,Umotavanje
apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Možete obnoviti samo ako vaše članstvo ističe u roku od 30 dana
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Value must be between {0} and {1},Vrijednost mora biti između {0} i {1}
DocType: Quality Feedback,Parameters,Parametri
DocType: Shift Type,Auto Attendance Settings,Auto Attendance Settings
,Sales Partner Transaction Summary,Sažetak transakcija prodajnog partnera
DocType: Asset Maintenance,Maintenance Manager Name,Ime menadžera održavanja
apps/erpnext/erpnext/public/js/controllers/transaction.js,It is needed to fetch Item Details.,Potrebno je dohvatiti detalje stavke.
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,This is based on stock movement. See {0} for details,Ovo se zasniva na kretanju zaliha. Pogledajte {0} za detalje
DocType: Clinical Procedure,Appointment,Sastanak
apps/erpnext/erpnext/public/js/utils/party.js,Please enter {0} first,Unesite prvo {0}
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 ista kao glavna stavka
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:
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 koju važeću oznaku Bootstrap 4. Prikazuje se na stranici stavke.
DocType: Serial No,Incoming Rate,Incoming Rate
DocType: Cashier Closing,POS-CLO-,POS-CLO- \ t
DocType: Invoice Discounting,Accounts Receivable Discounted Account,Račun s diskontovanim računima potraživanja
DocType: Tally Migration,Tally Debtors Account,Tally Debtors Account
DocType: Grant Application,Has any past Grant Record,Ima prošli Grant Record
DocType: POS Closing Voucher,Amount in Custody,Iznos u pritvoru
DocType: Drug Prescription,Interval,Interval
DocType: Warehouse,Parent Warehouse,Parent Warehouse
apps/erpnext/erpnext/stock/reorder_item.py,Auto Material Requests Generated,Generisano automatsko traženje materijala
apps/erpnext/erpnext/controllers/stock_controller.py,Row {0}: Quality Inspection rejected for item {1},Red {0}: Odbijena inspekcija kvaliteta za stavku {1}
DocType: Vehicle,Additional Details,Dodatni detalji
DocType: Sales Partner Type,Sales Partner Type,Vrsta prodajnog partnera
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,"Select BOM, Qty and For Warehouse","Odaberite BOM, Qty i For Warehouse"
DocType: Asset Maintenance Log,Maintenance Type,Tip održavanja
DocType: Homepage Section,Use this field to render any custom HTML in the section.,Koristite ovo polje za prikaz bilo kojeg prilagođenog HTML-a u odjeljku.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,"Appointment cancelled, Please review and cancel the invoice {0}","Sastanak otkazan, pregledajte i otkažite fakturu {0}"
DocType: Sales Invoice,Time Sheet List,Lista vremenskih lista
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Bill {1} dated {2},{0} protiv računa {1} sa datumom {2}
DocType: Shopify Settings,For Company,For Company
DocType: Linked Soil Analysis,Linked Soil Analysis,Linked Soil Analysis
DocType: Project,Day to Send,Dan za slanje
DocType: Salary Component,Is Tax Applicable,Da li se primjenjuje porez
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Purchase Order number required for Item {0},Broj narudžbenice potreban za stavku {0}
DocType: Item Tax Template,Tax Rates,Poreske stope
apps/erpnext/erpnext/templates/pages/search_help.py,Help Results for,Rezultati pomoći za
DocType: Student Admission,Student Admission,Student Admission
DocType: Designation Skill,Skill,Skill
DocType: Budget Account,Budget Account,Račun budžeta
DocType: Employee Transfer,Create New Employee Id,Napravite novi ID zaposlenika
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} is required for 'Profit and Loss' account {1}.,{0} je potreban za račun &#39;Profit i gubitak&#39; {1}.
apps/erpnext/erpnext/config/accounting.py,Goods and Services Tax (GST India),Porez na robu i usluge (GST Indija)
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Creating Salary Slips...,Kreiranje isplata plata ...
DocType: Employee Skill,Employee Skill,Veština zaposlenika
DocType: Pricing Rule,Apply Rule On Item Code,Primijeni pravilo o kodu artikla
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,'Update Stock' can not be checked because items are not delivered via {0},&quot;Ažuriranje zaliha&quot; ne može se provjeriti jer se stavke ne isporučuju putem {0}
DocType: Journal Entry,Stock Entry,Stock Entry
apps/erpnext/erpnext/regional/india/utils.py,House rent paid days overlapping with {0},Iznajmljivanje plaćenih dana za kuće koje se preklapaju s {0}
DocType: Employee,Current Address Is,Trenutna adresa je
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Analyst,Analitičar
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,No records found in the Payment table,U tabeli plaćanja nema zapisa
DocType: Email Digest,Sales Orders to Deliver,Prodajni nalozi za isporuku
DocType: Item,Units of Measure,Jedinice mjere
DocType: Leave Block List,Block Days,Block Days
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Quantity must not be more than {0},Količina ne smije biti veća od {0}
apps/erpnext/erpnext/public/js/utils/item_selector.js,Add Items,Add Items
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Porezi i naknade (valuta kompanije)
DocType: Accounts Settings,Currency Exchange Settings,Postavke za razmjenu valuta
DocType: Taxable Salary Slab,From Amount,From Amount
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Warehouse is mandatory,Skladište je obavezno
apps/erpnext/erpnext/utilities/user_progress.py,Add Students,Dodaj studente
DocType: Payment Entry,Account Paid From,Račun plaćen od
DocType: Employee Attendance Tool,Marked Attendance HTML,Označeni HTML za prisustvo
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} has been disabled,Stavka {0} je onemogućena
DocType: Cheque Print Template,Amount In Figure,Iznos na slici
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Cannot produce more Item {0} than Sales Order quantity {1},Nije moguće proizvesti više stavke {0} nego količina narudžbenice {1}
DocType: Purchase Invoice,Return,Povratak
apps/erpnext/erpnext/stock/doctype/batch/batch.py,The selected item cannot have Batch,Odabrana stavka ne može imati paket
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.js,Print IRS 1099 Forms,Ispis IRS 1099 Obrasci
apps/erpnext/erpnext/controllers/accounts_controller.py,'Update Stock' cannot be checked for fixed asset sale,&#39;Update Stock&#39; ne može se proveriti za prodaju fiksne imovine
DocType: Asset,Depreciation Schedule,Raspored amortizacije
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule not applicable for country {0},Pravilo dostave nije primjenjivo za zemlju {0}
DocType: Purchase Receipt,Time at which materials were received,Vrijeme kada su materijali primljeni
DocType: Tax Rule,Billing Country,Država naplate
DocType: Journal Entry Account,Sales Order,Prodajni nalog
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Nedostaje vrijednost
apps/erpnext/erpnext/stock/doctype/item/item.py,Stores,Trgovine
DocType: Exchange Rate Revaluation Account,New Balance In Base Currency,Novo stanje u osnovnoj valuti
DocType: POS Profile,Price List,Cjenovnik
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Invalid {0}: {1},Nevažeći {0}: {1}
DocType: Article,Article,Članak
apps/erpnext/erpnext/public/js/setup_wizard.js,The name of the institute for which you are setting up this system.,Naziv instituta za koji postavljate ovaj sistem.
apps/erpnext/erpnext/utilities/user_progress.py,A Product,A Product
DocType: Crop,Crop Name,Crop Name
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,'From Date' is required,&quot;Od datuma&quot; je obavezno
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select a BOM,Odaberite sastavnicu
DocType: Travel Itinerary,Travel Itinerary,Plan putovanja
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Birthday Reminder,Podsetnik za rođendan
apps/erpnext/erpnext/utilities/user_progress.py,Pair,Par
apps/erpnext/erpnext/stock/get_item_details.py,Item Price added for {0} in Price List {1},Stavka Cijena je dodana za {0} u cjeniku {1}
DocType: Pricing Rule,Validate Applied Rule,Validate Applied Rule
DocType: Job Card Item,Job Card Item,Stavka radne kartice
DocType: Homepage,Company Tagline for website homepage,Kompanija Tagline za početnu stranicu web lokacije
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Set Response Time and Resolution for Priority {0} at index {1}.,Postavite vrijeme odziva i razlučivost za prioritet {0} na indeksu {1}.
DocType: Company,Round Off Cost Center,Okrugli centar troškova
DocType: Supplier Scorecard Criteria,Criteria Weight,Težina kriterija
DocType: Asset,Depreciation Schedules,Raspored amortizacije
DocType: Subscription,Discounts,Popusti
DocType: Shipping Rule,Shipping Rule Conditions,Uslovi Pravila o otpremi
DocType: Subscription,Cancelation Date,Datum otkazivanja
DocType: Payment Entry,Party Bank Account,Bankarski račun stranke
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,New Cost Center Name,Novo ime centra troška
DocType: Promotional Scheme Price Discount,Max Amount,Maksimalni iznos
DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Nakon završetka plaćanja preusmjerite korisnika na odabranu stranicu.
DocType: Salary Slip,Total Loan Repayment,Ukupna otplata kredita
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,To Fiscal Year,U fiskalnu godinu
DocType: Delivery Note,Return Against Delivery Note,Povratak protiv isporuke isporuke
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,"Edit in full page for more options like assets, serial nos, batches etc.","Uredite cijelu stranicu za više opcija kao što su sredstva, serijski brojevi, serije itd."
DocType: Payment Entry,Allocate Payment Amount,Rasporedite iznos uplate
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Returned Item {1} does not exists in {2} {3},Red # {0}: Vraćena stavka {1} ne postoji u {2} {3}
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js,Enrolling students,Upis studenata
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Dozvoli korisniku da uredi cenovnik u transakcijama
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Please select the document type first,Prvo izaberite tip dokumenta
DocType: Hotel Room Reservation,Hotel Room Reservation,Rezervacija hotelskih soba
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Researcher,Istraživač
apps/erpnext/erpnext/accounts/party.py,{0} {1} is frozen,{0} {1} je zamrznut
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item Code cannot be changed for Serial No.,Šifra artikla se ne može mijenjati za serijski broj.
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Ukupni porezi i naknade (valuta kompanije)
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Rule Conflicts with {0},Porez na porezno pravilo sa {0}
DocType: Fiscal Year,Year End Date,Datum završetka godine
apps/erpnext/erpnext/utilities/activation.py,Create Leads,Create Leads
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js,Show zero values,Prikaži nultu vrijednost
DocType: Employee Onboarding,Employee Onboarding,Zaposleni Onboarding
DocType: POS Closing Voucher,Period End Date,Datum završetka perioda
DocType: Department,The first Leave Approver in the list will be set as the default Leave Approver.,Prvi odobreni dopust u listi će biti postavljen kao podrazumevani Leave Approver.
DocType: POS Settings,POS Settings,POS Settings
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,All Accounts,Svi računi
DocType: Hotel Room,Hotel Manager,Hotel Manager
DocType: Opportunity,With Items,Sa stavkama
DocType: GL Entry,Is Advance,Is Advance
DocType: Membership,Membership Status,Status članstva
apps/erpnext/erpnext/config/crm.py,Sales campaigns.,Prodajne kampanje.
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Default BOM not found for Item {0} and Project {1},Zadana BOM nije pronađena za stavku {0} i Project {1}
DocType: Leave Type,Encashment Threshold Days,Dani pragova naplate
apps/erpnext/erpnext/stock/report/item_prices/item_prices.js,Items Filter,Items Filter
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} je na čekanju do {1}
DocType: Clinical Procedure Item,Invoice Separately as Consumables,Faktura odvojeno od potrošnog materijala
DocType: Subscription,Days Until Due,Dana do dospijeća
apps/erpnext/erpnext/templates/pages/projects.js,Show Completed,Show Completed
apps/erpnext/erpnext/config/accounting.py,Bank Statement Transaction Entry Report,Izvještaj o upisu transakcije u banci
apps/erpnext/erpnext/accounts/doctype/bank/bank_dashboard.py,Bank Deatils,Bank Deatils
apps/erpnext/erpnext/utilities/transaction_base.py,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Red # {0}: Stopa mora biti ista kao {1}: {2} ({3} / {4})
DocType: Clinical Procedure,HLC-CPR-.YYYY.-,FHP-CPR-.YYYY.-
DocType: Healthcare Settings,Healthcare Service Items,Stavke zdravstvene službe
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 3,Raspon starenja 3
DocType: Vital Signs,Blood Pressure,Krvni pritisak
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/sales_partner_target_variance_based_on_item_group.js,Target On,Target On
apps/erpnext/erpnext/patches/v11_0/add_healthcare_service_unit_tree_root.py,All Healthcare Service Units,Sve jedinice zdravstvene službe
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Program,Obavezno polje - Program
apps/erpnext/erpnext/public/js/projects/timer.js,Timer,Timer
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Postavite {0} u kategoriju sredstava {1} ili tvrtku {2}
DocType: Bank Statement Settings Item,Bank Header,Zaglavlje banke
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Not eligible for the admission in this program as per DOB,Ne ispunjava uvjete za upis u ovaj program prema DOB
DocType: Assessment Criteria,Assessment Criteria Group,Grupa kriterijuma procjene
DocType: Options,Is Correct,Tacno je
apps/erpnext/erpnext/utilities/user_progress.py,user@example.com,user@example.com
DocType: Department,Parent Department,Parent Department
DocType: Employee Internal Work History,Employee Internal Work History,Interna radna istorija zaposlenih
DocType: Supplier,Warn POs,Warn POs
DocType: Employee,Offer Date,Datum ponude
DocType: Sales Invoice,Product Bundle Help,Pomoć za paket proizvoda
DocType: Stock Reconciliation,Stock Reconciliation,Stock Reconciliation
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Accounting Entry for Stock,Računovodstveni unos za dionice
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.",Sastanak se preklapa s {0}. <br> {1} je zakazao sastanak sa {2} u {3} sa {4} minuta.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with child nodes cannot be converted to ledger,Skladišta sa podređenim čvorovima ne mogu se pretvoriti u knjigu knjiga
DocType: Project,Projects Manager,Menadžer projekata
apps/erpnext/erpnext/hr/doctype/training_event/training_event.py,End time cannot be before start time,Vrijeme završetka ne može biti prije vremena početka
DocType: UOM,UOM Name,UOM ime
DocType: Vital Signs,BMI,BMI
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Hours,Hours
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} {2} {3},Iznos {0} {1} {2} {3}
,Supplier Ledger Summary,Summary Ledger Supplier
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Email ID,ID e-pošte studenta
apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA Mandat
DocType: Bank Account,IBAN,IBAN
DocType: Restaurant Reservation,No of People,No of People
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,From Date and To Date lie in different Fiscal Year,Od datuma do datuma 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 preporuku kupca za fakturu
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in condition: {0},Pogreška u sintaksi: {0}
DocType: Payment Entry,Transaction ID,ID transakcije
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Please enter message before sending,Unesite poruku prije slanja
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Ref Date,Ref Date
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Napomena: Ovaj centar troškova je grupa. Nije moguće izvršiti računovodstvene stavke za grupe.
DocType: Soil Analysis,Soil Analysis Criterias,Kriteriji analize tla
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Packing Slip(s) cancelled,Listić (i) pakovanja je poništen
DocType: Company,Existing Company,Postojeća kompanija
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batches,Serije
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Defense,Odbrana
DocType: Item,Has Batch No,Batch No
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Delayed Days,Delayed Days
DocType: Lead,Person Name,Ime osobe
DocType: Item Variant,Item Variant,Item Variant
DocType: Training Event Employee,Invited,Pozvan
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Maksimalni iznos koji odgovara komponenti {0} premašuje {1}
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py,Amount to Bill,Iznos za Bill
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"For {0}, only debit accounts can be linked against another credit entry","Za {0}, samo debitni računi mogu biti povezani s drugim unosom kredita"
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py,Creating Dimensions...,Kreiranje dimenzija ...
DocType: Bank Statement Transaction Entry,Payable Account,Plaćeni račun
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Navedite broj potrebnih posjeta
DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,Izaberite samo ako imate podešavanje dokumenata za mapiranje novčanog toka
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} is a company holiday,{0} je praznik kompanije
DocType: Item,Items with higher weightage will be shown higher,Stavke sa većom težinom će biti prikazane više
DocType: Project,Project will be accessible on the website to these users,Projekat će biti dostupan na web stranici ovim korisnicima
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute table is mandatory,Tablica atributa je obavezna
DocType: Salary Slip,Total Working Hours,Ukupno radno vrijeme
DocType: Crop,Planting UOM,Sadnja UOM
DocType: Inpatient Record,O Negative,O Negativno
DocType: Purchase Order,To Receive and Bill,Da primim i Bill
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Početni i završni datumi koji nisu u važećem obračunskom periodu, ne mogu izračunati {0}."
DocType: POS Profile,Only show Customer of these Customer Groups,Prikaži samo klijente ovih korisničkih grupa
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select items to save the invoice,Izaberite stavke za čuvanje fakture
DocType: Service Level Priority,Resolution Time,Resolution Time
DocType: Grading Scale Interval,Grade Description,Opis razreda
DocType: Homepage Section,Cards,Kartice
DocType: Quality Meeting Minutes,Quality Meeting Minutes,Zapisnici o kvalitetu sastanka
DocType: Linked Plant Analysis,Linked Plant Analysis,Povezana analiza biljaka
apps/erpnext/erpnext/public/js/controllers/transaction.js,Service Stop Date cannot be after Service End Date,Datum servisnog zaustavljanja ne može biti nakon datuma završetka usluge
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Please set B2C Limit in GST Settings.,Postavite B2C granicu u GST postavkama.
DocType: Member,Member Name,Ime člana
DocType: Account,Payable,Plaća se
DocType: Job Card,For Quantity,Za količinu
DocType: Territory,For reference,Za referenciju
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Add to Cart,Dodaj u korpu
DocType: Global Defaults,Global Defaults,Global Defaults
DocType: Leave Application,Follow via Email,Pratite putem e-pošte
DocType: Leave Allocation,Total Leaves Allocated,Ukupno dodeljenih listova
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Raw Material,Sirovina
DocType: Manufacturer,Limited to 12 characters,Ograničeno na 12 znakova
DocType: Selling Settings,Customer Naming By,Imenovanje korisnika
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 stavku {0} u redu {1}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js,New Sales Person Name,Ime novog prodajnog lica
DocType: Amazon MWS Settings,Amazon will synch data updated after this date,Amazon će sinkronizirati podatke ažurirane nakon tog datuma
DocType: Service Day,Service Day,Dan službe
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Porezi i naknade odbijene (valuta kompanije)
DocType: Project,Gross Margin %,Bruto marža%
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Bank Statement balance as per General Ledger,Bilans bankovnog izvoda prema glavnoj knjizi
apps/erpnext/erpnext/public/js/setup_wizard.js,Healthcare (beta),Zdravstvena zaštita (beta)
DocType: Shopify Settings,Default Warehouse to to create Sales Order and Delivery Note,Default Warehouse za kreiranje prodajnog naloga i isporuke
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Response Time for {0} at index {1} can't be greater than Resolution Time.,Vreme odgovora za {0} kod indeksa {1} ne može biti veće od vremena rezolucije.
DocType: Opportunity,Customer / Lead Name,Ime klijenta / vode
DocType: Student,EDU-STU-.YYYY.-,EDU-STU-.YYYY.- \ t
DocType: Expense Claim Advance,Unclaimed amount,Neuplaćeni iznos
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Source and target warehouse cannot be same for row {0},Izvorno i ciljno skladište ne može biti isto za redak {0}
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Redosled amortizacije {0}: Očekivana vrednost nakon korisnog veka mora biti veća ili jednaka {1}
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Please select date,Odaberite datum
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Salary Structure should have flexible benefit component(s) to dispense benefit amount,Struktura plata treba da ima fleksibilnu komponentu (e) beneficije za raspodjelu iznosa naknade
DocType: Employee Attendance Tool,Employee Attendance Tool,Alat za prisustvo zaposlenih
DocType: Employee,Educational Qualification,Obrazovna kvalifikacija
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Accessable Value,Dostupna vrijednost
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Sample quantity {0} cannot be more than received quantity {1},Količina uzorka {0} ne može biti veća od primljene količine {1}
DocType: POS Profile,Taxes and Charges,Porezi i takse
DocType: Opportunity,Contact Mobile No,Kontakt Mobile No
DocType: Employee,Joining Details,Detalji o pridruživanju
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Start Job,Start Job
DocType: Quality Action Table,Quality Action Table,Tabela akcije kvaliteta
DocType: Healthcare Practitioner,Phone (Office),Telefon (Office)
DocType: Timesheet Detail,Operation ID,Operativni ID
DocType: Soil Texture,Silt Loam,Silt Loam
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please set the Default Cost Center in {0} company.,Podesite Default Cost Center u kompaniji {0}.
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Update Email Group,Ažuriraj grupu e-pošte
DocType: Employee Promotion,Employee Promotion Detail,Detalji o promociji zaposlenih
DocType: Loan Application,Repayment Info,Info o otplati
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Show unclosed fiscal year's P&L balances,Prikažite bilans stanja dobiti i gubitka neotpisane fiskalne godine
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 dati ponudu, ali su sve stavke navedene. Ažuriranje RFQ statusa."
DocType: Asset,Finance Books,Finance Books
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,"Buying must be checked, if Applicable For is selected as {0}","Kupnja mora biti provjerena, ako je Primjenjivo za odabrano kao {0}"
DocType: Stock Settings,Role Allowed to edit frozen stock,Uloga Dopušteno za uređivanje zamrznutih dionica
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication Date,Datum zadnje komunikacije
DocType: Activity Cost,Costing Rate,Costing Rate
DocType: Shipping Rule,example: Next Day Shipping,primjer: Sljedeći dan isporuke
DocType: Bank Statement Transaction Entry,Payment Invoice Items,Stavke fakture plaćanja
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py,Tasks have been created for managing the {0} disease (on row {1}),Kreirani su zadaci za upravljanje {0} bolesti (u retku {1})
DocType: Healthcare Settings,Confirmation Message,Confirmation Message
DocType: Lab Test UOM,Lab Test UOM,Lab Test UOM
DocType: Leave Type,Earned Leave Frequency,Earned Leave Frequency
DocType: Loyalty Program,Loyalty Program Type,Tip programa lojalnosti
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 dostavu nema zemlju, koja je potrebna za ovo Pravilo o otpremi"
DocType: POS Profile,Terms and Conditions,Odredbe i uvjeti
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule',Molimo kliknite na &#39;Generiraj raspored&#39;
DocType: Sales Invoice,Total Qty,Total Qty
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,All other ITC,Svi ostali ITC
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Parties and Addresses,Uvozne strane i adrese
DocType: Item,List this Item in multiple groups on the website.,Navedite ovu stavku u više grupa na web stranici.
DocType: Request for Quotation,Message for Supplier,Poruka za dobavljača
DocType: Healthcare Practitioner,Phone (R),Telefon (R)
DocType: Maintenance Team Member,Team Member,Član tima
DocType: Asset Category Account,Asset Category Account,Account Asset Category Account
,Team Updates,Team Updates
DocType: Bank Account,Party,Party
DocType: Soil Analysis,Ca/Mg,Ca / Mg
DocType: Purchase Invoice,Write Off Amount (Company Currency),Napiši iznos (valuta kompanije)
DocType: Stock Entry,Including items for sub assemblies,Uključujući stavke za podsklopove
DocType: Course Topic,Topic Name,Naziv teme
DocType: Budget,Applicable on booking actual expenses,Primjenjivo na rezervacije stvarnih troškova
DocType: Purchase Invoice,Start date of current invoice's period,Datum početka tekućeg perioda fakture
apps/erpnext/erpnext/utilities/user_progress.py,Litre,Liter
DocType: Marketplace Settings,Hub Seller Name,Ime prodavca čvorišta
DocType: Stock Entry,Total Outgoing Value,Ukupna izlazna vrijednost
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Auto repeat document updated,Ažuriran je automatski dokument
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} u {1}. Da biste uključili {2} u stavku stavke, redovi {3} također moraju biti uključeni"
apps/erpnext/erpnext/config/stock.py,Serial No and Batch,Serijski broj i serija
DocType: Contract,Fulfilment Deadline,Rok ispunjenja
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Napravite radnu karticu
,Sales Person Commission Summary,Sažetak Komisije za prodajno osoblje
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,"Cannot process route, since Google Maps Settings is disabled.",Nije moguće obraditi rutu jer su postavke Google Karata onemogućene.
apps/erpnext/erpnext/utilities/user_progress.py,Go to Items,Idite na stavke
DocType: Asset Value Adjustment,Current Asset Value,Current Asset Value
DocType: Support Search Source,Result Preview Field,Polje pregleda rezultata
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: GL Entry,Against Voucher Type,Against Voucher Type
DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Uvjeti ispunjenja obrasca ugovora
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Allocating leaves...,Dodeljivanje lišća ...
DocType: Student Applicant,Admitted,Prihvaćeno
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Get Updates,Get Updates
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Black,Crna
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Year start date or end date is overlapping with {0}. To avoid please set company,"Datum početka ili datum završetka se preklapa s {0}. Da biste izbegli, molim vas, postavite kompaniju"
apps/erpnext/erpnext/templates/pages/projects.html,Show closed,Prikaži zatvoreno
DocType: Sample Collection,No. of print,Br
DocType: Sample Collection,HLC-SC-.YYYY.-,FHP-SC-.YYYY.- \ t
