diff --git a/erpnext/translations/bs.csv b/erpnext/translations/bs.csv
new file mode 100644
index 0000000..697f016
--- /dev/null
+++ b/erpnext/translations/bs.csv
@@ -0,0 +1,3331 @@
+ (Half Day),(Poludnevni)
+ and year: ,i godina:
+""" does not exists",""" Ne postoji"
+%  Delivered,Isporučena%
+% Amount Billed,% Iznos Naplaćeno
+% Billed,Naplaćeno%
+% Completed,Završen%
+% Delivered,% isporučeno
+% Installed,Instalirani%
+% Received,% Pozicija
+% of materials billed against this Purchase Order.,% Materijala naplaćeno protiv ove narudžbenice.
+% of materials billed against this Sales Order,% Materijala naplaćeno protiv ovog prodajnog naloga
+% of materials delivered against this Delivery Note,% Materijala dostavljenih protiv ove otpremnici
+% of materials delivered against this Sales Order,% Materijala dostavljenih od ovog prodajnog naloga
+% of materials ordered against this Material Request,% Materijala naredio protiv ovog materijala Zahtjeva
+% of materials received against this Purchase Order,% Materijala dobio protiv ove narudžbenice
+'Actual Start Date' can not be greater than 'Actual End Date',"' Stvarni datum početka ' ne može biti veći od stvarnih datuma završetka """
+'Based On' and 'Group By' can not be same,' Temelji se na' i 'Grupiranje po ' ne mogu biti isti
+'Days Since Last Order' must be greater than or equal to zero,' Dani od posljednjeg reda ' mora biti veći ili jednak nuli
+'Entries' cannot be empty,' Prijave ' ne može biti prazno
+'Expected Start Date' can not be greater than 'Expected End Date',""" Očekivani datum početka ' ne može biti veći od očekivanih datuma završetka"""
+'From Date' is required,' Od datuma ' je potrebno
+'From Date' must be after 'To Date',"' Od datuma ' mora biti poslije ' To Date """
+'Has Serial No' can not be 'Yes' for non-stock item,' Je rednim brojem ' ne može biti ' Da ' za ne - stock stavke
+'Notification Email Addresses' not specified for recurring invoice,"' Obavijest E-mail adrese "" nisu spomenuti za ponavljajuće fakture"
+'Profit and Loss' type account {0} not allowed in Opening Entry,' Račun dobiti i gubitka ' vrsta računa {0} nije dopuštena u otvor za
+'To Case No.' cannot be less than 'From Case No.',&#39;Za Predmet br&#39; ne može biti manja od &#39;Od Predmet br&#39;
+'To Date' is required,' To Date ' je potrebno
+'Update Stock' for Sales Invoice {0} must be set,' Update Stock ' za prodaje fakture {0} mora biti postavljen
+* Will be calculated in the transaction.,* Hoće li biti izračunata u transakciji.
+1 Currency = [?] FractionFor e.g. 1 USD = 100 Cent,1 valuta = [?] Frakcija  Za npr. 1 USD = 100 centi
+1. To maintain the customer wise item code and to make them searchable based on their code use this option,1. Za održavanje kupaca mudar Šifra i kako bi ih pretraživati ​​na temelju svog koda koristiti ovu opciju
+"<a href=""#Sales Browser/Customer Group"">Add / Edit</a>","<a href=""#Sales Browser/Customer Group""> Dodaj / Uredi < />"
+"<a href=""#Sales Browser/Item Group"">Add / Edit</a>","<a href=""#Sales Browser/Item Group""> Dodaj / Uredi < />"
+"<a href=""#Sales Browser/Territory"">Add / Edit</a>","<a href=""#Sales Browser/Territory""> Dodaj / Uredi < />"
+"<h4>Default Template</h4><p>Uses <a href=""http://jinja.pocoo.org/docs/templates/"">Jinja Templating</a> and all the fields of Address (including Custom Fields if any) will be available</p><pre><code>{{ address_line1 }}&lt;br&gt;{% if address_line2 %}{{ address_line2 }}&lt;br&gt;{% endif -%}{{ city }}&lt;br&gt;{% if state %}{{ state }}&lt;br&gt;{% endif -%}{% if pincode %} PIN:  {{ pincode }}&lt;br&gt;{% endif -%}{{ country }}&lt;br&gt;{% if phone %}Phone: {{ phone }}&lt;br&gt;{% endif -%}{% if fax %}Fax: {{ fax }}&lt;br&gt;{% endif -%}{% if email_id %}Email: {{ email_id }}&lt;br&gt;{% endif -%}</code></pre>","<h4> zadani predložak </ h4>  <p> Koristi <a href=""http://jinja.pocoo.org/docs/templates/""> Jinja templating </> i sva polja adresa ( uključujući Custom Fields ako postoje) će biti dostupan </ p>  <pre> <code> {{address_line1}} <br>  {% ako address_line2%} {{}} address_line2 <br> { endif% -%}  {{grad}} <br>  {% ako je državna%} {{}} Država <br> {% endif -%}  {% ako pincode%} PIN: {{pincode}} <br> {% endif -%}  {{country}} <br>  {% ako je telefon%} Telefon: {{telefonski}} <br> { endif% -%}  {% ako fax%} Fax: {{fax}} <br> {% endif -%}  {% ako email_id%} E: {{email_id}} <br> ; {% endif -%}  </ code> </ pre>"
+A Customer Group exists with same name please change the Customer name or rename the Customer Group,Grupa kupaca sa istim imenom postoji. Promijenite naziv kupca ili promijenite naziv grupe kupaca.
+A Customer exists with same name,Kupac sa istim imenom već postoji
+A Lead with this email id should exist,Kontakt sa ovim e-mailom bi trebao postojati
+A Product or Service,Proizvod ili usluga
+A Supplier exists with same name,Dobavljač sa istim imenom već postoji
+A symbol for this currency. For e.g. $,Simbol za ovu valutu. Kao npr. $
+AMC Expiry Date,AMC Datum isteka
+Abbr,Kratica
+Abbreviation cannot have more than 5 characters,Kratica ne može imati više od 5 znakova
+Above Value,Iznad vrijednosti
+Absent,Odsutan
+Acceptance Criteria,Kriterij prihvaćanja
+Accepted,Prihvaćeno
+Accepted + Rejected Qty must be equal to Received quantity for Item {0},Količina prihvaćeno + odbijeno mora biti jednaka zaprimljenoj količini artikla {0}
+Accepted Quantity,Prihvaćena količina
+Accepted Warehouse,Prihvaćeno skladište
+Account,Račun
+Account Balance,Bilanca računa
+Account Created: {0},Račun stvoren: {0}
+Account Details,Detalji računa
+Account Head,Zaglavlje računa
+Account Name,Naziv računa
+Account Type,Vrsta računa
+"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Stanje računa već u kredit, što se ne smije postaviti 'ravnoteža se mora' kao 'zaduženje """
+"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Stanje računa već u zaduženje, ne smiju postaviti 'ravnoteža se mora' kao 'kreditne'"
+Account for the warehouse (Perpetual Inventory) will be created under this Account.,Račun za skladište ( neprestani inventar) stvorit će se na temelju ovog računa .
+Account head {0} created,Zaglavlje računa {0} stvoreno
+Account must be a balance sheet account,Račun mora biti račun bilance
+Account with child nodes cannot be converted to ledger,Račun za dijete čvorova ne može pretvoriti u knjizi
+Account with existing transaction can not be converted to group.,Račun s postojećim transakcije ne može pretvoriti u skupinu .
+Account with existing transaction can not be deleted,Račun s postojećim transakcije ne može izbrisati
+Account with existing transaction cannot be converted to ledger,Račun s postojećim transakcije ne može pretvoriti u knjizi
+Account {0} cannot be a Group,Račun {0} ne može bitiGroup
+Account {0} does not belong to Company {1},Račun {0} ne pripada Društvu {1}
+Account {0} does not belong to company: {1},Račun {0} ne pripada tvrtki: {1}
+Account {0} does not exist,Račun {0} ne postoji
+Account {0} has been entered more than once for fiscal year {1},Račun {0} je ušao više od jednom za fiskalnu godinu {1}
+Account {0} is frozen,Račun {0} je zamrznuta
+Account {0} is inactive,Račun {0} nije aktivan
+Account {0} is not valid,Račun {0} nije ispravan
+Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,Račun {0} mora biti tipa ' Fixed Asset ' kao točka {1} jeAsset artikla
+Account {0}: Parent account {1} can not be a ledger,Račun {0}: Parent račun {1} Ne može biti knjiga
+Account {0}: Parent account {1} does not belong to company: {2},Račun {0}: Parent račun {1} ne pripadaju tvrtki: {2}
+Account {0}: Parent account {1} does not exist,Račun {0}: Parent račun {1} ne postoji
+Account {0}: You can not assign itself as parent account,Račun {0}: Ne može se dodijeliti roditeljskog računa
+Account: {0} can only be updated via \					Stock Transactions,Račun: {0} se može ažurirati samo putem \ Stock transakcije
+Accountant,računovođa
+Accounting,Računovodstvo
+"Accounting Entries can be made against leaf nodes, called","Računovodstvo Prijave se mogu podnijeti protiv lisnih čvorova , pozvao"
+"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Knjiženje zamrznuta do tog datuma, nitko ne može učiniti / mijenjati ulazak, osim uloge naveden u nastavku."
+Accounting journal entries.,Računovodstvo unosi u dnevnik.
+Accounts,Računi
+Accounts Browser,računi preglednik
+Accounts Frozen Upto,Računi Frozen Upto
+Accounts Payable,Računi naplativo
+Accounts Receivable,Potraživanja
+Accounts Settings,Računi Postavke
+Active,Aktivan
+Active: Will extract emails from ,Aktivno: Hoće li izdvojiti e-pošte iz
+Activity,Djelatnost
+Activity Log,Aktivnost Prijava
+Activity Log:,Aktivnost Prijavite:
+Activity Type,Aktivnost Tip
+Actual,Stvaran
+Actual Budget,Stvarni proračun
+Actual Completion Date,Stvarni datum dovršenja
+Actual Date,Stvarni datum
+Actual End Date,Stvarni Datum završetka
+Actual Invoice Date,Stvarni Datum fakture
+Actual Posting Date,Stvarni datum knjiženja
+Actual Qty,Stvarni Kol
+Actual Qty (at source/target),Stvarni Kol (na izvoru / ciljne)
+Actual Qty After Transaction,Stvarni Kol Nakon transakcije
+Actual Qty: Quantity available in the warehouse.,Stvarni Količina : Količina dostupni u skladištu .
+Actual Quantity,Stvarni Količina
+Actual Start Date,Stvarni datum početka
+Add,Dodati
+Add / Edit Taxes and Charges,Dodaj / Uredi poreza i pristojbi
+Add Child,Dodaj dijete
+Add Serial No,Dodaj rednim brojem
+Add Taxes,Dodaj Porezi
+Add Taxes and Charges,Dodaj poreze i troškove
+Add or Deduct,Dodavanje ili Oduzmite
+Add rows to set annual budgets on Accounts.,Dodavanje redaka postaviti godišnje proračune na računima.
+Add to Cart,Dodaj u košaricu
+Add to calendar on this date,Dodaj u kalendar ovog datuma
+Add/Remove Recipients,Dodaj / Ukloni primatelja
+Address,Adresa
+Address & Contact,Adresa i kontakt
+Address & Contacts,Adresa i kontakti
+Address Desc,Adresa Desc
+Address Details,Adresa - detalji
+Address HTML,Adresa HTML
+Address Line 1,Adresa Linija 1
+Address Line 2,Adresa Linija 2
+Address Template,Predložak adrese
+Address Title,Adresa - naslov
+Address Title is mandatory.,Adresa Naslov je obavezno .
+Address Type,Adresa Tip
+Address master.,Adresa master
+Administrative Expenses,Administrativni troškovi
+Administrative Officer,Administrativni službenik
+Advance Amount,Predujam Iznos
+Advance amount,Predujam iznos
+Advances,Napredak
+Advertisement,Reklama
+Advertising,oglašavanje
+Aerospace,zračno-kosmički prostor
+After Sale Installations,Nakon prodaje postrojenja
+Against,Protiv
+Against Account,Protiv računa
+Against Bill {0} dated {1},Protiv Bill {0} od {1}
+Against Docname,Protiv Docname
+Against Doctype,Protiv DOCTYPE
+Against Document Detail No,Protiv dokumenta Detalj No
+Against Document No,Protiv dokumentu nema
+Against Expense Account,Protiv Rashodi račun
+Against Income Account,Protiv računu dohotka
+Against Journal Voucher,Protiv Journal Voucheru
+Against Journal Voucher {0} does not have any unmatched {1} entry,Protiv Journal vaučer {0} nema premca {1} unos
+Against Purchase Invoice,Protiv Kupnja fakture
+Against Sales Invoice,Protiv prodaje fakture
+Against Sales Order,Protiv prodajnog naloga
+Against Voucher,Protiv Voucheru
+Against Voucher Type,Protiv voucher vrsti
+Ageing Based On,Starenje temelju On
+Ageing Date is mandatory for opening entry,Starenje Datum je obvezna za otvaranje unos
+Ageing date is mandatory for opening entry,Starenje datum je obavezno za otvaranje unos
+Agent,Agent
+Aging Date,Starenje Datum
+Aging Date is mandatory for opening entry,Starenje Datum je obvezna za otvaranje unos
+Agriculture,poljoprivreda
+Airline,aviokompanija
+All Addresses.,Sve adrese.
+All Contact,Sve Kontakt
+All Contacts.,Svi kontakti.
+All Customer Contact,Sve Kupac Kontakt
+All Customer Groups,Sve skupine kupaca
+All Day,All Day
+All Employee (Active),Sve zaposlenika (aktivna)
+All Item Groups,Svi Stavka Grupe
+All Lead (Open),Sve Olovo (Otvoreno)
+All Products or Services.,Svi proizvodi i usluge.
+All Sales Partner Contact,Sve Kontakt Prodaja partner
+All Sales Person,Sve Prodaje Osoba
+All Supplier Contact,Sve Dobavljač Kontakt
+All Supplier Types,Sve vrste Supplier
+All Territories,Svi Territories
+"All export related fields like currency, conversion rate, export total, export grand total etc are available in Delivery Note, POS, Quotation, Sales Invoice, Sales Order etc.","Sve izvoz srodnih područja poput valute , stopa pretvorbe , izvoz ukupno , izvoz sveukupnom itd su dostupni u Dostavnica, POS , ponude, prodaje fakture , prodajnog naloga i sl."
+"All import related fields like currency, conversion rate, import total, import grand total etc are available in Purchase Receipt, Supplier Quotation, Purchase Invoice, Purchase Order etc.","Svi uvoz srodnih područja poput valute , stopa pretvorbe , uvoz ukupno , uvoz sveukupnom itd su dostupni u Račun kupnje , dobavljač kotaciju , prilikom kupnje proizvoda, narudžbenice i sl."
+All items have already been invoiced,Svi predmeti su već fakturirano
+All these items have already been invoiced,Svi ovi predmeti su već fakturirano
+Allocate,Dodijeliti
+Allocate leaves for a period.,Dodijeliti lišće za razdoblje .
+Allocate leaves for the year.,Dodjela lišće za godinu dana.
+Allocated Amount,Dodijeljeni iznos
+Allocated Budget,Dodijeljeni proračuna
+Allocated amount,Dodijeljeni iznos
+Allocated amount can not be negative,Dodijeljeni iznos ne može biti negativna
+Allocated amount can not greater than unadusted amount,Dodijeljeni iznos ne može veći od iznosa unadusted
+Allow Bill of Materials,Dopustite Bill materijala
+Allow Bill of Materials should be 'Yes'. Because one or many active BOMs present for this item,Dopustite Bill materijala bi trebao biti ' Da ' . Budući da je jedan ili više aktivnih Sastavnice prisutne za ovu stavku
+Allow Children,dopustiti djeci
+Allow Dropbox Access,Dopusti pristup Dropbox
+Allow Google Drive Access,Dopusti pristup Google Drive
+Allow Negative Balance,Dopustite negativan saldo
+Allow Negative Stock,Dopustite negativnu Stock
+Allow Production Order,Dopustite proizvodnom nalogu
+Allow User,Dopusti korisnika
+Allow Users,Omogućiti korisnicima
+Allow the following users to approve Leave Applications for block days.,Dopusti sljedeći korisnici odobriti ostavite aplikacije za blok dana.
+Allow user to edit Price List Rate in transactions,Dopustite korisniku da uredite Ocijenite cjeniku u prometu
+Allowance Percent,Dodatak posto
+Allowance for over-{0} crossed for Item {1},Dodatak za prekomjerno {0} prešao za točku {1}
+Allowance for over-{0} crossed for Item {1}.,Dodatak za prekomjerno {0} prešao za točku {1}.
+Allowed Role to Edit Entries Before Frozen Date,Dopuštenih uloga za uređivanje upise Prije Frozen Datum
+Amended From,Izmijenjena Od
+Amount,Iznos
+Amount (Company Currency),Iznos (valuta tvrtke)
+Amount Paid,Plaćeni iznos
+Amount to Bill,Iznositi Billa
+An Customer exists with same name,Kupac postoji s istim imenom
+"An Item Group exists with same name, please change the item name or rename the item group","Stavka Grupa postoji s istim imenom , molimo promijenite ime stavku ili preimenovati stavku grupe"
+"An item exists with same name ({0}), please change the item group name or rename the item","Stavka postoji s istim imenom ( {0} ) , molimo promijenite ime stavku grupe ili preimenovati stavku"
+Analyst,analitičar
+Annual,godišnji
+Another Period Closing Entry {0} has been made after {1},Drugi period Zatvaranje Stupanje {0} je postignut nakon {1}
+Another Salary Structure {0} is active for employee {0}. Please make its status 'Inactive' to proceed.,Drugi Plaća Struktura {0} je aktivan za zaposlenika {0} . Molimo da svoj ​​status ' Neaktivan ' za nastavak .
+"Any other comments, noteworthy effort that should go in the records.","Svi ostali komentari, značajan napor da bi trebao ići u evidenciji."
+Apparel & Accessories,Odjeća i modni dodaci
+Applicability,Primjena
+Applicable For,primjenjivo za
+Applicable Holiday List,Primjenjivo odmor Popis
+Applicable Territory,primjenjivo teritorij
+Applicable To (Designation),Odnosi se na (Oznaka)
+Applicable To (Employee),Odnosi se na (Radnik)
+Applicable To (Role),Odnosi se na (uloga)
+Applicable To (User),Odnosi se na (Upute)
+Applicant Name,Podnositelj zahtjeva Ime
+Applicant for a Job.,Podnositelj prijave za posao.
+Application of Funds (Assets),Primjena sredstava ( aktiva )
+Applications for leave.,Prijave za odmor.
+Applies to Company,Odnosi se na Društvo
+Apply On,Nanesite na
+Appraisal,Procjena
+Appraisal Goal,Procjena gol
+Appraisal Goals,Ocjenjivanje Golovi
+Appraisal Template,Procjena Predložak
+Appraisal Template Goal,Procjena Predložak cilja
+Appraisal Template Title,Procjena Predložak Naslov
+Appraisal {0} created for Employee {1} in the given date range,Procjena {0} stvorena za zaposlenika {1} u određenom razdoblju
+Apprentice,šegrt
+Approval Status,Status odobrenja
+Approval Status must be 'Approved' or 'Rejected',"Status Odobrenje mora biti ""Odobreno"" ili "" Odbijeno """
+Approved,Odobren
+Approver,Odobritelj
+Approving Role,Odobravanje ulogu
+Approving Role cannot be same as role the rule is Applicable To,Odobravanje ulogu ne mogu biti isti kao i ulogepravilo odnosi se na
+Approving User,Odobravanje korisnika
+Approving User cannot be same as user the rule is Applicable To,Odobravanje korisnik ne može biti isto kao korisnikapravilo odnosi se na
+Are you sure you want to STOP ,Are you sure you want to STOP 
+Are you sure you want to UNSTOP ,Are you sure you want to UNSTOP 
+Arrear Amount,Iznos unatrag
+"As Production Order can be made for this item, it must be a stock item.","Kao Production Order može biti za tu stavku , to mora bitipredmet dionica ."
+As per Stock UOM,Kao po burzi UOM
+"As there are existing stock transactions for this item, you can not change the values of 'Has Serial No', 'Is Stock Item' and 'Valuation Method'","Kao što već postoje dionica transakcije za ovu stavku , ne možete mijenjati vrijednosti ' Je rednim brojem ' , ' Je Stock točka ""i"" Vrednovanje metoda'"
+Asset,Asset
+Assistant,asistent
+Associate,pomoćnik
+Atleast one of the Selling or Buying must be selected,Barem jedan od prodajete ili kupujete mora biti odabran
+Atleast one warehouse is mandatory,Atleast jednom skladištu je obavezno
+Attach Image,Pričvrstite slike
+Attach Letterhead,Pričvrstite zaglavljem
+Attach Logo,Pričvrstite Logo
+Attach Your Picture,Učvrstite svoju sliku
+Attendance,Pohađanje
+Attendance Date,Gledatelja Datum
+Attendance Details,Gledatelja Detalji
+Attendance From Date,Gledatelja Od datuma
+Attendance From Date and Attendance To Date is mandatory,Gledatelja Od datuma i posjećenost do sada je obvezno
+Attendance To Date,Gledatelja do danas
+Attendance can not be marked for future dates,Gledatelji ne može biti označena za budući datum
+Attendance for employee {0} is already marked,Gledatelja za zaposlenika {0} već označen
+Attendance record.,Gledatelja rekord.
+Authorization Control,Odobrenje kontrole
+Authorization Rule,Autorizacija Pravilo
+Auto Accounting For Stock Settings,Auto Računovodstvo za dionice Settings
+Auto Material Request,Auto Materijal Zahtjev
+Auto-raise Material Request if quantity goes below re-order level in a warehouse,Auto-podizanje Materijal zahtjev ako se količina ide ispod ponovno bi razinu u skladištu
+Automatically compose message on submission of transactions.,Automatski nova poruka na podnošenje transakcija .
+Automatically extract Job Applicants from a mail box ,Automatically extract Job Applicants from a mail box 
+Automatically extract Leads from a mail box e.g.,Automatski ekstrakt vodi iz mail box pr
+Automatically updated via Stock Entry of type Manufacture/Repack,Automatski ažurira putem burze Unos tipa Proizvodnja / prepakirati
+Automotive,automobilski
+Autoreply when a new mail is received,Automatski odgovori kad kada stigne nova pošta
+Available,Dostupno
+Available Qty at Warehouse,Dostupna količina na skladištu
+Available Stock for Packing Items,Raspoloživo stanje za pakirane artikle
+"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet","Dostupan u sastavnice , Dostavnica, prilikom kupnje proizvoda, proizvodnje narudžbi, narudžbenica , Račun kupnje , prodaje fakture , prodajnog naloga , Stock ulaska, timesheet"
+Average Age,Prosječna starost
+Average Commission Rate,Prosječna stopa komisija
+Average Discount,Prosječni popust
+Awesome Products,strašan Proizvodi
+Awesome Services,strašan Usluge
+BOM Detail No,BOM Detalj Ne
+BOM Explosion Item,BOM eksplozije artikla
+BOM Item,BOM artikla
+BOM No,BOM Ne
+BOM No. for a Finished Good Item,BOM broj za Gotovi Dobar točki
+BOM Operation,BOM Operacija
+BOM Operations,BOM operacije
+BOM Replace Tool,BOM Zamijenite alat
+BOM number is required for manufactured Item {0} in row {1},BOM broj potreban za proizvedenog artikla {0} je u redu {1}
+BOM number not allowed for non-manufactured Item {0} in row {1},BOM broj nisu dopušteni za ne - proizvedenog artikla {0} je u redu {1}
+BOM recursion: {0} cannot be parent or child of {2},BOM rekurzija : {0} ne može biti roditelj ili dijete od {2}
+BOM replaced,BOM zamijeniti
+BOM {0} for Item {1} in row {2} is inactive or not submitted,BOM {0} za točku {1} u redu {2} nije aktivan ili ne podnose
+BOM {0} is not active or not submitted,BOM {0} nije aktivan ili ne podnose
+BOM {0} is not submitted or inactive BOM for Item {1},BOM {0} nije podnesen ili neaktivne troškovnik za točku {1}
+Backup Manager,Backup Manager
+Backup Right Now,Backup Right Now
+Backups will be uploaded to,Sigurnosne kopije će biti učitane
+Balance Qty,Bilanca Kol
+Balance Sheet,završni račun
+Balance Value,Bilanca Vrijednost
+Balance for Account {0} must always be {1},Bilanca za račun {0} mora uvijek biti {1}
+Balance must be,Bilanca mora biti
+"Balances of Accounts of type ""Bank"" or ""Cash""","Stanja računa tipa "" Banka"" ili "" Cash """
+Bank,Banka
+Bank / Cash Account,Banka / Cash račun
+Bank A/C No.,Banka / C br
+Bank Account,Žiro račun
+Bank Account No.,Žiro račun broj
+Bank Accounts,bankovni računi
+Bank Clearance Summary,Razmak banka Sažetak
+Bank Draft,Bank Nacrt
+Bank Name,Ime banke
+Bank Overdraft Account,Bank Prekoračenje računa
+Bank Reconciliation,Banka pomirenje
+Bank Reconciliation Detail,Banka Pomirenje Detalj
+Bank Reconciliation Statement,Izjava banka pomirenja
+Bank Voucher,Banka bon
+Bank/Cash Balance,Banka / saldo
+Banking,bankarstvo
+Barcode,Barkod
+Barcode {0} already used in Item {1},Barkod {0} već koristi u točki {1}
+Based On,Na temelju
+Basic,osnovni
+Basic Info,Osnovne informacije
+Basic Information,Osnovne informacije
+Basic Rate,Osnovna stopa
+Basic Rate (Company Currency),Osnovna stopa (Društvo valuta)
+Batch,Serija
+Batch (lot) of an Item.,Hrpa (puno) od točke.
+Batch Finished Date,Hrpa Završio Datum
+Batch ID,Hrpa ID
+Batch No,Hrpa Ne
+Batch Started Date,Hrpa Autor Date
+Batch Time Logs for billing.,Hrpa Vrijeme Trupci za naplatu.
+Batch-Wise Balance History,Batch-Wise bilanca Povijest
+Batched for Billing,Izmiješane za naplatu
+Better Prospects,Bolji izgledi
+Bill Date,Bill Datum
+Bill No,Bill Ne
+Bill No {0} already booked in Purchase Invoice {1},Bill Ne {0} već rezervirani kupnje proizvoda {1}
+Bill of Material,Bill materijala
+Bill of Material to be considered for manufacturing,Bill of material treba uzeti u obzir za proizvodnju
+Bill of Materials (BOM),Bill materijala (BOM)
+Billable,Naplatu
+Billed,Naplaćeno
+Billed Amount,naplaćeno Iznos
+Billed Amt,Naplaćeno Amt
+Billing,Naplata
+Billing Address,Adresa za naplatu
+Billing Address Name,Adresa za naplatu Ime
+Billing Status,Naplata Status
+Bills raised by Suppliers.,Mjenice podigao dobavljače.
+Bills raised to Customers.,Mjenice podignuta na kupce.
+Bin,Kanta
+Bio,Bio
+Biotechnology,biotehnologija
+Birthday,rođendan
+Block Date,Blok Datum
+Block Days,Blok Dani
+Block leave applications by department.,Blok ostaviti aplikacija odjelu.
+Blog Post,Blog post
+Blog Subscriber,Blog Pretplatnik
+Blood Group,Krv Grupa
+Both Warehouse must belong to same Company,Oba Skladište mora pripadati istoj tvrtki
+Box,kutija
+Branch,Grana
+Brand,Marka
+Brand Name,Brand Name
+Brand master.,Marka majstor.
+Brands,Marke
+Breakdown,Slom
+Broadcasting,radiodifuzija
+Brokerage,posredništvo
+Budget,Budžet
+Budget Allocated,Proračun Dodijeljeni
+Budget Detail,Proračun Detalj
+Budget Details,Proračunski Detalji
+Budget Distribution,Proračun Distribucija
+Budget Distribution Detail,Proračun Distribucija Detalj
+Budget Distribution Details,Proračun raspodjele Detalji
+Budget Variance Report,Proračun varijance Prijavi
+Budget cannot be set for Group Cost Centers,Proračun ne može biti postavljen za grupe troška
+Build Report,Izgradite Prijavite
+Bundle items at time of sale.,Bala stavke na vrijeme prodaje.
+Business Development Manager,Business Development Manager
+Buying,Kupovina
+Buying & Selling,Kupnja i Prodaja
+Buying Amount,Kupnja Iznos
+Buying Settings,Kupnja postavki
+"Buying must be checked, if Applicable For is selected as {0}","Kupnja treba provjeriti, ako je primjenjivo za odabrano kao {0}"
+C-Form,C-Form
+C-Form Applicable,C-obrascu
+C-Form Invoice Detail,C-Obrazac Račun Detalj
+C-Form No,C-Obrazac br
+C-Form records,C - Form zapisi
+CENVAT Capital Goods,CENVAT Kapitalni proizvodi
+CENVAT Edu Cess,CENVAT Edu Posebni porez
+CENVAT SHE Cess,CENVAT ONA Posebni porez
+CENVAT Service Tax,CENVAT usluga Porezne
+CENVAT Service Tax Cess 1,CENVAT usluga Porezne Posebni porez na 1
+CENVAT Service Tax Cess 2,CENVAT usluga Porezne Posebni porez 2
+Calculate Based On,Izračunajte Na temelju
+Calculate Total Score,Izračunajte ukupni rezultat
+Calendar Events,Kalendar događanja
+Call,Nazvati
+Calls,pozivi
+Campaign,Kampanja
+Campaign Name,Naziv kampanje
+Campaign Name is required,Ime Kampanja je potrebno
+Campaign Naming By,Imenovanje Kampanja By
+Campaign-.####,Kampanje . # # # #
+Can be approved by {0},Može biti odobren od strane {0}
+"Can not filter based on Account, if grouped by Account","Ne možete filtrirati na temelju računa , ako grupirani po računu"
+"Can not filter based on Voucher No, if grouped by Voucher","Ne možete filtrirati na temelju vaučer No , ako grupirani po vaučer"
+Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Može se odnositi red samo akotip zadužen je "" Na prethodni red Iznos 'ili' prethodnog retka Total '"
+Cancel Material Visit {0} before cancelling this Customer Issue,Odustani Materijal Posjetite {0} prije poništenja ovog kupca Issue
+Cancel Material Visits {0} before cancelling this Maintenance Visit,Odustani Posjeta materijala {0} prije otkazivanja ovog održavanja pohod
+Cancelled,Otkazan
+Cancelling this Stock Reconciliation will nullify its effect.,Otkazivanje Ove obavijesti pomirenja će poništiti svoj ​​učinak .
+Cannot Cancel Opportunity as Quotation Exists,Ne mogu otkazati prilika kao kotacija Exist
+Cannot approve leave as you are not authorized to approve leaves on Block Dates,Ne može odobriti dopust kako niste ovlašteni za odobravanje lišće o skupnom datume
+Cannot cancel because Employee {0} is already approved for {1},"Ne mogu otkazati , jer zaposlenika {0} već je odobren za {1}"
+Cannot cancel because submitted Stock Entry {0} exists,"Ne mogu otkazati , jer podnijela Stock Stupanje {0} postoji"
+Cannot carry forward {0},Ne mogu prenositi {0}
+Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Ne možete promijeniti fiskalnu godinu datum početka i datum završetka fiskalne godine kada Fiskalna godina se sprema.
+"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Ne mogu promijeniti tvrtke zadanu valutu , jer postoje neki poslovi . Transakcije mora biti otkazana promijeniti zadanu valutu ."
+Cannot convert Cost Center to ledger as it has child nodes,"Ne može se pretvoriti troška za knjigu , kao da ima djece čvorova"
+Cannot covert to Group because Master Type or Account Type is selected.,"Ne može tajno da Grupe , jer je izabran Master Type ili račun Type ."
+Cannot deactive or cancle BOM as it is linked with other BOMs,Ne možete DEACTIVE ili cancle troškovnik jer je povezan s drugim sastavnicama
+"Cannot declare as lost, because Quotation has been made.","Ne može proglasiti izgubili , jer citat je napravio ."
+Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Ne mogu odbiti kada kategorija je "" vrednovanje "" ili "" Vrednovanje i Total '"
+"Cannot delete Serial No {0} in stock. First remove from stock, then delete.","Ne možete izbrisati rednim brojem {0} na lageru . Prvo izvadite iz zalihe , a zatim izbrisati ."
+"Cannot directly set amount. For 'Actual' charge type, use the rate field","Ne može se izravno postaviti iznos . Za stvarnu ' tipa naboja , koristiti polje rate"
+"Cannot overbill for Item {0} in row {0} more than {1}. To allow overbilling, please set in Stock Settings","Ne možete overbill za točku {0} u redu {0} više od {1}. Da bi se omogućilo overbilling, molimo vas postavljen u Stock Settings"
+Cannot produce more Item {0} than Sales Order quantity {1},Ne može proizvesti više predmeta {0} od prodajnog naloga količina {1}
+Cannot refer row number greater than or equal to current row number for this Charge type,Ne mogu se odnositi broj retka veći ili jednak trenutnom broju red za ovu vrstu Charge
+Cannot return more than {0} for Item {1},Ne može se vratiti više od {0} za točku {1}
+Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Ne možete odabrati vrstu naboja kao ' na prethodnim Row Iznos ""ili"" u odnosu na prethodnu Row Ukupno ""za prvi red"
+Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for valuation. You can select only 'Total' option for previous row amount or previous row total,"Ne možete odabrati vrstu naboja kao ' na prethodnim Row Iznos ""ili"" u odnosu na prethodnu Row Total ' za vrednovanje . Možete odabrati samo ' Ukupno ' opciju za prethodni iznos red ili prethodne ukupno redu"
+Cannot set as Lost as Sales Order is made.,Ne mogu se postaviti kao izgubljen kao prodajnog naloga je napravio .
+Cannot set authorization on basis of Discount for {0},Ne mogu postaviti odobrenje na temelju popusta za {0}
+Capacity,Kapacitet
+Capacity Units,Kapacitet jedinice
+Capital Account,Kapitalni račun
+Capital Equipments,Kapitalni oprema
+Carry Forward,Prenijeti
+Carry Forwarded Leaves,Nosi proslijeđen lišće
+Case No(s) already in use. Try from Case No {0},Slučaj Ne ( i) je već u uporabi . Pokušajte s predmetu broj {0}
+Case No. cannot be 0,Slučaj broj ne može biti 0
+Cash,Gotovina
+Cash In Hand,Novac u blagajni
+Cash Voucher,Novac bon
+Cash or Bank Account is mandatory for making payment entry,Novac ili bankovni račun je obvezna za izradu ulazak plaćanje
+Cash/Bank Account,Novac / bankovni račun
+Casual Leave,Casual dopust
+Cell Number,Mobitel Broj
+Change UOM for an Item.,Promjena UOM za predmet.
+Change the starting / current sequence number of an existing series.,Promjena polaznu / tekući redni broj postojeće serije.
+Channel Partner,Channel Partner
+Charge of type 'Actual' in row {0} cannot be included in Item Rate,Punjenje tipa ' Stvarni ' u redu {0} ne mogu biti uključeni u točki Rate
+Chargeable,Naplativ
+Charity and Donations,Ljubav i donacije
+Chart Name,Ime grafikona
+Chart of Accounts,Kontnog
+Chart of Cost Centers,Grafikon troškovnih centara
+Check how the newsletter looks in an email by sending it to your email.,Pogledajte kako izgleda newsletter u e-mail tako da ga šalju na e-mail.
+"Check if recurring invoice, uncheck to stop recurring or put proper End Date","Provjerite je li ponavljajući fakture, poništite zaustaviti ponavljajući ili staviti odgovarajući datum završetka"
+"Check if you need automatic recurring invoices. After submitting any sales invoice, Recurring section will be visible.","Provjerite ako trebate automatske ponavljajuće fakture. Nakon odavanja prodaje fakturu, ponavljajućih sekcija će biti vidljiv."
+Check if you want to send salary slip in mail to each employee while submitting salary slip,"Provjerite ako želite poslati plaće slip u pošti svakom zaposleniku, dok podnošenje plaće slip"
+Check this if you want to force the user to select a series before saving. There will be no default if you check this.,Označite ovo ako želite prisiliti korisniku odabir seriju prije spremanja. Tu će biti zadana ako to provjerili.
+Check this if you want to show in website,Označite ovo ako želite pokazati u web
+Check this to disallow fractions. (for Nos),Provjerite to da ne dopušta frakcija. (Za br)
+Check this to pull emails from your mailbox,Provjerite to povući e-pošte iz poštanskog sandučića
+Check to activate,Provjerite za aktiviranje
+Check to make Shipping Address,Provjerite otprema adresu
+Check to make primary address,Provjerite primarnu adresu
+Chemical,kemijski
+Cheque,Ček
+Cheque Date,Ček Datum
+Cheque Number,Ček Broj
+Child account exists for this account. You can not delete this account.,Dijete računa postoji za taj račun . Ne možete izbrisati ovaj račun .
+City,Grad
+City/Town,Grad / Mjesto
+Claim Amount,Iznos štete
+Claims for company expense.,Potraživanja za tvrtke trošak.
+Class / Percentage,Klasa / Postotak
+Classic,Klasik
+Clear Table,Jasno Tablica
+Clearance Date,Razmak Datum
+Clearance Date not mentioned,Razmak Datum nije spomenuo
+Clearance date cannot be before check date in row {0},Datum rasprodaja ne može biti prije datuma check u redu {0}
+Click on 'Make Sales Invoice' button to create a new Sales Invoice.,Kliknite na &quot;Make prodaje Račun &#39;gumb za stvaranje nove prodaje fakture.
+Click on a link to get options to expand get options ,Click on a link to get options to expand get options 
+Client,Klijent
+Close Balance Sheet and book Profit or Loss.,Zatvori bilanca i knjiga dobit ili gubitak .
+Closed,Zatvoreno
+Closing (Cr),Zatvaranje (Cr)
+Closing (Dr),Zatvaranje (DR)
+Closing Account Head,Zatvaranje računa šefa
+Closing Account {0} must be of type 'Liability',Zatvaranje računa {0} mora biti tipa ' odgovornosti '
+Closing Date,Datum zatvaranja
+Closing Fiscal Year,Zatvaranje Fiskalna godina
+Closing Qty,zatvaranje Kol
+Closing Value,zatvaranje vrijednost
+CoA Help,CoA Pomoć
+Code,Šifra
+Cold Calling,Hladno pozivanje
+Color,Boja
+Column Break,Kolona Break
+Comma separated list of email addresses,Zarez odvojen popis e-mail adrese
+Comment,Komentirati
+Comments,Komentari
+Commercial,trgovački
+Commission,provizija
+Commission Rate,Komisija Stopa
+Commission Rate (%),Komisija stopa (%)
+Commission on Sales,Komisija za prodaju
+Commission rate cannot be greater than 100,Proviziju ne može biti veća od 100
+Communication,Komunikacija
+Communication HTML,Komunikacija HTML
+Communication History,Komunikacija Povijest
+Communication log.,Komunikacija dnevnik.
+Communications,Communications
+Company,Društvo
+Company (not Customer or Supplier) master.,Društvo ( ne kupaca i dobavljača ) majstor .
+Company Abbreviation,Kratica Društvo
+Company Details,Tvrtka Detalji
+Company Email,tvrtka E-mail
+"Company Email ID not found, hence mail not sent","Tvrtka E-mail ID nije pronađen , pa se ne mail poslan"
+Company Info,Podaci o tvrtki
+Company Name,Ime tvrtke
+Company Settings,Tvrtka Postavke
+Company is missing in warehouses {0},Tvrtka je nestalo u skladištima {0}
+Company is required,Tvrtka je potrebno
+Company registration numbers for your reference. Example: VAT Registration Numbers etc.,Tvrtka registracijski brojevi za svoju referencu. Primjer: PDV registracijski brojevi i sl.
+Company registration numbers for your reference. Tax numbers etc.,Tvrtka registracijski brojevi za svoju referencu. Porezni brojevi itd.
+"Company, Month and Fiscal Year is mandatory","Tvrtka , Mjesec i Fiskalna godina je obvezno"
+Compensatory Off,kompenzacijski Off
+Complete,Dovršiti
+Complete Setup,kompletan Setup
+Completed,Dovršen
+Completed Production Orders,Završeni Radni nalozi
+Completed Qty,Završen Kol
+Completion Date,Završetak Datum
+Completion Status,Završetak Status
+Computer,računalo
+Computers,Računala
+Confirmation Date,potvrda Datum
+Confirmed orders from Customers.,Potvrđeno narudžbe od kupaca.
+Consider Tax or Charge for,Razmislite poreza ili pristojbi za
+Considered as Opening Balance,Smatra početnog stanja
+Considered as an Opening Balance,Smatra se kao početno stanje
+Consultant,Konzultant
+Consulting,savjetodavni
+Consumable,potrošni
+Consumable Cost,potrošni cost
+Consumable cost per hour,Potrošni cijena po satu
+Consumed Qty,Potrošeno Kol
+Consumer Products,Consumer Products
+Contact,Kontakt
+Contact Control,Kontaktirajte kontrolu
+Contact Desc,Kontakt ukratko
+Contact Details,Kontakt podaci
+Contact Email,Kontakt email
+Contact HTML,Kontakt HTML
+Contact Info,Kontakt Informacije
+Contact Mobile No,Kontak GSM
+Contact Name,Kontakt ime
+Contact No.,Kontakt broj
+Contact Person,Kontakt osoba
+Contact Type,Vrsta kontakta
+Contact master.,Kontakt majstor .
+Contacts,Kontakti
+Content,Sadržaj
+Content Type,Vrsta sadržaja
+Contra Voucher,Contra bon
+Contract,ugovor
+Contract End Date,Ugovor Datum završetka
+Contract End Date must be greater than Date of Joining,Ugovor Datum završetka mora biti veći od dana ulaska u
+Contribution (%),Doprinos (%)
+Contribution to Net Total,Doprinos neto Ukupno
+Conversion Factor,Konverzijski faktor
+Conversion Factor is required,Faktor pretvorbe je potrebno
+Conversion factor cannot be in fractions,Faktor pretvorbe ne može biti u frakcijama
+Conversion factor for default Unit of Measure must be 1 in row {0},Faktor pretvorbe za zadani jedinica mjere mora biti jedan u nizu {0}
+Conversion rate cannot be 0 or 1,Stopa pretvorbe ne može biti 0 ili 1
+Convert into Recurring Invoice,Pretvori u Ponavljajući fakture
+Convert to Group,Pretvori u Grupi
+Convert to Ledger,Pretvori u knjizi
+Converted,Pretvoreno
+Copy From Item Group,Primjerak iz točke Group
+Cosmetics,kozmetika
+Cost Center,Troška
+Cost Center Details,Troška Detalji
+Cost Center Name,Troška Name
+Cost Center is required for 'Profit and Loss' account {0},Troška je potrebno za račun ' dobiti i gubitka ' {0}
+Cost Center is required in row {0} in Taxes table for type {1},Troška potrebno je u redu {0} poreza stolom za vrstu {1}
+Cost Center with existing transactions can not be converted to group,Troška s postojećim transakcija ne može se prevesti u skupini
+Cost Center with existing transactions can not be converted to ledger,Troška s postojećim transakcija ne može pretvoriti u knjizi
+Cost Center {0} does not belong to Company {1},Troška {0} ne pripada Tvrtka {1}
+Cost of Goods Sold,Troškovi prodane robe
+Costing,Koštanje
+Country,Zemlja
+Country Name,Država Ime
+Country wise default Address Templates,Država mudar zadana adresa predlošci
+"Country, Timezone and Currency","Država , vremenske zone i valute"
+Create Bank Voucher for the total salary paid for the above selected criteria,Stvaranje Bank bon za ukupne plaće isplaćene za gore odabranih kriterija
+Create Customer,izraditi korisnika
+Create Material Requests,Stvaranje materijalni zahtijevi
+Create New,Stvori novo
+Create Opportunity,Stvaranje prilika
+Create Production Orders,Stvaranje radne naloge
+Create Quotation,stvaranje citata
+Create Receiver List,Stvaranje Receiver popis
+Create Salary Slip,Stvaranje plaće Slip
+Create Stock Ledger Entries when you submit a Sales Invoice,Otvori Stock stavke knjige kada podnijeti prodaje fakture
+"Create and manage daily, weekly and monthly email digests.","Stvaranje i upravljanje dnevne , tjedne i mjesečne e razgradnju ."
+Create rules to restrict transactions based on values.,Stvaranje pravila za ograničavanje prometa na temelju vrijednosti .
+Created By,Stvorio
+Creates salary slip for above mentioned criteria.,Stvara plaće slip za gore navedene kriterije.
+Creation Date,Datum stvaranja
+Creation Document No,Stvaranje dokumenata nema
+Creation Document Type,Tip stvaranje dokumenata
+Creation Time,vrijeme kreiranja
+Credentials,Svjedodžba
+Credit,Kredit
+Credit Amt,Kreditne Amt
+Credit Card,kreditna kartica
+Credit Card Voucher,Kreditne kartice bon
+Credit Controller,Kreditne kontroler
+Credit Days,Kreditne Dani
+Credit Limit,Kreditni limit
+Credit Note,Kreditne Napomena
+Credit To,Kreditne Da
+Currency,Valuta
+Currency Exchange,Mjenjačnica
+Currency Name,Valuta Ime
+Currency Settings,Valuta Postavke
+Currency and Price List,Valuta i cjenik
+Currency exchange rate master.,Majstor valute .
+Current Address,Trenutna adresa
+Current Address Is,Trenutni Adresa je
+Current Assets,Dugotrajna imovina
+Current BOM,Trenutni BOM
+Current BOM and New BOM can not be same,Trenutni troškovnik i novi troškovnik ne mogu biti isti
+Current Fiscal Year,Tekuće fiskalne godine
+Current Liabilities,Kratkoročne obveze
+Current Stock,Trenutni Stock
+Current Stock UOM,Trenutni kataloški UOM
+Current Value,Trenutna vrijednost
+Custom,Običaj
+Custom Autoreply Message,Prilagođena Automatski Poruka
+Custom Message,Prilagođena poruka
+Customer,Kupac
+Customer (Receivable) Account,Kupac (Potraživanja) račun
+Customer / Item Name,Kupac / Stavka Ime
+Customer / Lead Address,Kupac / Olovo Adresa
+Customer / Lead Name,Kupac / Ime osobe
+Customer > Customer Group > Territory,Kupac> Korisnička Group> Regija
+Customer Account Head,Kupac račun Head
+Customer Acquisition and Loyalty,Stjecanje kupaca i lojalnost
+Customer Address,Kupac Adresa
+Customer Addresses And Contacts,Kupac adrese i kontakti
+Customer Addresses and Contacts,Kupca adrese i kontakti
+Customer Code,Kupac Šifra
+Customer Codes,Kupac Kodovi
+Customer Details,Korisnički podaci
+Customer Feedback,Kupac Ocjena
+Customer Group,Kupac Grupa
+Customer Group / Customer,Kupac Group / kupaca
+Customer Group Name,Kupac Grupa Ime
+Customer Intro,Kupac Uvod
+Customer Issue,Kupac Issue
+Customer Issue against Serial No.,Kupac izdavanja protiv serijski broj
+Customer Name,Naziv klijenta
+Customer Naming By,Kupac Imenovanje By
+Customer Service,Služba za korisnike
+Customer database.,Kupac baze.
+Customer is required,Kupac je dužan
+Customer master.,Majstor Korisnička .
+Customer required for 'Customerwise Discount',Kupac je potrebno za ' Customerwise Popust '
+Customer {0} does not belong to project {1},Korisnik {0} ne pripada projicirati {1}
+Customer {0} does not exist,Korisnik {0} ne postoji
+Customer's Item Code,Kupca Stavka Šifra
+Customer's Purchase Order Date,Kupca narudžbenice Datum
+Customer's Purchase Order No,Kupca Narudžbenica br
+Customer's Purchase Order Number,Kupac je broj narudžbenice
+Customer's Vendor,Kupca Prodavatelj
+Customers Not Buying Since Long Time,Kupci ne kupuju jer dugo vremena
+Customerwise Discount,Customerwise Popust
+Customize,Prilagodite
+Customize the Notification,Prilagodite Obavijest
+Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Prilagodite uvodni tekst koji ide kao dio tog e-maila. Svaka transakcija ima zaseban uvodni tekst.
+DN Detail,DN detalj
+Daily,Svakodnevno
+Daily Time Log Summary,Dnevno vrijeme Log Profila
+Database Folder ID,Direktorij podatkovne baze ID
+Database of potential customers.,Baza potencijalnih kupaca.
+Date,Datum
+Date Format,Oblik datuma
+Date Of Retirement,Datum odlaska u mirovinu
+Date Of Retirement must be greater than Date of Joining,Datum umirovljenja mora biti veći od datuma pristupa
+Date is repeated,Datum se ponavlja
+Date of Birth,Datum rođenja
+Date of Issue,Datum izdavanja
+Date of Joining,Datum pristupa
+Date of Joining must be greater than Date of Birth,Datum pristupa mora biti veći od datuma rođenja
+Date on which lorry started from supplier warehouse,Datum kojeg je kamion krenuo sa dobavljačeva skladišta
+Date on which lorry started from your warehouse,Datum kojeg je kamion otišao sa Vašeg skladišta
+Dates,Datumi
+Days Since Last Order,Dana od posljednje narudžbe
+Days for which Holidays are blocked for this department.,Dani za koje su praznici blokirani za ovaj odjel.
+Dealer,Trgovac
+Debit,Zaduženje
+Debit Amt,Rashod Amt
+Debit Note,Rashodi - napomena
+Debit To,Rashodi za
+Debit and Credit not equal for this voucher. Difference is {0}.,Rashodi i kreditiranje nisu jednaki za ovog jamca. Razlika je {0} .
+Deduct,Odbiti
+Deduction,Odbitak
+Deduction Type,Tip odbitka
+Deduction1,Odbitak 1
+Deductions,Odbici
+Default,Zadano
+Default Account,Zadani račun
+Default Address Template cannot be deleted,Zadani predložak adrese ne može se izbrisati
+Default Amount,Zadani iznos
+Default BOM,Zadani BOM
+Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,"Zadana banka / novčani račun će se automatski ažurirati prema POS računu, kada je ovaj mod odabran."
+Default Bank Account,Zadani bankovni račun
+Default Buying Cost Center,Zadani trošak kupnje
+Default Buying Price List,Zadani cjenik kupnje
+Default Cash Account,Zadani novčani račun
+Default Company,Zadana tvrtka
+Default Currency,Zadana valuta
+Default Customer Group,Zadana grupa korisnika
+Default Expense Account,Zadani račun rashoda
+Default Income Account,Zadani račun prihoda
+Default Item Group,Zadana grupa artikala
+Default Price List,Zadani cjenik
+Default Purchase Account in which cost of the item will be debited.,Zadani račun kupnje - na koji će trošak artikla biti terećen.
+Default Selling Cost Center,Zadani trošak prodaje
+Default Settings,Zadane postavke
+Default Source Warehouse,Zadano izvorno skladište
+Default Stock UOM,Zadana kataloška mjerna jedinica
+Default Supplier,Glavni dobavljač
+Default Supplier Type,Zadani tip dobavljača
+Default Target Warehouse,Centralno skladište
+Default Territory,Zadani teritorij
+Default Unit of Measure,Zadana mjerna jedinica
+"Default Unit of Measure can not be changed directly because you have already made some transaction(s) with another UOM. To change default UOM, use 'UOM Replace Utility' tool under Stock module.","Zadana mjerna jedinica ne može se mijenjati izravno, jer ste već napravili neku transakciju sa drugom mjernom jedinicom. Za promjenu zadane mjerne jedinice, koristite 'Alat za mijenjanje mjernih jedinica' alat preko Stock modula."
+Default Valuation Method,Zadana metoda vrednovanja
+Default Warehouse,Glavno skladište
+Default Warehouse is mandatory for stock Item.,Glavno skladište je obvezno za zalihu artikala.
+Default settings for accounting transactions.,Zadane postavke za računovodstvene poslove.
+Default settings for buying transactions.,Zadane postavke za transakciju kupnje.
+Default settings for selling transactions.,Zadane postavke za transakciju prodaje.
+Default settings for stock transactions.,Zadane postavke za burzovne transakcije.
+Defense,Obrana
+"Define Budget for this Cost Center. To set budget action, see <a href=""#!List/Company"">Company Master</a>","Odredite proračun za ovu troška. Da biste postavili proračuna akciju, vidi <a href=""#!List/Company"">Tvrtka Master</a>"
+Del,Izbr
+Delete,Izbrisati
+Delete {0} {1}?,Izbrisati {0} {1} ?
+Delivered,Isporučeno
+Delivered Items To Be Billed,Isporučeni proizvodi za naplatiti
+Delivered Qty,Isporučena količina
+Delivered Serial No {0} cannot be deleted,Isporučeni serijski broj {0} se ne može izbrisati
+Delivery Date,Datum isporuke
+Delivery Details,Detalji isporuke
+Delivery Document No,Dokument isporuke br
+Delivery Document Type,Dokument isporuke - tip
+Delivery Note,Otpremnica
+Delivery Note Item,Otpremnica artikla
+Delivery Note Items,Otpremnica artikala
+Delivery Note Message,Otpremnica - poruka
+Delivery Note No,Otpremnica br
+Delivery Note Required,Potrebna je otpremnica
+Delivery Note Trends,Trendovi otpremnica
+Delivery Note {0} is not submitted,Otpremnica {0} nije potvrđena
+Delivery Note {0} must not be submitted,Otpremnica {0} ne smije biti potvrđena
+Delivery Notes {0} must be cancelled before cancelling this Sales Order,Otpremnica {0} mora biti otkazana prije poništenja ove narudžbenice
+Delivery Status,Status isporuke
+Delivery Time,Vrijeme isporuke
+Delivery To,Dostava za
+Department,Odjel
+Department Stores,Robne kuće
+Depends on LWP,Ovisi o LWP
+Depreciation,Amortizacija
+Description,Opis
+Description HTML,HTML opis
+Designation,Oznaka
+Designer,Imenovatelj
+Detailed Breakup of the totals,Detaljni raspada ukupnim
+Details,Detalji
+Difference (Dr - Cr),Razlika ( dr. - Cr )
+Difference Account,Račun razlike
+"Difference Account must be a 'Liability' type account, since this Stock Reconciliation is an Opening Entry","Razlika račun mora biti' odgovornosti ' vrsta računa , jer to Stock Pomirenje jeulazni otvor"
+Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,Različite mjerne jedinice artikala će dovesti do ukupne pogrešne neto težine. Budite sigurni da je neto težina svakog artikla u istoj mjernoj jedinici.
+Direct Expenses,Izravni troškovi
+Direct Income,Izravni dohodak
+Disable,Ugasiti
+Disable Rounded Total,Ugasiti zaokruženi iznos
+Disabled,Ugašeno
+Discount  %,Popust%
+Discount %,Popust%
+Discount (%),Popust (%)
+Discount Amount,Iznos popusta
+"Discount Fields will be available in Purchase Order, Purchase Receipt, Purchase Invoice","Popust polja će biti dostupna u narudžbenici, primci i računu kupnje"
+Discount Percentage,Postotak popusta
+Discount Percentage can be applied either against a Price List or for all Price List.,Postotak popusta se može neovisno primijeniti prema jednom ili za više cjenika.
+Discount must be less than 100,Popust mora biti manji od 100
+Discount(%),Popust (%)
+Dispatch,Otpremanje
+Display all the individual items delivered with the main items,Prikaži sve pojedinačne artikle isporučene sa glavnim artiklima
+Distribute transport overhead across items.,Podijeliti cijenu prijevoza prema artiklima.
+Distribution,Distribucija
+Distribution Id,ID distribucije
+Distribution Name,Naziv distribucije
+Distributor,Distributer
+Divorced,Rastavljen
+Do Not Contact,Ne kontaktirati
+Do not show any symbol like $ etc next to currencies.,Ne pokazati nikakav simbol kao $ iza valute.
+Do really want to unstop production order: ,Želite li ponovno pokrenuti proizvodnju:
+Do you really want to STOP ,Želite li stvarno stati
+Do you really want to STOP this Material Request?,Želite li stvarno stopirati ovaj zahtjev za materijalom?
+Do you really want to Submit all Salary Slip for month {0} and year {1},Želite li zaista podnijeti sve klizne plaće za mjesec {0} i godinu {1}
+Do you really want to UNSTOP ,Želite li zaista pokrenuti
+Do you really want to UNSTOP this Material Request?,Želite li stvarno ponovno pokrenuti ovaj zahtjev za materijalom?
+Do you really want to stop production order: ,Želite li stvarno prekinuti proizvodnju:
+Doc Name,Doc ime
+Doc Type,Doc tip
+Document Description,Opis dokumenta
+Document Type,Tip dokumenta
+Documents,Dokumenti
+Domain,Domena
+Don't send Employee Birthday Reminders,Ne šaljite podsjetnik za rođendan zaposlenika
+Download Materials Required,Preuzmite - Potrebni materijali
+Download Reconcilation Data,Preuzmite Rekoncilijacijske podatke
+Download Template,Preuzmite predložak
+Download a report containing all raw materials with their latest inventory status,Preuzmite izvješće koje sadrži sve sirovine sa svojim najnovijim statusom inventara
+"Download the Template, fill appropriate data and attach the modified file.","Preuzmite predložak , ispunite odgovarajuće podatke i priložite izmijenjenu datoteku ."
+"Download the Template, fill appropriate data and attach the modified file.All dates and employee combination in the selected period will come in the template, with existing attendance records","Preuzmite predložak, ispunite odgovarajuće podatke i priložite izmijenjenu datoteku. Svi datumi i kombinacija zaposlenika u odabranom razdoblju će doći u predlošku, s postojećim izostancima"
+Draft,Nepotvrđeno
+Dropbox,Dropbox
+Dropbox Access Allowed,Dozvoljen pristup Dropboxu
+Dropbox Access Key,Dropbox pristupni ključ
+Dropbox Access Secret,Dropbox tajni pristup
+Due Date,Datum dospijeća
+Due Date cannot be after {0},Datum dospijeća ne može biti poslije {0}
+Due Date cannot be before Posting Date,Datum dospijeća ne može biti prije datuma objavljivanja
+Duplicate Entry. Please check Authorization Rule {0},Dupli unos. Provjerite pravila za autorizaciju {0}
+Duplicate Serial No entered for Item {0},Dupli serijski broj unešen za artikal {0}
+Duplicate entry,Dupli unos
+Duplicate row {0} with same {1},Dupli red {0} sa istim {1}
+Duties and Taxes,Carine i porezi
+ERPNext Setup,ERPNext Setup
+Earliest,Najstarije
+Earnest Money,kapara
+Earning,Zarada
+Earning & Deduction,Zarada &amp; Odbitak
+Earning Type,Zarada Vid
+Earning1,Earning1
+Edit,Uredi
+Edu. Cess on Excise,Edu. Posebni porez na trošarine
+Edu. Cess on Service Tax,Edu. Posebni porez na porez na uslugu
+Edu. Cess on TDS,Edu. Posebni porez na TDS
+Education,Obrazovanje
+Educational Qualification,Obrazovne kvalifikacije
+Educational Qualification Details,Obrazovni Pojedinosti kvalifikacije
+Eg. smsgateway.com/api/send_sms.cgi,Npr.. smsgateway.com / api / send_sms.cgi
+Either debit or credit amount is required for {0},Ili debitna ili kreditna iznos potreban za {0}
+Either target qty or target amount is mandatory,Ili meta Količina ili ciljani iznos je obvezna
+Either target qty or target amount is mandatory.,Ili meta Količina ili ciljani iznos je obavezna .
+Electrical,Električna
+Electricity Cost,Troškovi struje
+Electricity cost per hour,Troškovi struje po satu
+Electronics,Elektronika
+Email,E-mail
+Email Digest,E-pošta
+Email Digest Settings,E-pošta Postavke
+Email Digest: ,Email Digest: 
+Email Id,E-mail ID
+"Email Id where a job applicant will email e.g. ""jobs@example.com""",E-mail Id gdje posao zahtjeva će e-mail npr. &quot;jobs@example.com&quot;
+Email Notifications,E-mail obavijesti
+Email Sent?,Je li e-mail poslan?
+"Email id must be unique, already exists for {0}","Email ID mora biti jedinstven , već postoji za {0}"
+Email ids separated by commas.,E-mail ids odvojene zarezima.
+"Email settings to extract Leads from sales email id e.g. ""sales@example.com""",E-mail postavke za izdvajanje vodi od prodaje email id npr. &quot;sales@example.com&quot;
+Emergency Contact,Hitni kontakt
+Emergency Contact Details,Hitna Kontaktni podaci
+Emergency Phone,Hitna Telefon
+Employee,Zaposlenik
+Employee Birthday,Zaposlenik Rođendan
+Employee Details,Zaposlenih Detalji
+Employee Education,Zaposlenik Obrazovanje
+Employee External Work History,Zaposlenik Vanjski Rad Povijest
+Employee Information,Zaposlenik informacije
+Employee Internal Work History,Zaposlenik Unutarnji Rad Povijest
+Employee Internal Work Historys,Zaposlenih unutarnji rad Historys
+Employee Leave Approver,Zaposlenik dopust Odobritelj
+Employee Leave Balance,Zaposlenik napuste balans
+Employee Name,Zaposlenik Ime
+Employee Number,Zaposlenik Broj
+Employee Records to be created by,Zaposlenik Records bi se stvorili
+Employee Settings,Postavke zaposlenih
+Employee Type,Zaposlenik Tip
+"Employee designation (e.g. CEO, Director etc.).","Oznaka zaposlenika ( npr. CEO , direktor i sl. ) ."
+Employee master.,Majstor zaposlenika .
+Employee record is created using selected field. ,Zaposlenika rekord je stvorio pomoću odabranog polja.
+Employee records.,Zaposlenih evidencija.
+Employee relieved on {0} must be set as 'Left',Zaposlenik razriješen na {0} mora biti postavljen kao 'lijevo '
+Employee {0} has already applied for {1} between {2} and {3},Zaposlenik {0} već podnijela zahtjev za {1} od {2} i {3}
+Employee {0} is not active or does not exist,Zaposlenik {0} nije aktivan ili ne postoji
+Employee {0} was on leave on {1}. Cannot mark attendance.,Zaposlenik {0} je bio na odmoru na {1} . Ne možete označiti dolazak .
+Employees Email Id,Zaposlenici Email ID
+Employment Details,Zapošljavanje Detalji
+Employment Type,Zapošljavanje Tip
+Enable / disable currencies.,Omogućiti / onemogućiti valute .
+Enabled,Omogućeno
+Encashment Date,Encashment Datum
+End Date,Datum završetka
+End Date can not be less than Start Date,Datum završetka ne može biti manja od početnog datuma
+End date of current invoice's period,Kraj datum tekućeg razdoblja dostavnice
+End of Life,Kraj života
+Energy,energija
+Engineer,inženjer
+Enter Verification Code,Unesite kod za provjeru
+Enter campaign name if the source of lead is campaign.,Unesite naziv kampanje ukoliko izvor olova je kampanja.
+Enter department to which this Contact belongs,Unesite odjel na koji se ovaj Kontakt pripada
+Enter designation of this Contact,Upišite oznaku ove Kontakt
+"Enter email id separated by commas, invoice will be mailed automatically on particular date","Unesite e-mail ID odvojena zarezima, račun će automatski biti poslan na određeni datum"
+Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,Unesite stavke i planirani Količina za koje želite povećati proizvodne naloge ili preuzimanje sirovine za analizu.
+Enter name of campaign if source of enquiry is campaign,"Unesite naziv kampanje, ako je izvor upit je kampanja"
+"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)","Unesite statičke parametre URL ovdje (npr. pošiljatelj = ERPNext, username = ERPNext, lozinkom = 1234 itd.)"
+Enter the company name under which Account Head will be created for this Supplier,Unesite naziv tvrtke pod kojima računa Voditelj će biti stvoren za tu dobavljača
+Enter url parameter for message,Unesite URL parametar za poruke
+Enter url parameter for receiver nos,Unesite URL parametar za prijemnike br
+Entertainment & Leisure,Zabava i slobodno vrijeme
+Entertainment Expenses,Zabava Troškovi
+Entries,Prijave
+Entries against ,Entries against 
+Entries are not allowed against this Fiscal Year if the year is closed.,"Prijave nisu dozvoljeni protiv ove fiskalne godine, ako se godina zatvoren."
+Equity,pravičnost
+Error: {0} > {1},Pogreška : {0} > {1}
+Estimated Material Cost,Procjena troškova materijala
+"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Čak i ako postoji više Cijene pravila s najvišim prioritetom, onda sljedeći interni prioriteti primjenjuje se:"
+Everyone can read,Svatko može pročitati
+"Example: ABCD.#####If series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.",". Primjer: ABCD # # # # #  Ako serija je postavljena i Serial No ne spominje u transakcijama, a zatim automatski serijski broj će biti izrađen na temelju ove serije. Ako ste oduvijek željeli izrijekom spomenuti Serial brojeva za tu stavku. ostavite praznim."
+Exchange Rate,Tečaj
+Excise Duty 10,Trošarina 10
+Excise Duty 14,Trošarina 14
+Excise Duty 4,Trošarina 4
+Excise Duty 8,Trošarina 8
+Excise Duty @ 10,Trošarina @ 10.
+Excise Duty @ 14,Trošarina @ 14
+Excise Duty @ 4,Trošarina @ 4
+Excise Duty @ 8,Trošarina @ 8.
+Excise Duty Edu Cess 2,Trošarina Edu Posebni porez 2
+Excise Duty SHE Cess 1,Trošarina ONA Posebni porez na 1
+Excise Page Number,Trošarina Broj stranice
+Excise Voucher,Trošarina bon
+Execution,izvršenje
+Executive Search,Executive Search
+Exemption Limit,Izuzeće granica
+Exhibition,Izložba
+Existing Customer,Postojeći Kupac
+Exit,Izlaz
+Exit Interview Details,Izlaz Intervju Detalji
+Expected,Očekivana
+Expected Completion Date can not be less than Project Start Date,Očekivani datum dovršetka ne može biti manja od projekta Početni datum
+Expected Date cannot be before Material Request Date,Očekivani datum ne može biti prije Materijal Zahtjev Datum
+Expected Delivery Date,Očekivani rok isporuke
+Expected Delivery Date cannot be before Purchase Order Date,Očekuje se dostava Datum ne može biti prije narudžbenice Datum
+Expected Delivery Date cannot be before Sales Order Date,Očekuje se dostava Datum ne može biti prije prodajnog naloga Datum
+Expected End Date,Očekivani Datum završetka
+Expected Start Date,Očekivani datum početka
+Expense,rashod
+Expense / Difference account ({0}) must be a 'Profit or Loss' account,Rashodi / Razlika računa ({0}) mora biti račun 'dobit ili gubitak'
+Expense Account,Rashodi račun
+Expense Account is mandatory,Rashodi račun je obvezna
+Expense Claim,Rashodi polaganja
+Expense Claim Approved,Rashodi Zahtjev odobren
+Expense Claim Approved Message,Rashodi Zahtjev Odobren poruku
+Expense Claim Detail,Rashodi Zahtjev Detalj
+Expense Claim Details,Rashodi Pojedinosti o polaganju
+Expense Claim Rejected,Rashodi Zahtjev odbijen
+Expense Claim Rejected Message,Rashodi Zahtjev odbijen poruku
+Expense Claim Type,Rashodi Vrsta polaganja
+Expense Claim has been approved.,Rashodi Zahtjev je odobren .
+Expense Claim has been rejected.,Rashodi Zahtjev je odbijen .
+Expense Claim is pending approval. Only the Expense Approver can update status.,Rashodi Tužba se čeka odobrenje . SamoRashodi Odobritelj može ažurirati status .
+Expense Date,Rashodi Datum
+Expense Details,Rashodi Detalji
+Expense Head,Rashodi voditelj
+Expense account is mandatory for item {0},Rashodi račun je obvezna za predmet {0}
+Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Rashodi ili razlika račun je obvezna za točke {0} jer utječe na ukupnu vrijednost dionica
+Expenses,troškovi
+Expenses Booked,Rashodi Rezervirani
+Expenses Included In Valuation,Troškovi uključeni u vrednovanje
+Expenses booked for the digest period,Troškovi rezerviranih za razdoblje digest
+Expiry Date,Datum isteka
+Exports,Izvoz
+External,Vanjski
+Extract Emails,Ekstrakt e-pošte
+FCFS Rate,FCFS Stopa
+Failed: ,Nije uspjelo:
+Family Background,Obitelj Pozadina
+Fax,Fax
+Features Setup,Značajke konfiguracija
+Feed,Hraniti
+Feed Type,Pasi Vid
+Feedback,Povratna veza
+Female,Ženski
+Fetch exploded BOM (including sub-assemblies),Fetch eksplodirala BOM (uključujući i podsklopova )
+"Field available in Delivery Note, Quotation, Sales Invoice, Sales Order","Polje dostupan u otpremnicu, ponudu, prodaje fakture, prodaja reda"
+Files Folder ID,Files ID
+Fill the form and save it,Ispunite obrazac i spremite ga
+Filter based on customer,Filter temelji se na kupca
+Filter based on item,Filtrirati na temelju točki
+Financial / accounting year.,Financijska / obračunska godina .
+Financial Analytics,Financijski Analytics
+Financial Services,financijske usluge
+Financial Year End Date,Financijska godina End Date
+Financial Year Start Date,Financijska godina Start Date
+Finished Goods,gotovih proizvoda
+First Name,Ime
+First Responded On,Prvo Odgovorili Na
+Fiscal Year,Fiskalna godina
+Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Fiskalna godina Datum početka i datum završetka fiskalne godine već su postavljeni u fiskalnoj godini {0}
+Fiscal Year Start Date and Fiscal Year End Date cannot be more than a year apart.,Fiskalna godina Datum početka i datum završetka fiskalne godine ne može biti više od godine dana.
+Fiscal Year Start Date should not be greater than Fiscal Year End Date,Fiskalna godina Start Date ne bi trebao biti veći od Fiskalna godina End Date
+Fixed Asset,Dugotrajne imovine
+Fixed Assets,Dugotrajna imovina
+Follow via Email,Slijedite putem e-maila
+"Following table will show values if items are sub - contracted. These values will be fetched from the master of ""Bill of Materials"" of sub - contracted items.",Nakon stol će pokazati vrijednosti ako su stavke pod - ugovoreno. Ove vrijednosti će biti preuzeta od zapovjednika &quot;Bill of Materials&quot; pod - ugovoreni stavke.
+Food,hrana
+"Food, Beverage & Tobacco","Hrana , piće i duhan"
+"For 'Sales BOM' 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 'Sales BOM' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Za 'Prodaja BOM ""predmeta, skladište, rednim brojem i hrpa Ne smatrat će se iz' Popis pakiranja 'stolom. Ako Warehouse i šarže su isti za sve pakiranje predmeta za bilo 'Prodaja' sastavnice točke, te vrijednosti mogu se unijeti u glavni predmet stola, vrijednosti će se kopirati 'pakiranje popis' stolom."
+For Company,Za tvrtke
+For Employee,Za zaposlenom
+For Employee Name,Za ime zaposlenika
+For Price List,Za Cjeniku
+For Production,Za proizvodnju
+For Reference Only.,Samo za referencu.
+For Sales Invoice,Za prodaju fakture
+For Server Side Print Formats,Za Server formati stranom za ispis
+For Supplier,za Supplier
+For Warehouse,Za galeriju
+For Warehouse is required before Submit,Jer je potrebno Warehouse prije Podnijeti
+"For e.g. 2012, 2012-13","Za npr. 2012, 2012-13"
+For reference,Za referencu
+For reference only.,Za samo kao referenca.
+"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Za praktičnost kupaca, te kodovi mogu se koristiti u tiskanim formata kao što su fakture i otpremnice"
+Fraction,Frakcija
+Fraction Units,Frakcije Jedinice
+Freeze Stock Entries,Zamrzavanje Stock Unosi
+Freeze Stocks Older Than [Days],Freeze Dionice stariji od [ dana ]
+Freight and Forwarding Charges,Teretni i Forwarding Optužbe
+Friday,Petak
+From,Od
+From Bill of Materials,Od Bill of Materials
+From Company,Iz Društva
+From Currency,Od novca
+From Currency and To Currency cannot be same,Od valute i valuta ne mogu biti isti
+From Customer,Od kupca
+From Customer Issue,Od kupca Issue
+From Date,Od datuma
+From Date cannot be greater than To Date,Od datuma ne može biti veća od To Date
+From Date must be before To Date,Od datuma mora biti prije do danas
+From Date should be within the Fiscal Year. Assuming From Date = {0},Od datuma trebao biti u fiskalnoj godini. Uz pretpostavku Od datuma = {0}
+From Delivery Note,Od otpremnici
+From Employee,Od zaposlenika
+From Lead,Od Olovo
+From Maintenance Schedule,Od održavanje rasporeda
+From Material Request,Od materijala zahtjev
+From Opportunity,od Opportunity
+From Package No.,Iz paketa broj
+From Purchase Order,Od narudžbenice
+From Purchase Receipt,Od Račun kupnje
+From Quotation,od kotaciju
+From Sales Order,Od prodajnog naloga
+From Supplier Quotation,Od dobavljača kotaciju
+From Time,S vremena
+From Value,Od Vrijednost
+From and To dates required,Od i Do datuma zahtijevanih
+From value must be less than to value in row {0},Od vrijednosti mora biti manje nego vrijednosti u redu {0}
+Frozen,Zaleđeni
+Frozen Accounts Modifier,Blokiran Računi Modifikacijska
+Fulfilled,Ispunjena
+Full Name,Ime i prezime
+Full-time,Puno radno vrijeme
+Fully Billed,Potpuno Naplaćeno
+Fully Completed,Potpuno Završeni
+Fully Delivered,Potpuno Isporučeno
+Furniture and Fixture,Namještaj i susret
+Further accounts can be made under Groups but entries can be made against Ledger,"Daljnje računi mogu biti u skupinama , ali unose možete izvoditi protiv Ledgera"
+"Further accounts can be made under Groups, but entries can be made against Ledger","Daljnje računi mogu biti u skupinama , ali unose možete izvoditi protiv Ledgera"
+Further nodes can be only created under 'Group' type nodes,"Daljnje čvorovi mogu se samo stvorio pod ""Grupa"" tipa čvorova"
+GL Entry,GL Stupanje
+Gantt Chart,Gantogram
+Gantt chart of all tasks.,Gantogram svih zadataka.
+Gender,Rod
+General,Opći
+General Ledger,Glavna knjiga
+Generate Description HTML,Generiranje Opis HTML
+Generate Material Requests (MRP) and Production Orders.,Generirajte Materijal Upiti (MRP) i radne naloge.
+Generate Salary Slips,Generiranje plaće gaćice
+Generate Schedule,Generiranje Raspored
+Generates HTML to include selected image in the description,Stvara HTML uključuju odabrane slike u opisu
+Get Advances Paid,Nabavite plaćenim avansima
+Get Advances Received,Get Napredak pozicija
+Get Current Stock,Nabavite trenutne zalihe
+Get Items,Nabavite artikle
+Get Items From Sales Orders,Get artikle iz narudžbe
+Get Items from BOM,Se predmeti s troškovnikom
+Get Last Purchase Rate,Nabavite Zadnji Ocijeni Kupnja
+Get Outstanding Invoices,Nabavite neplaćene račune
+Get Relevant Entries,Dobiti relevantne objave
+Get Sales Orders,Nabavite narudžbe
+Get Specification Details,Nabavite Specifikacija Detalji
+Get Stock and Rate,Nabavite Stock i stopa
+Get Template,Nabavite predloška
+Get Terms and Conditions,Nabavite Uvjeti i pravila
+Get Unreconciled Entries,Nabavite nesaglašen objave
+Get Weekly Off Dates,Nabavite Tjedno Off datumi
+"Get valuation rate and available stock at source/target warehouse on mentioned posting date-time. If serialized item, please press this button after entering serial nos.","Nabavite stopa za vrednovanje i dostupni zaliha na izvor / cilj skladištu na spomenuti datum knjiženja radno vrijeme. Ako serijaliziranom stavku, molimo pritisnite ovu tipku nakon ulaska serijskih brojeva."
+Global Defaults,Globalni Zadano
+Global POS Setting {0} already created for company {1},Global POS Setting {0} već stvorene za tvrtke {1}
+Global Settings,globalne postavke
+"Go to the appropriate group (usually Application of Funds > Current Assets > Bank Accounts and create a new Account Ledger (by clicking on Add Child) of type ""Bank""","Idi na odgovarajuće skupine (obično Application fondova > tekuće imovine > bankovnim računima i stvoriti Ledger novog računa (klikom na Dodaj dijete) tipa : ""Banka"""
+"Go to the appropriate group (usually Source of Funds > Current Liabilities > Taxes and Duties and create a new Account Ledger (by clicking on Add Child) of type ""Tax"" and do mention the Tax rate.","Idi na odgovarajuće skupine (obično izvor sredstava > kratkoročne obveze > poreza i carina i stvoriti novi račun Ledger ( klikom na Dodaj dijete ) tipa "" porez"" i ne spominju se porezna stopa ."
+Goal,Cilj
+Goals,Golovi
+Goods received from Suppliers.,Roba dobio od dobavljače.
+Google Drive,Google Drive
+Google Drive Access Allowed,Google Drive Pristup dopuštenih
+Government,vlada
+Graduate,Diplomski
+Grand Total,Ukupno za platiti
+Grand Total (Company Currency),Sveukupno (valuta tvrtke)
+"Grid ""","Grid """
+Grocery,Trgovina
+Gross Margin %,Bruto marža %
+Gross Margin Value,Bruto marža vrijednost
+Gross Pay,Bruto plaće
+Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,Bruto plaće + + zaostatak Iznos Iznos Encashment - Ukupno Odbitak
+Gross Profit,Ukupan profit
+Gross Profit (%),Bruto dobit (%)
+Gross Weight,Bruto težina
+Gross Weight UOM,Bruto težina UOM
+Group,Grupa
+Group by Account,Grupa po računu
+Group by Voucher,Grupa po vaučer
+Group or Ledger,Grupa ili knjiga
+Groups,Grupe
+HR Manager,HR Manager
+HR Settings,HR Postavke
+HTML / Banner that will show on the top of product list.,HTML / bannera koji će se prikazivati ​​na vrhu liste proizvoda.
+Half Day,Pola dana
+Half Yearly,Pola Godišnji
+Half-yearly,Polugodišnje
+Happy Birthday!,Sretan rođendan !
+Hardware,hardver
+Has Batch No,Je Hrpa Ne
+Has Child Node,Je li čvor dijete
+Has Serial No,Ima Serial Ne
+Head of Marketing and Sales,Voditelj marketinga i prodaje
+Header,Kombajn
+Health Care,Health Care
+Health Concerns,Zdravlje Zabrinutost
+Health Details,Zdravlje Detalji
+Held On,Održanoj
+Help HTML,Pomoć HTML
+"Help: To link to another record in the system, use ""#Form/Note/[Note Name]"" as the Link URL. (don't use ""http://"")","Pomoć: Za povezivanje na drugi zapis u sustavu, koristite &quot;# Forma / Napomena / [Napomena ime]&quot; kao URL veze. (Ne koristite &quot;http://&quot;)"
+"Here you can maintain family details like name and occupation of parent, spouse and children","Ovdje možete održavati obiteljske pojedinosti kao što su ime i okupacije roditelja, supružnika i djecu"
+"Here you can maintain height, weight, allergies, medical concerns etc","Ovdje možete održavati visina, težina, alergije, medicinske brige itd."
+Hide Currency Symbol,Sakrij simbol valute
+High,Visok
+History In Company,Povijest U Društvu
+Hold,Držati
+Holiday,Odmor
+Holiday List,Turistička Popis
+Holiday List Name,Turistička Popis Ime
+Holiday master.,Majstor za odmor .
+Holidays,Praznici
+Home,Dom
+Host,Domaćin
+"Host, Email and Password required if emails are to be pulled","Domaćin, e-mail i lozinka potrebni ako e-mailove su se izvukao"
+Hour,sat
+Hour Rate,Sat Ocijenite
+Hour Rate Labour,Sat Ocijenite rada
+Hours,Sati
+How Pricing Rule is applied?,Kako se primjenjuje cijena pravilo?
+How frequently?,Kako često?
+"How should this currency be formatted? If not set, will use system defaults","Kako bi se to valuta biti formatiran? Ako nije postavljeno, koristit će zadane postavke sustava"
+Human Resources,Ljudski resursi
+Identification of the package for the delivery (for print),Identifikacija paketa za dostavu (za tisak)
+If Income or Expense,Ako prihoda i rashoda
+If Monthly Budget Exceeded,Ako Mjesečni proračun Exceeded
+"If Sale BOM is defined, the actual BOM of the Pack is displayed as table. Available in Delivery Note and Sales Order","Ako Prodaja BOM definiran ,stvarni troškovnik od Pack prikazuje se kao stol . Dostupan u Dostavnica i prodajni nalog"
+"If Supplier Part Number exists for given Item, it gets stored here","Ako Dobavljač Broj dijela postoji za određeni predmet, to dobiva pohranjen ovdje"
+If Yearly Budget Exceeded,Ako Godišnji proračun Exceeded
+"If checked, BOM for sub-assembly items will be considered for getting raw materials. Otherwise, all sub-assembly items will be treated as a raw material.","Ako je označeno, BOM za pod-zbor stavke će biti uzeti u obzir za dobivanje sirovine. Inače, sve pod-montaža stavke će biti tretirani kao sirovinu."
+"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Ako je označeno, Ukupan broj. radnih dana će uključiti odmor, a to će smanjiti vrijednost plaća po danu"
+"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Ako je označeno, iznos poreza će se smatrati već uključena u Print Rate / Ispis Iznos"
+If different than customer address,Ako se razlikuje od kupaca adresu
+"If disable, 'Rounded Total' field will not be visible in any transaction","Ako onemogućite, &#39;Ukupno&#39; Zaobljeni polje neće biti vidljiv u bilo kojoj transakciji"
+"If enabled, the system will post accounting entries for inventory automatically.","Ako je omogućeno, sustav će objaviti računovodstvene stavke za popis automatski."
+If more than one package of the same type (for print),Ako je više od jedan paket od iste vrste (za tisak)
+"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Ako više Cijene pravila i dalje prevladavaju, korisnici su zamoljeni da postavite prioritet ručno riješiti sukob."
+"If no change in either Quantity or Valuation Rate, leave the cell blank.","Ako nema promjena u bilo Količina ili procjena stope , ostaviti prazno stanica ."
+If not applicable please enter: NA,Ako ne odnosi unesite: NA
+"If not checked, the list will have to be added to each Department where it has to be applied.","Ako nije označeno, popis će biti dodan u svakom odjela gdje se mora primjenjivati."
+"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, 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 odabrani Cijene Pravilo je za 'Cijena', to će prebrisati cjenik. Cijene Pravilo cijena je konačna cijena, tako da nema dalje popusta treba primijeniti. Dakle, u prometu kao što su prodajni nalog, narudžbenica itd, to će biti preuzeta u 'stopi' polju, a ne 'cjenik' stopi polju."
+"If specified, send the newsletter using this email address","Ako je navedeno, pošaljite newsletter koristeći ovu e-mail adresu"
+"If the account is frozen, entries are allowed to restricted users.","Ako je račun zamrznut , unosi dopušteno ograničene korisnike ."
+"If this Account represents a Customer, Supplier or Employee, set it here.","Ako se to računa predstavlja kupac, dobavljač ili zaposlenik, postavite ga ovdje."
+"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 su dva ili više Cijene Pravila naći na temelju gore navedenih uvjeta, prednost se primjenjuju. Prioritet je broj od 0 do 20, a zadana vrijednost je nula (prazno). Veći broj znači da će imati prednost ako postoji više Cijene pravila s istim uvjetima."
+If you follow Quality Inspection. Enables Item QA Required and QA No in Purchase Receipt,Ako slijedite kvalitete . Omogućuje predmet QA potrebno i QA Ne u Račun kupnje
+If you have Sales Team and Sale Partners (Channel Partners)  they can be tagged and maintain their contribution in the sales activity,Ako imate prodajnog tima i prodaja partnerima (partneri) mogu biti označene i održavati svoj doprinos u prodajne aktivnosti
+"If you have created a standard template in Purchase Taxes and Charges Master, select one and click on the button below.","Ako ste stvorili standardni predložak za kupnju poreze i pristojbe magisterij, odaberite jednu i kliknite na gumb ispod."
+"If you have created a standard template in Sales Taxes and Charges Master, select one and click on the button below.","Ako ste stvorili standardni predložak u prodaji poreze i pristojbe magisterij, odaberite jednu i kliknite na gumb ispod."
+"If you have long print formats, this feature can be used to split the page to be printed on multiple pages with all headers and footers on each page","Ako ste dugo ispis formata, ova značajka može se koristiti za podijeliti stranicu na koju se ispisuje više stranica sa svim zaglavljima i podnožjima na svakoj stranici"
+If you involve in manufacturing activity. Enables Item 'Is Manufactured',Ako uključiti u proizvodnom djelatnošću . Omogućuje stavci je proizveden '
+Ignore,Ignorirati
+Ignore Pricing Rule,Ignorirajte Cijene pravilo
+Ignored: ,Zanemareni:
+Image,Slika
+Image View,Slika Pogledaj
+Implementation Partner,Provedba partner
+Import Attendance,Uvoz posjećenost
+Import Failed!,Uvoz nije uspio !
+Import Log,Uvoz Prijavite
+Import Successful!,Uvoz uspješna!
+Imports,Uvoz
+In Hours,U sati
+In Process,U procesu
+In Qty,u kol
+In Value,u vrijednosti
+In Words,Riječima
+In Words (Company Currency),Riječima (valuta tvrtke)
+In Words (Export) will be visible once you save the Delivery Note.,U riječi (izvoz) će biti vidljiv nakon što spremite otpremnici.
+In Words will be visible once you save the Delivery Note.,U riječi će biti vidljiv nakon što spremite otpremnici.
+In Words will be visible once you save the Purchase Invoice.,U riječi će biti vidljiv nakon što spremite ulazne fakture.
+In Words will be visible once you save the Purchase Order.,U riječi će biti vidljiv nakon što spremite narudžbenice.
+In Words will be visible once you save the Purchase Receipt.,U riječi će biti vidljiv nakon što spremite kupiti primitka.
+In Words will be visible once you save the Quotation.,U riječi će biti vidljiv nakon što spremite ponudu.
+In Words will be visible once you save the Sales Invoice.,U riječi će biti vidljiv nakon što spremite prodaje fakture.
+In Words will be visible once you save the Sales Order.,U riječi će biti vidljiv nakon što spremite prodajnog naloga.
+Incentives,Poticaji
+Include Reconciled Entries,Uključi pomirio objave
+Include holidays in Total no. of Working Days,Uključi odmor u ukupnom. radnih dana
+Income,prihod
+Income / Expense,Prihodi / rashodi
+Income Account,Prihodi račun
+Income Booked,Prihodi Rezervirani
+Income Tax,porezu na dohodak
+Income Year to Date,Prihodi godine do danas
+Income booked for the digest period,Prihodi rezervirano za razdoblje digest
+Incoming,Dolazni
+Incoming Rate,Dolazni Stopa
+Incoming quality inspection.,Dolazni kvalitete inspekcije.
+Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Neispravan broj glavnu knjigu unose naći. Možda ste odabrali krivi račun u transakciji.
+Incorrect or Inactive BOM {0} for Item {1} at row {2},Pogrešne ili Neaktivno BOM {0} za točku {1} po redu {2}
+Indicates that the package is a part of this delivery (Only Draft),Ukazuje da je paket je dio ove isporuke (samo nacrti)
+Indirect Expenses,neizravni troškovi
+Indirect Income,Neizravno dohodak
+Individual,Pojedinac
+Industry,Industrija
+Industry Type,Industrija Tip
+Inspected By,Pregledati
+Inspection Criteria,Inspekcijski Kriteriji
+Inspection Required,Inspekcija Obvezno
+Inspection Type,Inspekcija Tip
+Installation Date,Instalacija Datum
+Installation Note,Instalacija Napomena
+Installation Note Item,Instalacija Napomena artikla
+Installation Note {0} has already been submitted,Instalacija Napomena {0} već je poslan
+Installation Status,Instalacija Status
+Installation Time,Instalacija Vrijeme
+Installation date cannot be before delivery date for Item {0},Datum Instalacija ne može biti prije datuma isporuke za točke {0}
+Installation record for a Serial No.,Instalacija rekord za serijski broj
+Installed Qty,Instalirani Kol
+Instructions,Instrukcije
+Integrate incoming support emails to Support Ticket,Integracija dolazne e-mailove podrške za podršku ulaznica
+Interested,Zainteresiran
+Intern,stažista
+Internal,Interni
+Internet Publishing,Internet Izdavaštvo
+Introduction,Uvod
+Invalid Barcode,Invalid Barcode
+Invalid Barcode or Serial No,Invalid Barcode ili Serial Ne
+Invalid Mail Server. Please rectify and try again.,Invalid Server Mail . Molimo ispraviti i pokušajte ponovno .
+Invalid Master Name,Invalid Master Ime
+Invalid User Name or Support Password. Please rectify and try again.,Neispravno korisničko ime ili podrška Lozinka . Molimo ispraviti i pokušajte ponovno .
+Invalid quantity specified for item {0}. Quantity should be greater than 0.,Pogrešna količina navedeno za predmet {0} . Količina treba biti veći od 0 .
+Inventory,Inventar
+Inventory & Support,Inventar i podrška
+Investment Banking,Investicijsko bankarstvo
+Investments,investicije
+Invoice Date,Račun Datum
+Invoice Details,Pojedinosti dostavnice
+Invoice No,Račun br
+Invoice Number,Račun broj
+Invoice Period From,Račun razdoblju od
+Invoice Period From and Invoice Period To dates mandatory for recurring invoice,Račun razdoblju od računa i period za datume obveznih za ponavljajuće fakture
+Invoice Period To,Račun Razdoblje Da
+Invoice Type,Tip fakture
+Invoice/Journal Voucher Details,Račun / Časopis bon Detalji
+Invoiced Amount (Exculsive Tax),Dostavljeni iznos ( Exculsive poreza )
+Is Active,Je aktivna
+Is Advance,Je Predujam
+Is Cancelled,Je Otkazan
+Is Carry Forward,Je Carry Naprijed
+Is Default,Je Default
+Is Encash,Je li unovčiti
+Is Fixed Asset Item,Je fiksne imovine stavku
+Is LWP,Je lwp
+Is Opening,Je Otvaranje
+Is Opening Entry,Je Otvaranje unos
+Is POS,Je POS
+Is Primary Contact,Je Primarna Kontakt
+Is Purchase Item,Je Kupnja artikla
+Is Sales Item,Je Prodaja artikla
+Is Service Item,Je li usluga artikla
+Is Stock Item,Je kataloški artikla
+Is Sub Contracted Item,Je Sub Ugovoreno artikla
+Is Subcontracted,Je podugovarati
+Is this Tax included in Basic Rate?,Je li ovo pristojba uključena u osnovne stope?
+Issue,Izdanje
+Issue Date,Datum izdavanja
+Issue Details,Issue Detalji
+Issued Items Against Production Order,Izdana Proizvodi prema proizvodnji Reda
+It can also be used to create opening stock entries and to fix stock value.,Također se može koristiti za stvaranje početne vrijednosti unose i popraviti stock vrijednost .
+Item,Artikl
+Item Advanced,Stavka Napredna
+Item Barcode,Stavka Barkod
+Item Batch Nos,Stavka Batch Nos
+Item Code,Stavka Šifra
+Item Code > Item Group > Brand,Kod Stavka> Stavka Group> Brand
+Item Code and Warehouse should already exist.,Šifra i skladišta trebao već postoje .
+Item Code cannot be changed for Serial No.,Kod stavka ne može se mijenjati za serijskog broja
+Item Code is mandatory because Item is not automatically numbered,Kod artikla je obvezno jer točka nije automatski numerirani
+Item Code required at Row No {0},Šifra potrebno na Row Zabranjeno {0}
+Item Customer Detail,Stavka Kupac Detalj
+Item Description,Stavka Opis
+Item Desription,Stavka Desription
+Item Details,Stavka Detalji
+Item Group,Stavka Grupa
+Item Group Name,Stavka Ime grupe
+Item Group Tree,Stavka Group Tree
+Item Group not mentioned in item master for item {0},Stavka Grupa ne spominje u točki majstora za predmet {0}
+Item Groups in Details,Stavka Grupe u detaljima
+Item Image (if not slideshow),Stavka slike (ako ne Slideshow)
+Item Name,Stavka Ime
+Item Naming By,Stavka nazivanje
+Item Price,Stavka Cijena
+Item Prices,Stavka Cijene
+Item Quality Inspection Parameter,Stavka Provera kvaliteta parametara
+Item Reorder,Stavka redoslijeda
+Item Serial No,Stavka rednim brojem
+Item Serial Nos,Stavka Serijski br
+Item Shortage Report,Stavka Nedostatak Izvješće
+Item Supplier,Stavka Dobavljač
+Item Supplier Details,Stavka Supplier Detalji
+Item Tax,Stavka poreza
+Item Tax Amount,Stavka Iznos poreza
+Item Tax Rate,Stavka Porezna stopa
+Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Stavka Porezna Row {0} mora imati račun tipa poreza ili prihoda i rashoda ili naplativ
+Item Tax1,Stavka Tax1
+Item To Manufacture,Stavka za proizvodnju
+Item UOM,Stavka UOM
+Item Website Specification,Stavka Web Specifikacija
+Item Website Specifications,Stavka Website Specifikacije
+Item Wise Tax Detail,Stavka Wise Porezna Detalj
+Item Wise Tax Detail ,Stavka Wise Porezna Detalj
+Item is required,Stavka je potrebno
+Item is updated,Stavka je obnovljeno
+Item master.,Majstor artikla .
+"Item must be a purchase item, as it is present in one or many Active BOMs","Stavka mora bitipredmet kupnje , kao što je to prisutno u jednom ili više aktivnih sastavnicama"
+Item or Warehouse for row {0} does not match Material Request,Stavka ili skladišta za redom {0} ne odgovara Material Zahtjev
+Item table can not be blank,Tablica predmet ne može biti prazan
+Item to be manufactured or repacked,Stavka biti proizvedeni ili prepakirani
+Item valuation updated,Vrednovanje Stavka izmijenjena
+Item will be saved by this name in the data base.,Stavka će biti spremljena pod ovim imenom u bazi podataka.
+Item {0} appears multiple times in Price List {1},Stavka {0} se pojavljuje više puta u Cjenika {1}
+Item {0} does not exist,Stavka {0} ne postoji
+Item {0} does not exist in the system or has expired,Stavka {0} ne postoji u sustavu ili je istekla
+Item {0} does not exist in {1} {2},Stavka {0} ne postoji u {1} {2}
+Item {0} has already been returned,Stavka {0} već je vraćeno
+Item {0} has been entered multiple times against same operation,Stavka {0} upisan je više puta protiv istog rada
+Item {0} has been entered multiple times with same description or date,Stavka {0} upisan je više puta s istim opisom ili datumu
+Item {0} has been entered multiple times with same description or date or warehouse,Stavka {0} upisan je više puta s istim opisom ili datum ili skladište
+Item {0} has been entered twice,Stavka {0} je ušao dva puta
+Item {0} has reached its end of life on {1},Stavka {0} je dosegla svoj kraj života na {1}
+Item {0} ignored since it is not a stock item,Stavka {0} ignorirala jer to nijepredmet dionica
+Item {0} is cancelled,Stavka {0} je otkazan
+Item {0} is not Purchase Item,Stavka {0} nije Kupnja predmeta
+Item {0} is not a serialized Item,Stavka {0} nijeserijaliziranom predmeta
+Item {0} is not a stock Item,Stavka {0} nijestock Stavka
+Item {0} is not active or end of life has been reached,Stavka {0} nije aktivan ili kraj života je postignut
+Item {0} is not setup for Serial Nos. Check Item master,"Stavka {0} nije dobro postavljen za gospodara , serijski brojevi Provjera"
+Item {0} is not setup for Serial Nos. Column must be blank,Stavka {0} nije setup za serijski brojevi Stupac mora biti prazan
+Item {0} must be Sales Item,Stavka {0} mora biti Prodaja artikla
+Item {0} must be Sales or Service Item in {1},Stavka {0} mora biti Prodaja ili usluga artikla u {1}
+Item {0} must be Service Item,Stavka {0} mora biti usluga Stavka
+Item {0} must be a Purchase Item,Stavka {0} mora bitikupnja artikla
+Item {0} must be a Sales Item,Stavka {0} mora bitiProdaja artikla
+Item {0} must be a Service Item.,Stavka {0} mora bitiusluga artikla .
+Item {0} must be a Sub-contracted Item,Stavka {0} mora bitisklopljen ugovor artikla
+Item {0} must be a stock Item,Stavka {0} mora bitistock Stavka
+Item {0} must be manufactured or sub-contracted,Stavka {0} mora biti proizvedeni ili pod-ugovori
+Item {0} not found,Stavka {0} nije pronađena
+Item {0} with Serial No {1} is already installed,Stavka {0} s rednim brojem {1} već instaliran
+Item {0} with same description entered twice,Stavka {0} sa istim opisom ušao dva puta
+"Item, Warranty, AMC (Annual Maintenance Contract) details will be automatically fetched when Serial Number is selected.","Stavka, jamstvo, AMC (Godišnje održavanje Ugovor) pojedinosti će biti automatski dohvatio kada serijski broj je odabran."
+Item-wise Price List Rate,Stavka - mudar Cjenovnik Ocijenite
+Item-wise Purchase History,Stavka-mudar Kupnja Povijest
+Item-wise Purchase Register,Stavka-mudar Kupnja Registracija
+Item-wise Sales History,Stavka-mudar Prodaja Povijest
+Item-wise Sales Register,Stavka-mudri prodaja registar
+"Item: {0} managed batch-wise, can not be reconciled using \					Stock Reconciliation, instead use Stock Entry","Stavka: {0} uspio turi, ne može se pomiriti korištenja \ Stock pomirenje, umjesto da koristite Stock stupanja"
+Item: {0} not found in the system,Stavka : {0} ne nalaze u sustavu
+Items,Proizvodi
+Items To Be Requested,Predmeti se zatražiti
+Items required,Stavke potrebne
+"Items to be requested which are ""Out of Stock"" considering all warehouses based on projected qty and minimum order qty",Proizvodi se traži što su &quot;Out of Stock&quot; s obzirom na sve skladišta na temelju projicirane Qty i minimalne narudžbe Kol
+Items which do not exist in Item master can also be entered on customer's request,Proizvodi koji ne postoje u artikla gospodara također može unijeti na zahtjev kupca
+Itemwise Discount,Itemwise Popust
+Itemwise Recommended Reorder Level,Itemwise Preporučio redoslijeda Level
+Job Applicant,Posao podnositelj
+Job Opening,Posao Otvaranje
+Job Profile,posao Profile
+Job Title,Titula
+"Job profile, qualifications required etc.","Profil posla , kvalifikacijama i sl."
+Jobs Email Settings,Poslovi Postavke e-pošte
+Journal Entries,Časopis upisi
+Journal Entry,Časopis Stupanje
+Journal Voucher,Časopis bon
+Journal Voucher Detail,Časopis bon Detalj
+Journal Voucher Detail No,Časopis bon Detalj Ne
+Journal Voucher {0} does not have account {1} or already matched,Časopis bon {0} nema račun {1} ili već usklađeni
+Journal Vouchers {0} are un-linked,Časopis bon {0} su UN -linked
+Keep a track of communication related to this enquiry which will help for future reference.,Držite pratiti komunikacije vezane uz ovaj upit koji će vam pomoći za buduću referencu.
+Keep it web friendly 900px (w) by 100px (h),Držite ga prijateljski web 900px ( w ) by 100px ( h )
+Key Performance Area,Key Performance Area
+Key Responsibility Area,Ključ Odgovornost Površina
+Kg,kg
+LR Date,LR Datum
+LR No,LR Ne
+Label,Oznaka
+Landed Cost Item,Sletio Troškovi artikla
+Landed Cost Items,Sletio troškova Proizvodi
+Landed Cost Purchase Receipt,Sletio Trošak Kupnja Potvrda
+Landed Cost Purchase Receipts,Sletio troškova kupnje Primici
+Landed Cost Wizard,Sletio Trošak Čarobnjak
+Landed Cost updated successfully,Sletio Troškovi uspješno ažurirana
+Language,Jezik
+Last Name,Prezime
+Last Purchase Rate,Zadnja Kupnja Ocijenite
+Latest,najnoviji
+Lead,Dovesti
+Lead Details,Olovo Detalji
+Lead Id,Olovo Id
+Lead Name,Olovo Ime
+Lead Owner,Olovo Vlasnik
+Lead Source,Olovo Source
+Lead Status,Olovo Status
+Lead Time Date,Olovo Time Date
+Lead Time Days,Olovo vrijeme Dane
+Lead Time days is number of days by which this item is expected in your warehouse. This days is fetched in Material Request when you select this item.,Olovo vrijeme dana je broj dana koji ovaj predmet se očekuje u skladištu. Ovih dana je preuzeta u Materijal Zahtjev kada odaberete ovu stavku.
+Lead Type,Olovo Vid
+Lead must be set if Opportunity is made from Lead,Olovo se mora postaviti ako prilika je izrađena od olova
+Leave Allocation,Ostavite Raspodjela
+Leave Allocation Tool,Ostavite raspodjele alat
+Leave Application,Ostavite aplikaciju
+Leave Approver,Ostavite odobravatelju
+Leave Approvers,Ostavite odobravateljima
+Leave Balance Before Application,Ostavite Balance Prije primjene
+Leave Block List,Ostavite Block List
+Leave Block List Allow,Ostavite Blok Popis Dopustite
+Leave Block List Allowed,Ostavite Block List dopuštenih
+Leave Block List Date,Ostavite Date Popis Block
+Leave Block List Dates,Ostavite datumi lista blokiranih
+Leave Block List Name,Ostavite popis imena Block
+Leave Blocked,Ostavite blokirani
+Leave Control Panel,Ostavite Upravljačka ploča
+Leave Encashed?,Ostavite Encashed?
+Leave Encashment Amount,Ostavite Encashment Iznos
+Leave Type,Ostavite Vid
+Leave Type Name,Ostavite ime tipa
+Leave Without Pay,Ostavite bez plaće
+Leave application has been approved.,Ostavite Zahtjev je odobren .
+Leave application has been rejected.,Ostavite Zahtjev je odbijen .
+Leave approver must be one of {0},Ostavite odobritelj mora biti jedan od {0}
+Leave blank if considered for all branches,Ostavite prazno ako smatra za sve grane
+Leave blank if considered for all departments,Ostavite prazno ako smatra za sve odjele
+Leave blank if considered for all designations,Ostavite prazno ako smatra za sve oznake
+Leave blank if considered for all employee types,Ostavite prazno ako smatra za sve tipove zaposlenika
+"Leave can be approved by users with Role, ""Leave Approver""","Ostavite može biti odobren od strane korisnika s uloge, &quot;Ostavite odobravatelju&quot;"
+Leave of type {0} cannot be longer than {1},Ostavite tipa {0} ne može biti duži od {1}
+Leaves Allocated Successfully for {0},Lišće Dodijeljeni uspješno za {0}
+Leaves for type {0} already allocated for Employee {1} for Fiscal Year {0},Ostavlja za vrstu {0} već dodijeljeno za zaposlenika {1} za fiskalnu godinu {0}
+Leaves must be allocated in multiples of 0.5,"Listovi moraju biti dodijeljeno u COMBI 0,5"
+Ledger,Glavna knjiga
+Ledgers,knjige
+Left,Lijevo
+Legal,pravni
+Legal Expenses,pravne Troškovi
+Letter Head,Pismo Head
+Letter Heads for print templates.,Pismo glave za ispis predložaka .
+Level,Nivo
+Lft,LFT
+Liability,odgovornost
+List a few of your customers. They could be organizations or individuals.,Naveditenekoliko svojih kupaca . Oni mogu biti organizacije ili pojedinci .
+List a few of your suppliers. They could be organizations or individuals.,Naveditenekoliko svojih dobavljača . Oni mogu biti organizacije ili pojedinci .
+List items that form the package.,Popis stavki koje čine paket.
+List this Item in multiple groups on the website.,Popis ovaj predmet u više grupa na web stranici.
+"List your products or services that you buy or sell. Make sure to check the Item Group, Unit of Measure and other properties when you start.",Popis svoje proizvode ili usluge koje kupuju ili prodaju .
+"List your tax heads (e.g. VAT, Excise; they should have unique names) and their standard rates. This will create a standard template, which you can edit and add more later.","Popis svoje porezne glave ( npr. PDV , trošarine , oni bi trebali imati jedinstvene nazive ) i njihove standardne stope ."
+Loading...,Loading ...
+Loans (Liabilities),Zajmovi ( pasiva)
+Loans and Advances (Assets),Zajmovi i predujmovi ( aktiva )
+Local,mjesni
+Login,prijava
+Login with your new User ID,Prijavite se s novim User ID
+Logo,Logo
+Logo and Letter Heads,Logo i pismo glave
+Lost,izgubljen
+Lost Reason,Izgubili Razlog
+Low,Nisko
+Lower Income,Donja Prihodi
+MTN Details,MTN Detalji
+Main,glavni
+Main Reports,Glavni Izvješća
+Maintain Same Rate Throughout Sales Cycle,Održavati ista stopa Tijekom cijele prodajni ciklus
+Maintain same rate throughout purchase cycle,Održavanje istu stopu tijekom kupnje ciklusa
+Maintenance,Održavanje
+Maintenance Date,Održavanje Datum
+Maintenance Details,Održavanje Detalji
+Maintenance Schedule,Održavanje Raspored
+Maintenance Schedule Detail,Održavanje Raspored Detalj
+Maintenance Schedule Item,Održavanje Raspored predmeta
+Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Raspored održavanja ne stvara za sve stavke . Molimo kliknite na ""Generiraj raspored '"
+Maintenance Schedule {0} exists against {0},Raspored održavanja {0} postoji od {0}
+Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Raspored održavanja {0} mora biti otkazana prije poništenja ovu prodajnog naloga
+Maintenance Schedules,Održavanje Raspored
+Maintenance Status,Održavanje statusa
+Maintenance Time,Održavanje Vrijeme
+Maintenance Type,Održavanje Tip
+Maintenance Visit,Održavanje Posjetite
+Maintenance Visit Purpose,Održavanje Posjetite Namjena
+Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Održavanje Posjetite {0} mora biti otkazana prije poništenja ovu prodajnog naloga
+Maintenance start date can not be before delivery date for Serial No {0},Održavanje datum početka ne može biti prije datuma isporuke za rednim brojem {0}
+Major/Optional Subjects,Glavni / Izborni predmeti
+Make ,Make 
+Make Accounting Entry For Every Stock Movement,Provjerite knjiženje za svaki burzi pokreta
+Make Bank Voucher,Napravite Bank bon
+Make Credit Note,Provjerite Credit Note
+Make Debit Note,Provjerite terećenju
+Make Delivery,bi isporuka
+Make Difference Entry,Čine razliku Entry
+Make Excise Invoice,Provjerite trošarinske fakturu
+Make Installation Note,Provjerite Installation napomenu
+Make Invoice,Napravite fakturu
+Make Maint. Schedule,Napravite Maint . raspored
+Make Maint. Visit,Napravite Maint . posjet
+Make Maintenance Visit,Provjerite održavanja Posjetite
+Make Packing Slip,Napravite popis zapakiranih
+Make Payment,Uplati
+Make Payment Entry,Napravite unos Plaćanje
+Make Purchase Invoice,Napravite kupnje proizvoda
+Make Purchase Order,Provjerite narudžbenice
+Make Purchase Receipt,Napravite Račun kupnje
+Make Salary Slip,Provjerite plaće slip
+Make Salary Structure,Provjerite Plaća Struktura
+Make Sales Invoice,Ostvariti prodaju fakturu
+Make Sales Order,Provjerite prodajnog naloga
+Make Supplier Quotation,Provjerite Supplier kotaciji
+Make Time Log Batch,Nađite vremena Prijavite Hrpa
+Male,Muški
+Manage Customer Group Tree.,Upravljanje grupi kupaca stablo .
+Manage Sales Partners.,Upravljanje prodajnih partnera.
+Manage Sales Person Tree.,Upravljanje prodavač stablo .
+Manage Territory Tree.,Upravljanje teritorij stablo .
+Manage cost of operations,Upravljanje troškove poslovanja
+Management,upravljanje
+Manager,menadžer
+"Mandatory if Stock Item is ""Yes"". Also the default warehouse where reserved quantity is set from Sales Order.",Obvezni ako Stock Stavka je &quot;Da&quot;. Također zadano skladište gdje je zadržana količina se postaviti od prodajnog naloga.
+Manufacture against Sales Order,Proizvodnja protiv prodaje Reda
+Manufacture/Repack,Proizvodnja / Ponovno pakiranje
+Manufactured Qty,Proizvedeno Kol
+Manufactured quantity will be updated in this warehouse,Proizvedeno količina će biti ažurirana u ovom skladištu
+Manufactured quantity {0} cannot be greater than planned quanitity {1} in Production Order {2},Proizvedeno Količina {0} ne može biti veći od planiranog quanitity {1} u proizvodnom nalogu {2}
+Manufacturer,Proizvođač
+Manufacturer Part Number,Proizvođač Broj dijela
+Manufacturing,Proizvodnja
+Manufacturing Quantity,Proizvodnja Količina
+Manufacturing Quantity is mandatory,Proizvodnja Količina je obvezno
+Margin,Marža
+Marital Status,Bračni status
+Market Segment,Tržišni segment
+Marketing,marketing
+Marketing Expenses,Troškovi marketinga
+Married,Oženjen
+Mass Mailing,Misa mailing
+Master Name,Učitelj Ime
+Master Name is mandatory if account type is Warehouse,Master Ime je obavezno ako je vrsta račun Skladište
+Master Type,Majstor Tip
+Masters,Majstori
+Match non-linked Invoices and Payments.,Klađenje na ne-povezane faktura i plaćanja.
+Material Issue,Materijal Issue
+Material Receipt,Materijal Potvrda
+Material Request,Materijal zahtjev
+Material Request Detail No,Materijal Zahtjev Detalj Ne
+Material Request For Warehouse,Materijal Zahtjev za galeriju
+Material Request Item,Materijal Zahtjev artikla
+Material Request Items,Materijalni Zahtjev Proizvodi
+Material Request No,Materijal Zahtjev Ne
+Material Request Type,Materijal Zahtjev Tip
+Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Materijal Zahtjev maksimalno {0} može biti za točku {1} od prodajnog naloga {2}
+Material Request used to make this Stock Entry,Materijal Zahtjev se koristi da bi se ova Stock unos
+Material Request {0} is cancelled or stopped,Materijal Zahtjev {0} je otkazan ili zaustavljen
+Material Requests for which Supplier Quotations are not created,Materijalni Zahtjevi za koje Supplier Citati nisu stvorene
+Material Requests {0} created,Materijalni Zahtjevi {0} stvorio
+Material Requirement,Materijal Zahtjev
+Material Transfer,Materijal transfera
+Materials,Materijali
+Materials Required (Exploded),Materijali Obavezno (eksplodirala)
+Max 5 characters,Max 5 znakova
+Max Days Leave Allowed,Max Dani Ostavite dopuštenih
+Max Discount (%),Maks Popust (%)
+Max Qty,Max Kol
+Max discount allowed for item: {0} is {1}%,Maksimalni popust dopušteno za predmet: {0} je {1}%
+Maximum Amount,Maksimalni iznos
+Maximum allowed credit is {0} days after posting date,Najveća dopuštena kredit je {0} dana nakon objavljivanja datuma
+Maximum {0} rows allowed,Maksimalne {0} redovi dopušteno
+Maxiumm discount for Item {0} is {1}%,Maxiumm popusta za točke {0} je {1} %
+Medical,liječnički
+Medium,Srednji
+"Merging is only possible if following properties are same in both records. Group or Ledger, Root Type, Company",Spajanje je moguće samo ako sljedeća svojstva su jednaka u obje evidencije .
+Message,Poruka
+Message Parameter,Poruka parametra
+Message Sent,Poruka je poslana
+Message updated,Poruka izmijenjena
+Messages,Poruke
+Messages greater than 160 characters will be split into multiple messages,Poruka veća od 160 karaktera će biti split u više mesage
+Middle Income,Srednji Prihodi
+Milestone,Prekretnica
+Milestone Date,Prekretnica Datum
+Milestones,Dostignuća
+Milestones will be added as Events in the Calendar,Dostignuća će biti dodan kao Događanja u kalendaru
+Min Order Qty,Min Red Kol
+Min Qty,min Kol
+Min Qty can not be greater than Max Qty,Min Kol ne može biti veći od Max Kol
+Minimum Amount,Minimalni iznos
+Minimum Order Qty,Minimalna narudžba Količina
+Minute,minuta
+Misc Details,Razni podaci
+Miscellaneous Expenses,Razni troškovi
+Miscelleneous,Miscelleneous
+Mobile No,Mobitel Nema
+Mobile No.,Mobitel broj
+Mode of Payment,Način plaćanja
+Modern,Moderna
+Monday,Ponedjeljak
+Month,Mjesec
+Monthly,Mjesečno
+Monthly Attendance Sheet,Mjesečna posjećenost list
+Monthly Earning & Deduction,Mjesečna zarada &amp; Odbitak
+Monthly Salary Register,Mjesečna plaća Registracija
+Monthly salary statement.,Mjesečna plaća izjava.
+More Details,Više pojedinosti
+More Info,Više informacija
+Motion Picture & Video,Motion Picture & Video
+Moving Average,Moving Average
+Moving Average Rate,Premještanje prosječna stopa
+Mr,G.
+Ms,Gospođa
+Multiple Item prices.,Više cijene stavke.
+"Multiple Price Rule exists with same criteria, please resolve \			conflict by assigning priority. Price Rules: {0}","Višestruki Cijena Pravilo postoji sa istim kriterijima, molimo riješiti \ Sukob dodjeljivanjem prioritet. Cijena pravila: {0}"
+Music,glazba
+Must be Whole Number,Mora biti cijeli broj
+Name,Ime
+Name and Description,Ime i opis
+Name and Employee ID,Ime i ID zaposlenika
+"Name of new Account. Note: Please don't create accounts for Customers and Suppliers, they are created automatically from the Customer and Supplier master","Ime novog računa. Napomena: Molimo Vas da ne stvarate račune za kupce i dobavljače, oni se automatski stvaraju od postojećih klijenata i dobavljača"
+Name of person or organization that this address belongs to.,Ime osobe ili organizacije kojoj ova adresa pripada.
+Name of the Budget Distribution,Ime distribucije proračuna
+Naming Series,Imenovanje serije
+Negative Quantity is not allowed,Negativna količina nije dopuštena
+Negative Stock Error ({6}) for Item {0} in Warehouse {1} on {2} {3} in {4} {5},Negativna Stock Error ( {6} ) za točke {0} u skladište {1} na {2} {3} u {4} {5}
+Negative Valuation Rate is not allowed,Negativna stopa vrijednovanja nije dopuštena
+Negative balance in Batch {0} for Item {1} at Warehouse {2} on {3} {4},Negativna bilanca u batch {0} za artikl {1} na skladište {2} na {3} {4}
+Net Pay,Neto plaća
+Net Pay (in words) will be visible once you save the Salary Slip.,Neto plaća (riječima) će biti vidljiva nakon što spremite klizne plaće.
+Net Profit / Loss,Neto dobit / gubitak
+Net Total,Osnovica
+Net Total (Company Currency),Neto Ukupno (Društvo valuta)
+Net Weight,Neto težina
+Net Weight UOM,Težina mjerna jedinica
+Net Weight of each Item,Težina svakog artikla
+Net pay cannot be negative,Neto plaća ne može biti negativna
+Never,Nikad
+New ,Novi
+New Account,Novi račun
+New Account Name,Naziv novog računa
+New BOM,Novi BOM
+New Communications,Novi komunikacije
+New Company,Nova tvrtka
+New Cost Center,Novi trošak
+New Cost Center Name,Novi troška Naziv
+New Delivery Notes,Nove otpremnice
+New Enquiries,Novi upiti
+New Leads,Novi potencijalni kupci
+New Leave Application,Novi dopust Primjena
+New Leaves Allocated,Novi Leaves Dodijeljeni
+New Leaves Allocated (In Days),Novi Lišće alociran (u danima)
+New Material Requests,Novi materijal Zahtjevi
+New Projects,Novi projekti
+New Purchase Orders,Novi narudžbenice kupnje
+New Purchase Receipts,Novi primke kupnje
+New Quotations,Nove ponude
+New Sales Orders,Nove narudžbenice
+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 postavljen od strane burze upisu ili kupiti primitka
+New Stock Entries,Novi Stock upisi
+New Stock UOM,Novi kataloški UOM
+New Stock UOM is required,Novi Stock UOM je potrebno
+New Stock UOM must be different from current stock UOM,Novi Stock UOM mora biti različita od trenutne zalihe UOM
+New Supplier Quotations,Novi dobavljač Citati
+New Support Tickets,Novi Podrška Ulaznice
+New UOM must NOT be of type Whole Number,Novi UOM ne mora biti tipa cijeli broj
+New Workplace,Novi radnom mjestu
+Newsletter,Bilten
+Newsletter Content,Newsletter Sadržaj
+Newsletter Status,Newsletter Status
+Newsletter has already been sent,Newsletter je već poslana
+"Newsletters to contacts, leads.","Brošure za kontakte, vodi."
+Newspaper Publishers,novinski izdavači
+Next,sljedeći
+Next Contact By,Sljedeća Kontakt Do
+Next Contact Date,Sljedeća Kontakt Datum
+Next Date,Sljedeća Datum
+Next email will be sent on:,Sljedeća e-mail će biti poslan na:
+No,Ne
+No Customer Accounts found.,Nema kupaca Računi pronađena .
+No Customer or Supplier Accounts found,Nema kupaca i dobavljača Računi naći
+No Expense Approvers. Please assign 'Expense Approver' Role to atleast one user,Nema Rashodi approvers . Molimo dodijeliti ' Rashodi odobravatelju ' Uloga da atleast jednom korisniku
+No Item with Barcode {0},No Stavka s Barcode {0}
+No Item with Serial No {0},No Stavka s rednim brojem {0}
+No Items to pack,Nema stavki za omot
+No Leave Approvers. Please assign 'Leave Approver' Role to atleast one user,Nema dopusta approvers . Molimo dodijeliti ' ostavite odobravatelju ' Uloga da atleast jednom korisniku
+No Permission,Bez dozvole
+No Production Orders created,Nema Radni nalozi stvoreni
+No Supplier Accounts found. Supplier Accounts are identified based on 'Master Type' value in account record.,"Nema Supplier Računi pronađena . Supplier Računi su identificirani na temelju ' Master vrstu "" vrijednosti u računu rekord ."
+No accounting entries for the following warehouses,Nema računovodstvene unosi za sljedeće skladišta
+No addresses created,Nema adrese stvoreni
+No contacts created,Nema kontakata stvoreni
+No default Address Template found. Please create a new one from Setup > Printing and Branding > Address Template.,Ne zadana adresa Predložak pronađena. Molimo stvoriti novu s Setup> Tisak i Branding> adresu predložak.
+No default BOM exists for Item {0},Ne default BOM postoji točke {0}
+No description given,Nema opisa dano
+No employee found,Niti jedan zaposlenik pronađena
+No employee found!,Niti jedan zaposlenik našao !
+No of Requested SMS,Nema traženih SMS
+No of Sent SMS,Ne poslanih SMS
+No of Visits,Bez pregleda
+No permission,nema dozvole
+No record found,Ne rekord naći
+No records found in the Invoice table,Nisu pronađeni u tablici fakturu
+No records found in the Payment table,Nisu pronađeni u tablici plaćanja
+No salary slip found for month: ,Bez plaće slip naći za mjesec dana:
+Non Profit,Neprofitne
+Nos,Nos
+Not Active,Ne aktivna
+Not Applicable,Nije primjenjivo
+Not Available,nije dostupno
+Not Billed,Ne Naplaćeno
+Not Delivered,Ne Isporučeno
+Not Set,ne Set
+Not allowed to update stock transactions older than {0},Nije dopušteno osvježavanje burzovnih transakcija stariji od {0}
+Not authorized to edit frozen Account {0},Nije ovlašten za uređivanje smrznute račun {0}
+Not authroized since {0} exceeds limits,Ne authroized od {0} prelazi granice
+Not permitted,nije dopušteno
+Note,Primijetiti
+Note User,Napomena Upute
+"Note: Backups and files are not deleted from Dropbox, you will have to delete them manually.","Napomena: Backup i datoteke se ne brišu na Dropbox, morat ćete ih izbrisati ručno."
+"Note: Backups and files are not deleted from Google Drive, you will have to delete them manually.","Napomena: Backup i datoteke se ne brišu na Google Drive, morat ćete ih izbrisati ručno."
+Note: Due Date exceeds the allowed credit days by {0} day(s),Napomena : Zbog Datum prelazi dopuštene kreditne dane od strane {0} dan (a)
+Note: Email will not be sent to disabled users,Napomena: E-mail neće biti poslan invalide
+Note: Item {0} entered multiple times,Napomena : Stavka {0} upisan je više puta
+Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Napomena : Stupanje Plaćanje neće biti izrađen od ' Gotovina ili bankovni račun ' nije naveden
+Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Napomena : Sustav neće provjeravati pretjerano isporuke i više - booking za točku {0} kao količinu ili vrijednost je 0
+Note: There is not enough leave balance for Leave Type {0},Napomena : Nema dovoljno ravnotežu dopust za dozvolu tipa {0}
+Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Napomena : Ovaj troška jegrupa . Ne mogu napraviti računovodstvenih unosa protiv skupine .
+Note: {0},Napomena : {0}
+Notes,Bilješke
+Notes:,Bilješke :
+Nothing to request,Ništa se zatražiti
+Notice (days),Obavijest (dani )
+Notification Control,Obavijest kontrola
+Notification Email Address,Obavijest E-mail adresa
+Notify by Email on creation of automatic Material Request,Obavijesti putem e-pošte na stvaranje automatskog Materijal Zahtjeva
+Number Format,Broj Format
+Offer Date,ponuda Datum
+Office,Ured
+Office Equipments,uredske opreme
+Office Maintenance Expenses,Troškovi održavanja ureda
+Office Rent,najam ureda
+Old Parent,Stari Roditelj
+On Net Total,Na Net Total
+On Previous Row Amount,Na prethodnu Row visini
+On Previous Row Total,Na prethodni redak Ukupno
+Online Auctions,online aukcije
+Only Leave Applications with status 'Approved' can be submitted,"Ostavite samo one prijave sa statusom "" Odobreno"" može se podnijeti"
+"Only Serial Nos with status ""Available"" can be delivered.","Samo Serial Nos sa statusom "" dostupan "" može biti isporučena ."
+Only leaf nodes are allowed in transaction,Samo leaf čvorovi su dozvoljeni u transakciji
+Only the selected Leave Approver can submit this Leave Application,Samoodabrani Ostavite Odobritelj može podnijeti ovo ostaviti aplikacija
+Open,Otvoreno
+Open Production Orders,Otvoren Radni nalozi
+Open Tickets,Otvoreni Ulaznice
+Opening (Cr),Otvaranje ( Cr )
+Opening (Dr),Otvaranje ( DR)
+Opening Date,Otvaranje Datum
+Opening Entry,Otvaranje unos
+Opening Qty,Otvaranje Kol
+Opening Time,Radno vrijeme
+Opening Value,Otvaranje vrijednost
+Opening for a Job.,Otvaranje za posao.
+Operating Cost,Operativni troškovi
+Operation Description,Operacija Opis
+Operation No,Operacija Ne
+Operation Time (mins),Operacija Vrijeme (min)
+Operation {0} is repeated in Operations Table,Operacija {0} se ponavlja u operacijama tablici
+Operation {0} not present in Operations Table,Operacija {0} nije prisutan u operacijama tablici
+Operations,Operacije
+Opportunity,Prilika
+Opportunity Date,Prilika Datum
+Opportunity From,Prilika Od
+Opportunity Item,Prilika artikla
+Opportunity Items,Prilika Proizvodi
+Opportunity Lost,Prilika Izgubili
+Opportunity Type,Prilika Tip
+Optional. This setting will be used to filter in various transactions.,Izborni . Ova postavka će se koristiti za filtriranje u raznim transakcijama .
+Order Type,Vrsta narudžbe
+Order Type must be one of {0},Vrsta narudžbe mora biti jedan od {0}
+Ordered,A do Ž
+Ordered Items To Be Billed,Naručeni Stavke biti naplaćeno
+Ordered Items To Be Delivered,Naručeni Proizvodi se dostavljaju
+Ordered Qty,naredio Kol
+"Ordered Qty: Quantity ordered for purchase, but not received.","Ž Kol : Količina naručiti za kupnju , ali nije dobila ."
+Ordered Quantity,Količina Ž
+Orders released for production.,Narudžbe objavljen za proizvodnju.
+Organization Name,Naziv organizacije
+Organization Profile,Organizacija Profil
+Organization branch master.,Organizacija grana majstor .
+Organization unit (department) master.,Organizacija jedinica ( odjela ) majstor .
+Other,Drugi
+Other Details,Ostali podaci
+Others,drugi
+Out Qty,Od kol
+Out Value,Od vrijednosti
+Out of AMC,Od AMC
+Out of Warranty,Od jamstvo
+Outgoing,Društven
+Outstanding Amount,Izvanredna Iznos
+Outstanding for {0} cannot be less than zero ({1}),Izvanredna za {0} ne može biti manji od nule ( {1} )
+Overhead,Dometnut
+Overheads,opći troškovi
+Overlapping conditions found between:,Preklapanje uvjeti nalaze između :
+Overview,pregled
+Owned,U vlasništvu
+Owner,vlasnik
+P L A - Cess Portion,PLA - Posebni porez porcija
+PL or BS,PL ili BS
+PO Date,PO Datum
+PO No,PO Nema
+POP3 Mail Server,POP3 Mail Server
+POP3 Mail Settings,POP3 Mail Postavke
+POP3 mail server (e.g. pop.gmail.com),POP3 mail server (npr. pop.gmail.com)
+POP3 server e.g. (pop.gmail.com),POP3 poslužitelj npr. (pop.gmail.com)
+POS Setting,POS Podešavanje
+POS Setting required to make POS Entry,POS postavke potrebne da bi POS stupanja
+POS Setting {0} already created for user: {1} and company {2},POS Setting {0} već stvorena za korisnika : {1} i tvrtka {2}
+POS View,POS Pogledaj
+PR Detail,PR Detalj
+Package Item Details,Paket Stavka Detalji
+Package Items,Paket Proizvodi
+Package Weight Details,Težina paketa - detalji
+Packed Item,Dostava Napomena Pakiranje artikla
+Packed quantity must equal quantity for Item {0} in row {1},Prepuna količina mora biti jednaka količina za točku {0} je u redu {1}
+Packing Details,Detalji pakiranja
+Packing List,Popis pakiranja
+Packing Slip,Odreskom
+Packing Slip Item,Odreskom predmet
+Packing Slip Items,Odreskom artikle
+Packing Slip(s) cancelled,Pakiranje proklizavanja ( s) otkazan
+Page Break,Prijelom stranice
+Page Name,Ime stranice
+Paid Amount,Plaćeni iznos
+Paid amount + Write Off Amount can not be greater than Grand Total,Uplaćeni iznos + otpis iznos ne može biti veći od SVEUKUPNO
+Pair,Par
+Parameter,Parametar
+Parent Account,Roditelj račun
+Parent Cost Center,Roditelj troška
+Parent Customer Group,Roditelj Kupac Grupa
+Parent Detail docname,Roditelj Detalj docname
+Parent Item,Roditelj artikla
+Parent Item Group,Roditelj artikla Grupa
+Parent Item {0} must be not Stock Item and must be a Sales Item,Parent Item {0} mora biti ne Stock točka i mora bitiProdaja artikla
+Parent Party Type,Matične stranke Tip
+Parent Sales Person,Roditelj Prodaja Osoba
+Parent Territory,Roditelj Regija
+Parent Website Page,Roditelj Web Stranica
+Parent Website Route,Roditelj Web Route
+Parenttype,Parenttype
+Part-time,Part - time
+Partially Completed,Djelomično Završeni
+Partly Billed,Djelomično Naplaćeno
+Partly Delivered,Djelomično Isporučeno
+Partner Target Detail,Partner Ciljana Detalj
+Partner Type,Partner Tip
+Partner's Website,Web stranica partnera
+Party,Stranka
+Party Account,Party račun
+Party Type,Party Tip
+Party Type Name,Party Vrsta Naziv
+Passive,Pasiva
+Passport Number,Putovnica Broj
+Password,Zaporka
+Pay To / Recd From,Platiti Da / RecD Od
+Payable,Plativ
+Payables,Obveze
+Payables Group,Obveze Grupa
+Payment Days,Plaćanja Dana
+Payment Due Date,Plaćanje Due Date
+Payment Period Based On Invoice Date,Razdoblje za naplatu po Datum fakture
+Payment Reconciliation,Pomirenje plaćanja
+Payment Reconciliation Invoice,Pomirenje Plaćanje fakture
+Payment Reconciliation Invoices,Pomirenje Plaćanje računa
+Payment Reconciliation Payment,Pomirenje Plaćanje Plaćanje
+Payment Reconciliation Payments,Pomirenje Plaćanje Plaćanja
+Payment Type,Vrsta plaćanja
+Payment cannot be made for empty cart,Plaćanje ne može biti za prazan košaricu
+Payment of salary for the month {0} and year {1},Isplata plaće za mjesec {0} i godina {1}
+Payments,Plaćanja
+Payments Made,Uplate Izrađen
+Payments Received,Uplate primljeni
+Payments made during the digest period,Plaćanja tijekom razdoblja digest
+Payments received during the digest period,Uplate primljene tijekom razdoblja digest
+Payroll Settings,Postavke plaće
+Pending,Čekanju
+Pending Amount,Iznos na čekanju
+Pending Items {0} updated,Tijeku stvari {0} ažurirana
+Pending Review,U tijeku pregled
+Pending SO Items For Purchase Request,Otvorena SO Proizvodi za zahtjev za kupnju
+Pension Funds,mirovinskim fondovima
+Percent Complete,Postotak Cijela
+Percentage Allocation,Postotak Raspodjela
+Percentage Allocation should be equal to 100%,Postotak izdvajanja trebala bi biti jednaka 100 %
+Percentage variation in quantity to be allowed while receiving or delivering this item.,Postotak varijacije u količini biti dopušteno dok prima ili isporuku ovu stavku.
+Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.,Postotak koju smiju primiti ili isporučiti više od naručene količine. Na primjer: Ako ste naručili 100 jedinica. i tvoj ispravak je 10% onda se smiju primati 110 jedinica.
+Performance appraisal.,Ocjenjivanje.
+Period,razdoblje
+Period Closing Voucher,Razdoblje Zatvaranje bon
+Periodicity,Periodičnost
+Permanent Address,Stalna adresa
+Permanent Address Is,Stalna adresa je
+Permission,Dopuštenje
+Personal,Osobno
+Personal Details,Osobni podaci
+Personal Email,Osobni e
+Pharmaceutical,farmaceutski
+Pharmaceuticals,Lijekovi
+Phone,Telefon
+Phone No,Telefonski broj
+Piecework,rad plaćen na akord
+Pincode,Poštanski broj
+Place of Issue,Mjesto izdavanja
+Plan for maintenance visits.,Plan održavanja posjeta.
+Planned Qty,Planirani Kol
+"Planned Qty: Quantity, for which, Production Order has been raised, but is pending to be manufactured.","Planirano Količina : Količina , za koje , proizvodnja Red je podigao , ali je u tijeku kako bi se proizvoditi ."
+Planned Quantity,Planirana količina
+Planning,planiranje
+Plant,Biljka
+Plant and Machinery,Postrojenja i strojevi
+Please Enter Abbreviation or Short Name properly as it will be added as Suffix to all Account Heads.,Molimo unesite Skraćenica ili skraćeni naziv ispravno jer će biti dodan kao sufiks na sve računa šefova.
+Please Update SMS Settings,Obnovite SMS Settings
+Please add expense voucher details,Molimo dodati trošak bon pojedinosti
+Please add to Modes of Payment from Setup.,Molimo dodati načina plaćanja iz programa za postavljanje.
+Please check 'Is Advance' against Account {0} if this is an advance entry.,Molimo provjerite ' Je Advance ' protiv računu {0} ako je tounaprijed ulaz .
+Please click on 'Generate Schedule',"Molimo kliknite na ""Generiraj raspored '"
+Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Molimo kliknite na ""Generiraj raspored ' dohvatiti Serial No dodao je za točku {0}"
+Please click on 'Generate Schedule' to get schedule,"Molimo kliknite na ""Generiraj raspored ' kako bi dobili raspored"
+Please create Customer from Lead {0},Molimo stvoriti kupac iz Olovo {0}
+Please create Salary Structure for employee {0},Molimo stvoriti Plaća Struktura za zaposlenika {0}
+Please create new account from Chart of Accounts.,Molimo stvoriti novi račun iz kontnog plana .
+Please do NOT create Account (Ledgers) for Customers and Suppliers. They are created directly from the Customer / Supplier masters.,Molimo vas da ne stvaraju račun ( knjigama ) za kupce i dobavljače . Oni su stvorili izravno iz Kupac / Dobavljač majstora .
+Please enter 'Expected Delivery Date',Unesite ' Očekivani datum isporuke '
+Please enter 'Is Subcontracted' as Yes or No,Unesite ' Je podugovoren ' kao da ili ne
+Please enter 'Repeat on Day of Month' field value,Unesite ' ponovite na dan u mjesecu ' na terenu vrijednosti
+Please enter Account Receivable/Payable group in company master,Unesite račun potraživanja / naplativo skupinu u društvu gospodara
+Please enter Approving Role or Approving User,Unesite Odobravanje ulogu ili Odobravanje korisnike
+Please enter BOM for Item {0} at row {1},Unesite BOM za točku {0} na redu {1}
+Please enter Company,Unesite tvrtke
+Please enter Cost Center,Unesite troška
+Please enter Delivery Note No or Sales Invoice No to proceed,Unesite otpremnica br ili prodaja Račun br postupiti
+Please enter Employee Id of this sales parson,Unesite Id zaposlenika ovog prodajnog župnika
+Please enter Expense Account,Unesite trošak računa
+Please enter Item Code to get batch no,Unesite kod Predmeta da se hrpa nema
+Please enter Item Code.,Unesite kod artikal .
+Please enter Item first,Unesite predmeta prvi
+Please enter Maintaince Details first,Unesite prva Maintaince Detalji
+Please enter Master Name once the account is created.,Unesite Master ime jednomračunu je stvorio .
+Please enter Planned Qty for Item {0} at row {1},Unesite Planirano Qty za točku {0} na redu {1}
+Please enter Production Item first,Unesite Proizvodnja predmeta prvi
+Please enter Purchase Receipt No to proceed,Unesite kupiti primitka No za nastavak
+Please enter Reference date,Unesite Referentni datum
+Please enter Warehouse for which Material Request will be raised,Unesite skladište za koje Materijal Zahtjev će biti podignuta
+Please enter Write Off Account,Unesite otpis račun
+Please enter atleast 1 invoice in the table,Unesite atleast jedan račun u tablici
+Please enter company first,Unesite tvrtka prva
+Please enter company name first,Unesite ime tvrtke prvi
+Please enter default Unit of Measure,Unesite zadanu jedinicu mjere
+Please enter default currency in Company Master,Unesite zadanu valutu u tvrtki Master
+Please enter email address,Molimo unesite e-mail adresu
+Please enter item details,Unesite Detalji
+Please enter message before sending,Unesite poruku prije slanja
+Please enter parent account group for warehouse account,Unesite skupinu roditeljskog računa za skladišta obzir
+Please enter parent cost center,Unesite roditelj troška
+Please enter quantity for Item {0},Molimo unesite količinu za točku {0}
+Please enter relieving date.,Unesite olakšavanja datum .
+Please enter sales order in the above table,Unesite prodajnog naloga u gornjoj tablici
+Please enter valid Company Email,Unesite ispravnu tvrtke E-mail
+Please enter valid Email Id,Unesite ispravnu e-mail ID
+Please enter valid Personal Email,Unesite važeću osobnu e-mail
+Please enter valid mobile nos,Unesite valjane mobilne br
+Please find attached Sales Invoice #{0},U prilogu Prodaja Račun # {0}
+Please install dropbox python module,Molimo instalirajte Dropbox piton modul
+Please mention no of visits required,Molimo spomenuti nema posjeta potrebnih
+Please pull items from Delivery Note,Molimo povucite stavke iz Dostavnica
+Please save the Newsletter before sending,Molimo spremite Newsletter prije slanja
+Please save the document before generating maintenance schedule,Molimo spremite dokument prije stvaranja raspored za održavanje
+Please see attachment,Pogledajte prilog
+Please select Bank Account,Odaberite bankovni račun
+Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,Molimo odaberite prenositi ako želite uključiti prethodnoj fiskalnoj godini je ravnoteža ostavlja na ovoj fiskalnoj godini
+Please select Category first,Molimo odaberite kategoriju prvi
+Please select Charge Type first,Odaberite Naknada za prvi
+Please select Fiscal Year,Odaberite Fiskalna godina
+Please select Group or Ledger value,Odaberite vrijednost grupi ili Ledger
+Please select Incharge Person's name,Odaberite incharge ime osobe
+Please select Invoice Type and Invoice Number in atleast one row,Odaberite fakture Vid i broj računa u atleast jednom redu
+"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Sales BOM","Odaberite stavku u kojoj "" Je Stock Stavka "" je ""ne "" i "" Je Prodaja Stavka "" je "" Da "" i ne postoji drugi Prodaja BOM"
+Please select Price List,Molimo odaberite Cjenik
+Please select Start Date and End Date for Item {0},Molimo odaberite datum početka i datum završetka za točke {0}
+Please select Time Logs.,Odaberite vrijeme Evidencije.
+Please select a csv file,Odaberite CSV datoteku
+Please select a valid csv file with data,Odaberite valjanu CSV datoteku s podacima
+Please select a value for {0} quotation_to {1},Molimo odabir vrijednosti za {0} quotation_to {1}
+"Please select an ""Image"" first","Molimo odaberite ""Slika"" Prvi"
+Please select charge type first,Odaberite vrstu naboja prvi
+Please select company first,Odaberite tvrtku prvi
+Please select company first.,Odaberite tvrtku prvi.
+Please select item code,Odaberite Šifra
+Please select month and year,Molimo odaberite mjesec i godinu
+Please select prefix first,Odaberite prefiks prvi
+Please select the document type first,Molimo odaberite vrstu dokumenta prvi
+Please select weekly off day,Odaberite tjednik off dan
+Please select {0},Odaberite {0}
+Please select {0} first,Odaberite {0} Prvi
+Please select {0} first.,Odaberite {0} na prvom mjestu.
+Please set Dropbox access keys in your site config,Molimo postaviti Dropbox pristupnih tipki u vašem web config
+Please set Google Drive access keys in {0},Molimo postaviti Google Drive pristupnih tipki u {0}
+Please set default Cash or Bank account in Mode of Payment {0},Molimo postavite zadanu gotovinom ili banka računa u načinu plaćanja {0}
+Please set default value {0} in Company {0},Molimo postavite zadanu vrijednost {0} u Društvu {0}
+Please set {0},Molimo postavite {0}
+Please setup Employee Naming System in Human Resource > HR Settings,Molimo postavljanje zaposlenika sustav imenovanja u ljudskim resursima&gt; HR Postavke
+Please setup numbering series for Attendance via Setup > Numbering Series,Molimo postava numeriranje serija za sudjelovanje putem Podešavanje> numeriranja serije
+Please setup your chart of accounts before you start Accounting Entries,Molim postaviti svoj kontni plan prije nego što počnete računovodstvenih unosa
+Please specify,Navedite
+Please specify Company,Navedite tvrtke
+Please specify Company to proceed,Navedite Tvrtka postupiti
+Please specify Default Currency in Company Master and Global Defaults,Navedite zadanu valutu u tvrtki Global Master i zadane
+Please specify a,Navedite
+Please specify a valid 'From Case No.',Navedite važeću &#39;iz Predmet br&#39;
+Please specify a valid Row ID for {0} in row {1},Navedite valjanu Row ID za {0} je u redu {1}
+Please specify either Quantity or Valuation Rate or both,Navedite ili količini ili vrednovanja Ocijenite ili oboje
+Please submit to update Leave Balance.,Molimo dostaviti ažurirati napuste balans .
+Plot,zemljište
+Plot By,zemljište By
+Point of Sale,Point of Sale
+Point-of-Sale Setting,Point-of-Sale Podešavanje
+Post Graduate,Post diplomski
+Postal,Poštanski
+Postal Expenses,Poštanski troškovi
+Posting Date,Objavljivanje Datum
+Posting Time,Objavljivanje Vrijeme
+Posting date and posting time is mandatory,Datum knjiženja i knjiženje vrijeme je obvezna
+Posting timestamp must be after {0},Objavljivanje timestamp mora biti poslije {0}
+Potential opportunities for selling.,Potencijalni mogućnosti za prodaju.
+Preferred Billing Address,Željena adresa za naplatu
+Preferred Shipping Address,Željena Dostava Adresa
+Prefix,Prefiks
+Present,Sadašnje
+Prevdoc DocType,Prevdoc DOCTYPE
+Prevdoc Doctype,Prevdoc DOCTYPE
+Preview,Pregled
+Previous,prijašnji
+Previous Work Experience,Radnog iskustva
+Price,Cijena
+Price / Discount,Cijena / Popust
+Price List,Cjenik
+Price List Currency,Cjenik valuta
+Price List Currency not selected,Cjenik valuta ne bira
+Price List Exchange Rate,Cjenik tečajna
+Price List Name,Cjenik Ime
+Price List Rate,Cjenik Stopa
+Price List Rate (Company Currency),Cjenik stopa (Društvo valuta)
+Price List master.,Cjenik majstor .
+Price List must be applicable for Buying or Selling,Cjenik mora biti primjenjiv za kupnju ili prodaju
+Price List not selected,Popis Cijena ne bira
+Price List {0} is disabled,Cjenik {0} je onemogućen
+Price or Discount,Cijena i popust
+Pricing Rule,cijene Pravilo
+Pricing Rule Help,Cijene Pravilo Pomoć
+"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Cijene Pravilo prvo se bira na temelju 'Nanesite na' terenu, koji može biti točka, točka Grupa ili Brand."
+"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Cijene Pravilo je napravljen prebrisati Cjenik / definirati postotak popusta, na temelju nekih kriterija."
+Pricing Rules are further filtered based on quantity.,Pravilnik o određivanju cijena dodatno se filtrira na temelju količine.
+Print Format Style,Print Format Style
+Print Heading,Ispis Naslov
+Print Without Amount,Ispis Bez visini
+Print and Stationary,Ispis i stacionarnih
+Printing and Branding,Tiskanje i Branding
+Priority,Prioritet
+Private Equity,Private Equity
+Privilege Leave,Privilege dopust
+Probation,probni rad
+Process Payroll,Proces plaće
+Produced,izrađen
+Produced Quantity,Proizveden Količina
+Product Enquiry,Na upit
+Production,proizvodnja
+Production Order,Proizvodnja Red
+Production Order status is {0},Status radnog naloga je {0}
+Production Order {0} must be cancelled before cancelling this Sales Order,Proizvodnja Red {0} mora biti otkazana prije poništenja ovu prodajnog naloga
+Production Order {0} must be submitted,Proizvodnja Red {0} mora biti podnesen
+Production Orders,Nalozi
+Production Orders in Progress,Radni nalozi u tijeku
+Production Plan Item,Proizvodnja plan artikla
+Production Plan Items,Plan proizvodnje Proizvodi
+Production Plan Sales Order,Proizvodnja plan prodajnog naloga
+Production Plan Sales Orders,Plan proizvodnje narudžbe
+Production Planning Tool,Planiranje proizvodnje alat
+Products,Proizvodi
+"Products will be sorted by weight-age in default searches. More the weight-age, higher the product will appear in the list.","Proizvodi će biti razvrstani po težine dobi u zadane pretraživanja. Više težina-dob, veća proizvod će se pojaviti na popisu."
+Professional Tax,Stručni Porezni
+Profit and Loss,Račun dobiti i gubitka
+Profit and Loss Statement,Račun dobiti i gubitka
+Project,Projekt
+Project Costing,Projekt Costing
+Project Details,Projekt Detalji
+Project Manager,Voditelj projekta
+Project Milestone,Projekt Prekretnica
+Project Milestones,Projekt Dostignuća
+Project Name,Naziv projekta
+Project Start Date,Projekt datum početka
+Project Type,Vrsta projekta
+Project Value,Projekt Vrijednost
+Project activity / task.,Projekt aktivnost / zadatak.
+Project master.,Projekt majstor.
+Project will get saved and will be searchable with project name given,Projekt će biti spašen i da će se moći pretraživati ​​s projektom ime dano
+Project wise Stock Tracking,Projekt mudar Stock Praćenje
+Project-wise data is not available for Quotation,Projekt - mudar podaci nisu dostupni za ponudu
+Projected,projektiran
+Projected Qty,Predviđen Kol
+Projects,Projekti
+Projects & System,Projekti i sustav
+Prompt for Email on Submission of,Pitaj za e-poštu na podnošenje
+Proposal Writing,Pisanje prijedlog
+Provide email id registered in company,Osigurati e id registriran u tvrtki
+Provisional Profit / Loss (Credit),Privremeni dobit / gubitak (Credit)
+Public,Javni
+Published on website at: {0},Objavljeni na web stranici: {0}
+Publishing,objavljivanje
+Pull sales orders (pending to deliver) based on the above criteria,Povucite prodajne naloge (na čekanju za isporuku) na temelju navedenih kriterija
+Purchase,Kupiti
+Purchase / Manufacture Details,Kupnja / Proizvodnja Detalji
+Purchase Analytics,Kupnja Analytics
+Purchase Common,Kupnja Zajednička
+Purchase Details,Kupnja Detalji
+Purchase Discounts,Kupnja Popusti
+Purchase Invoice,Kupnja fakture
+Purchase Invoice Advance,Kupnja fakture Predujam
+Purchase Invoice Advances,Kupnja fakture Napredak
+Purchase Invoice Item,Kupnja fakture predmet
+Purchase Invoice Trends,Trendovi kupnje proizvoda
+Purchase Invoice {0} is already submitted,Kupnja Račun {0} već je podnijela
+Purchase Order,Narudžbenica
+Purchase Order Item,Narudžbenica predmet
+Purchase Order Item No,Narudžbenica Br.
+Purchase Order Item Supplied,Narudžbenica artikla Isporuka
+Purchase Order Items,Narudžbenica artikle
+Purchase Order Items Supplied,Narudžbenica Proizvodi Isporuka
+Purchase Order Items To Be Billed,Narudžbenica Proizvodi se naplaćuje
+Purchase Order Items To Be Received,Narudžbenica Proizvodi treba primiti
+Purchase Order Message,Narudžbenica poruku
+Purchase Order Required,Narudžbenica Obvezno
+Purchase Order Trends,Narudžbenica trendovi
+Purchase Order number required for Item {0},Broj narudžbenice potrebne za točku {0}
+Purchase Order {0} is 'Stopped',Narudžbenica {0} je ' Zaustavljen '
+Purchase Order {0} is not submitted,Narudžbenicu {0} nije podnesen
+Purchase Orders given to Suppliers.,Kupnja naloge koje je dao dobavljače.
+Purchase Receipt,Račun kupnje
+Purchase Receipt Item,Kupnja Potvrda predmet
+Purchase Receipt Item Supplied,Kupnja Prijem artikla Isporuka
+Purchase Receipt Item Supplieds,Kupnja Supplieds Stavka primitka
+Purchase Receipt Items,Kupnja primitka artikle
+Purchase Receipt Message,Kupnja Potvrda poruku
+Purchase Receipt No,Račun kupnje Ne
+Purchase Receipt Required,Kupnja Potvrda Obvezno
+Purchase Receipt Trends,Račun kupnje trendovi
+Purchase Receipt number required for Item {0},Račun kupnje broj potreban za točku {0}
+Purchase Receipt {0} is not submitted,Račun kupnje {0} nije podnesen
+Purchase Register,Kupnja Registracija
+Purchase Return,Kupnja Povratak
+Purchase Returned,Kupnja Vraćeno
+Purchase Taxes and Charges,Kupnja Porezi i naknade
+Purchase Taxes and Charges Master,Kupnja Porezi i naknade Master
+Purchse Order number required for Item {0},Broj Purchse Order potrebno za točke {0}
+Purpose,Svrha
+Purpose must be one of {0},Svrha mora biti jedan od {0}
+QA Inspection,QA Inspekcija
+Qty,Kol
+Qty Consumed Per Unit,Kol Potrošeno po jedinici
+Qty To Manufacture,Količina za proizvodnju
+Qty as per Stock UOM,Količina po burzi UOM
+Qty to Deliver,Količina za dovođenje
+Qty to Order,Količina za narudžbu
+Qty to Receive,Količina za primanje
+Qty to Transfer,Količina za prijenos
+Qualification,Kvalifikacija
+Quality,Kvaliteta
+Quality Inspection,Provjera kvalitete
+Quality Inspection Parameters,Inspekcija kvalitete Parametri
+Quality Inspection Reading,Kvaliteta Inspekcija čitanje
+Quality Inspection Readings,Inspekcija kvalitete Čitanja
+Quality Inspection required for Item {0},Provera kvaliteta potrebna za točke {0}
+Quality Management,upravljanja kvalitetom
+Quantity,Količina
+Quantity Requested for Purchase,Količina Traženi za kupnju
+Quantity and Rate,Količina i stopa
+Quantity and Warehouse,Količina i skladišta
+Quantity cannot be a fraction in row {0},Količina ne može bitidio u redu {0}
+Quantity for Item {0} must be less than {1},Količina za točku {0} mora biti manji od {1}
+Quantity in row {0} ({1}) must be same as manufactured quantity {2},Količina u redu {0} ( {1} ) mora biti isti kao proizvedena količina {2}
+Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Količina predmeta dobije nakon proizvodnju / pakiranje od navedenih količina sirovina
+Quantity required for Item {0} in row {1},Količina potrebna za točke {0} je u redu {1}
+Quarter,Četvrtina
+Quarterly,Tromjesečni
+Quick Help,Brza pomoć
+Quotation,Ponuda
+Quotation Item,Artikl iz ponude
+Quotation Items,Artikli iz ponude
+Quotation Lost Reason,Razlog nerealizirane ponude
+Quotation Message,Ponuda - poruka
+Quotation To,Ponuda za
+Quotation Trends,Trendovi ponude
+Quotation {0} is cancelled,Ponuda {0} je otkazana
+Quotation {0} not of type {1},Ponuda {0} nije tip {1}
+Quotations received from Suppliers.,Ponude dobivene od dobavljača.
+Quotes to Leads or Customers.,Citati na vodi ili kupaca.
+Raise Material Request when stock reaches re-order level,Podignite Materijal Zahtjev kad dionica dosegne ponovno poredak razinu
+Raised By,Povišena Do
+Raised By (Email),Povišena Do (e)
+Random,Slučajan
+Range,Domet
+Rate,VPC
+Rate ,Stopa
+Rate (%),Stopa ( % )
+Rate (Company Currency),Ocijeni (Društvo valuta)
+Rate Of Materials Based On,Stopa materijali na temelju
+Rate and Amount,Kamatna stopa i iznos
+Rate at which Customer Currency is converted to customer's base currency,Stopa po kojoj Kupac valuta se pretvaraju u kupca osnovne valute
+Rate at which Price list currency is converted to company's base currency,Stopa po kojoj Cjenik valute se pretvaraju u tvrtke bazne valute
+Rate at which Price list currency is converted to customer's base currency,Stopa po kojoj Cjenik valute se pretvaraju u kupca osnovne valute
+Rate at which customer's currency is converted to company's base currency,Stopa po kojoj se valuta klijenta se pretvaraju u tvrtke bazne valute
+Rate at which supplier's currency is converted to company's base currency,Stopa po kojoj supplier valuta se pretvaraju u tvrtke bazne valute
+Rate at which this tax is applied,Stopa po kojoj je taj porez se primjenjuje
+Raw Material,sirovine
+Raw Material Item Code,Sirovine Stavka Šifra
+Raw Materials Supplied,Sirovine nabavlja
+Raw Materials Supplied Cost,Sirovine Isporuka Troškovi
+Raw material cannot be same as main Item,Sirovina ne mogu biti isti kao glavni predmet
+Re-Order Level,Re-Order Razina
+Re-Order Qty,Re-Order Kol
+Re-order,Ponovno bi
+Re-order Level,Ponovno bi Razina
+Re-order Qty,Ponovno bi Kol
+Read,Čitati
+Reading 1,Čitanje 1
+Reading 10,Čitanje 10
+Reading 2,Čitanje 2
+Reading 3,Čitanje 3
+Reading 4,Čitanje 4
+Reading 5,Čitanje 5
+Reading 6,Čitanje 6
+Reading 7,Čitanje 7
+Reading 8,Čitanje 8
+Reading 9,Čitanje 9
+Real Estate,Nekretnine
+Reason,Razlog
+Reason for Leaving,Razlog za odlazak
+Reason for Resignation,Razlog za ostavku
+Reason for losing,Razlog za gubljenje
+Recd Quantity,RecD Količina
+Receivable,potraživanja
+Receivable / Payable account will be identified based on the field Master Type,Potraživanja / obveze prema dobavljačima račun će se utvrditi na temelju vrsti terenu Master
+Receivables,Potraživanja
+Receivables / Payables,Potraživanja / obveze
+Receivables Group,Potraživanja Grupa
+Received Date,Datum pozicija
+Received Items To Be Billed,Primljeni Proizvodi se naplaćuje
+Received Qty,Pozicija Kol
+Received and Accepted,Primljeni i prihvaćeni
+Receiver List,Prijemnik Popis
+Receiver List is empty. Please create Receiver List,Receiver Lista je prazna . Molimo stvoriti Receiver Popis
+Receiver Parameter,Prijemnik parametra
+Recipients,Primatelji
+Reconcile,pomiriti
+Reconciliation Data,Pomirenje podataka
+Reconciliation HTML,Pomirenje HTML
+Reconciliation JSON,Pomirenje JSON
+Record item movement.,Zabilježite stavku pokret.
+Recurring Id,Ponavljajući Id
+Recurring Invoice,Ponavljajući Račun
+Recurring Type,Ponavljajući Tip
+Reduce Deduction for Leave Without Pay (LWP),Smanjite odbitak za ostaviti bez plaća (lwp)
+Reduce Earning for Leave Without Pay (LWP),Smanjenje plaća za ostaviti bez plaće (lwp)
+Ref,Ref.
+Ref Code,Ref. Šifra
+Ref SQ,Ref. SQ
+Reference,Upućivanje
+Reference #{0} dated {1},Reference # {0} od {1}
+Reference Date,Referentni datum
+Reference Name,Referenca Ime
+Reference No & Reference Date is required for {0},Reference Nema & Reference Datum je potrebno za {0}
+Reference No is mandatory if you entered Reference Date,Reference Ne obvezno ako ušao referentnog datuma
+Reference Number,Referentni broj
+Reference Row #,Reference Row #
+Refresh,Osvježiti
+Registration Details,Registracija Brodu
+Registration Info,Registracija Info
+Rejected,Odbijen
+Rejected Quantity,Odbijen Količina
+Rejected Serial No,Odbijen Serijski br
+Rejected Warehouse,Odbijen galerija
+Rejected Warehouse is mandatory against regected item,Odbijen Skladište je obavezno protiv regected stavku
+Relation,Odnos
+Relieving Date,Rasterećenje Datum
+Relieving Date must be greater than Date of Joining,Olakšavanja Datum mora biti veći od dana ulaska u
+Remark,Primjedba
+Remarks,Primjedbe
+Remarks Custom,Primjedbe Custom
+Rename,preimenovati
+Rename Log,Preimenovanje Prijavite
+Rename Tool,Preimenovanje alat
+Rent Cost,Rent cost
+Rent per hour,Najam po satu
+Rented,Iznajmljuje
+Repeat on Day of Month,Ponovite na dan u mjesecu
+Replace,Zamijeniti
+Replace Item / BOM in all BOMs,Zamijenite predmet / BOM u svim sastavnicama
+Replied,Odgovorio
+Report Date,Prijavi Datum
+Report Type,Prijavi Vid
+Report Type is mandatory,Vrsta izvješća je obvezno
+Reports to,Izvješća
+Reqd By Date,Reqd Po datumu
+Reqd by Date,Reqd po datumu
+Request Type,Zahtjev Tip
+Request for Information,Zahtjev za informacije
+Request for purchase.,Zahtjev za kupnju.
+Requested,Tražena
+Requested For,Traženi Za
+Requested Items To Be Ordered,Traženi Proizvodi se mogu naručiti
+Requested Items To Be Transferred,Traženi stavki za prijenos
+Requested Qty,Traženi Kol
+"Requested Qty: Quantity requested for purchase, but not ordered.","Tražena količina : Količina zatražio za kupnju , ali ne i naređeno ."
+Requests for items.,Zahtjevi za stavke.
+Required By,Potrebna Do
+Required Date,Potrebna Datum
+Required Qty,Potrebna Kol
+Required only for sample item.,Potrebna je samo za primjer stavke.
+Required raw materials issued to the supplier for producing a sub - contracted item.,Potrebna sirovina izdane dobavljač za proizvodnju pod - ugovoreni predmet.
+Research,istraživanje
+Research & Development,Istraživanje i razvoj
+Researcher,istraživač
+Reseller,Prodavač
+Reserved,Rezervirano
+Reserved Qty,Rezervirano Kol
+"Reserved Qty: Quantity ordered for sale, but not delivered.","Rezervirano Količina : Količina naručiti za prodaju , ali nije dostavljena ."
+Reserved Quantity,Rezervirano Količina
+Reserved Warehouse,Rezervirano galerija
+Reserved Warehouse in Sales Order / Finished Goods Warehouse,Rezervirano Warehouse u prodajni nalog / skladišta gotovih proizvoda
+Reserved Warehouse is missing in Sales Order,Rezervirano Warehouse nedostaje u prodajni nalog
+Reserved Warehouse required for stock Item {0} in row {1},Rezervirana Skladište potrebno za dionice točke {0} u redu {1}
+Reserved warehouse required for stock item {0},Rezervirana skladište potrebno za dionice predmet {0}
+Reserves and Surplus,Pričuve i višak
+Reset Filters,Reset Filteri
+Resignation Letter Date,Ostavka Pismo Datum
+Resolution,Rezolucija
+Resolution Date,Rezolucija Datum
+Resolution Details,Rezolucija o Brodu
+Resolved By,Riješen Do
+Rest Of The World,Ostatak svijeta
+Retail,Maloprodaja
+Retail & Wholesale,Trgovina na veliko i
+Retailer,Prodavač na malo
+Review Date,Recenzija Datum
+Rgt,Ustaša
+Role Allowed to edit frozen stock,Uloga dopuštenih urediti smrznute zalihe
+Role that is allowed to submit transactions that exceed credit limits set.,Uloga koja je dopušteno podnijeti transakcije koje premašuju kreditnih ograničenja postavljena.
+Root Type,korijen Tip
+Root Type is mandatory,Korijen Tip je obvezno
+Root account can not be deleted,Korijen račun ne može biti izbrisan
+Root cannot be edited.,Korijen ne može se mijenjati .
+Root cannot have a parent cost center,Korijen ne mogu imati središte troškova roditelj
+Rounded Off,zaokružen
+Rounded Total,Zaokruženi iznos
+Rounded Total (Company Currency),Zaobljeni Ukupno (Društvo valuta)
+Row # ,Redak #
+Row # {0}: ,Row # {0}: 
+Row #{0}: Ordered qty can not less than item's minimum order qty (defined in item master).,Row # {0}: Ž Količina ne može manje od stavke minimalne narudžbe kom (definiranom u točki gospodara).
+Row #{0}: Please specify Serial No for Item {1},Row # {0}: Navedite rednim brojem predmeta za {1}
+Row {0}: Account does not match with \						Purchase Invoice Credit To account,Red {0}: račun ne odgovara \ Kupnja Račun kredit za račun
+Row {0}: Account does not match with \						Sales Invoice Debit To account,Red {0}: račun ne odgovara \ Prodaja Račun terećenja na računu
+Row {0}: Conversion Factor is mandatory,Red {0}: pretvorbe Factor je obvezno
+Row {0}: Credit entry can not be linked with a Purchase Invoice,Red {0} : Kreditni unos ne može biti povezan s kupnje proizvoda
+Row {0}: Debit entry can not be linked with a Sales Invoice,Red {0} : debitne unos ne može biti povezan s prodaje fakture
+Row {0}: Payment amount must be less than or equals to invoice outstanding amount. Please refer Note below.,Red {0}: Iznos uplate mora biti manji ili jednak da računa preostali iznos. Pogledajte Napomena nastavku.
+Row {0}: Qty is mandatory,Red {0}: Količina je obvezno
+"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.					Available Qty: {4}, Transfer Qty: {5}","Red {0}: Kol ne stavi na raspolaganje u skladištu {1} na {2} {3}. Dostupan Količina: {4}, prijenos Kol: {5}"
+"Row {0}: To set {1} periodicity, difference between from and to date \						must be greater than or equal to {2}","Red {0}: Za postavljanje {1} periodičnost, razlika između od i do sada \ mora biti veći ili jednak {2}"
+Row {0}:Start Date must be before End Date,Red {0} : Datum početka mora biti prije datuma završetka
+Rules for adding shipping costs.,Pravila za dodavanjem troškove prijevoza .
+Rules for applying pricing and discount.,Pravila za primjenu cijene i popust .
+Rules to calculate shipping amount for a sale,Pravila za izračun shipping iznos za prodaju
+S.O. No.,S.O. Ne.
+SHE Cess on Excise,ONA procesni o akcizama
+SHE Cess on Service Tax,ONA procesni na usluga poreza
+SHE Cess on TDS,ONA procesni na TDS
+SMS Center,SMS centar
+SMS Gateway URL,SMS Gateway URL
+SMS Log,SMS Prijava
+SMS Parameter,SMS parametra
+SMS Sender Name,SMS Sender Ime
+SMS Settings,Postavke SMS
+SO Date,SO Datum
+SO Pending Qty,SO čekanju Kol
+SO Qty,SO Kol
+Salary,Plaća
+Salary Information,Plaća informacije
+Salary Manager,Plaća Manager
+Salary Mode,Plaća način
+Salary Slip,Plaća proklizavanja
+Salary Slip Deduction,Plaća proklizavanja Odbitak
+Salary Slip Earning,Plaća proklizavanja Zarada
+Salary Slip of employee {0} already created for this month,Plaća Slip zaposlenika {0} već stvorena za ovaj mjesec
+Salary Structure,Plaća Struktura
+Salary Structure Deduction,Plaća Struktura Odbitak
+Salary Structure Earning,Plaća Struktura Zarada
+Salary Structure Earnings,Plaća Struktura Zarada
+Salary breakup based on Earning and Deduction.,Plaća raspada temelju zarađivati ​​i odbitka.
+Salary components.,Plaća komponente.
+Salary template master.,Plaća predložak majstor .
+Sales,Prodaja
+Sales Analytics,Prodajna analitika
+Sales BOM,Prodaja BOM
+Sales BOM Help,Prodaja BOM Pomoć
+Sales BOM Item,Prodaja BOM artikla
+Sales BOM Items,Prodaja BOM Proizvodi
+Sales Browser,prodaja preglednik
+Sales Details,Prodajni detalji
+Sales Discounts,Prodajni popusti
+Sales Email Settings,Prodajne email postavke
+Sales Expenses,Prodajni troškovi
+Sales Extras,Prodajni dodaci
+Sales Funnel,prodaja dimnjak
+Sales Invoice,Prodajni račun
+Sales Invoice Advance,Predujam prodajnog računa
+Sales Invoice Item,Prodajni artikal
+Sales Invoice Items,Prodajni artikli
+Sales Invoice Message,Poruka prodajnog  računa
+Sales Invoice No,Prodajni račun br
+Sales Invoice Trends,Trendovi prodajnih računa
+Sales Invoice {0} has already been submitted,Prodajni računi {0} su već potvrđeni
+Sales Invoice {0} must be cancelled before cancelling this Sales Order,Prodaja Račun {0} mora biti otkazana prije poništenja ovu prodajnog naloga
+Sales Order,Narudžba kupca
+Sales Order Date,Datum narudžbe (kupca)
+Sales Order Item,Naručeni artikal - prodaja
+Sales Order Items,Naručeni artikli - prodaja
+Sales Order Message,Poruka narudžbe kupca
+Sales Order No,Broj narudžbe kupca
+Sales Order Required,Prodajnog naloga Obvezno
+Sales Order Trends,Prodajnog naloga trendovi
+Sales Order required for Item {0},Prodajnog naloga potrebna za točke {0}
+Sales Order {0} is not submitted,Prodajnog naloga {0} nije podnesen
+Sales Order {0} is not valid,Prodajnog naloga {0} nije ispravan
+Sales Order {0} is stopped,Prodajnog naloga {0} je zaustavljen
+Sales Partner,Prodajni partner
+Sales Partner Name,Prodaja Ime partnera
+Sales Partner Target,Prodaja partner Target
+Sales Partners Commission,Prodaja Partneri komisija
+Sales Person,Prodajna osoba
+Sales Person Name,Ime prodajne osobe
+Sales Person Target Variance Item Group-Wise,Prodaja Osoba Target varijance artikla Group - Wise
+Sales Person Targets,Prodaje osobi Mete
+Sales Person-wise Transaction Summary,Prodaja Osobne mudar Transakcija Sažetak
+Sales Register,Prodaja Registracija
+Sales Return,Povrat robe
+Sales Returned,prodaja Vraćeno
+Sales Taxes and Charges,Prodaja Porezi i naknade
+Sales Taxes and Charges Master,Prodaja Porezi i naknade Master
+Sales Team,Prodaja Team
+Sales Team Details,Prodaja Team Detalji
+Sales Team1,Prodaja Team1
+Sales and Purchase,Prodaje i kupnje
+Sales campaigns.,Prodajne kampanje.
+Salutation,Pozdrav
+Sample Size,Veličina uzorka
+Sanctioned Amount,Iznos kažnjeni
+Saturday,Subota
+Schedule,Raspored
+Schedule Date,Raspored Datum
+Schedule Details,Raspored Detalji
+Scheduled,Planiran
+Scheduled Date,Planirano Datum
+Scheduled to send to {0},Planirano za slanje na {0}
+Scheduled to send to {0} recipients,Planirano za slanje na {0} primatelja
+Scheduler Failed Events,Raspored događanja Neuspjeli
+School/University,Škola / Sveučilište
+Score (0-5),Ocjena (0-5)
+Score Earned,Ocjena Zarađeni
+Score must be less than or equal to 5,Rezultat mora biti manja od ili jednaka 5
+Scrap %,Otpad%
+Seasonality for setting budgets.,Sezonalnost za postavljanje proračuna.
+Secretary,tajnica
+Secured Loans,osigurani krediti
+Securities & Commodity Exchanges,Vrijednosni papiri i robne razmjene
+Securities and Deposits,Vrijednosni papiri i depoziti
+"See ""Rate Of Materials Based On"" in Costing Section",Pogledajte &quot;stopa materijali na temelju troškova&quot; u odjeljak
+"Select ""Yes"" for sub - contracting items",Odaberite &quot;Da&quot; za pod - ugovorne stavke
+"Select ""Yes"" if this item is used for some internal purpose in your company.",Odaberite &quot;Da&quot; ako ova stavka se koristi za neke unutarnje potrebe u vašoj tvrtki.
+"Select ""Yes"" if this item represents some work like training, designing, consulting etc.","Odaberite &quot;Da&quot; ako ova stavka predstavlja neki posao poput treninga, projektiranje, konzalting i sl."
+"Select ""Yes"" if you are maintaining stock of this item in your Inventory.",Odaberite &quot;Da&quot; ako ste održavanju zaliha ove točke u vašem inventaru.
+"Select ""Yes"" if you supply raw materials to your supplier to manufacture this item.",Odaberite &quot;Da&quot; ako opskrbu sirovina na svoj dobavljača za proizvodnju ovu stavku.
+Select Brand...,Odaberite brend ...
+Select Budget Distribution to unevenly distribute targets across months.,Odaberite Budget distribuciju neravnomjerno raspodijeliti ciljeve diljem mjeseci.
+"Select Budget Distribution, if you want to track based on seasonality.","Odaberite Budget Distribution, ako želite pratiti na temelju sezonalnosti."
+Select Company...,Odaberite tvrtku ...
+Select DocType,Odaberite DOCTYPE
+Select Fiscal Year...,Odaberite fiskalnu godinu ...
+Select Items,Odaberite artikle
+Select Project...,Odaberite projekt ...
+Select Purchase Receipts,Odaberite primku
+Select Sales Orders,Odaberite narudžbe kupca
+Select Sales Orders from which you want to create Production Orders.,Odaberite narudžbe iz kojih želite stvoriti radne naloge.
+Select Time Logs and Submit to create a new Sales Invoice.,Odaberite vrijeme Evidencije i slanje stvoriti novi prodajni fakture.
+Select Transaction,Odaberite transakciju
+Select Warehouse...,Odaberite skladište ...
+Select Your Language,Odaberite jezik
+Select account head of the bank where cheque was deposited.,Odaberite račun šefa banke gdje je ček bio pohranjen.
+Select company name first.,Prvo odaberite naziv tvrtke.
+Select template from which you want to get the Goals,Odaberite predložak s kojeg želite dobiti ciljeva
+Select the Employee for whom you are creating the Appraisal.,Odaberite zaposlenika za koga se stvara procjene.
+Select the period when the invoice will be generated automatically,Odaberite razdoblje kada faktura će biti generiran automatski
+Select the relevant company name if you have multiple companies,Odaberite odgovarajući naziv tvrtke ako imate više tvrtki
+Select the relevant company name if you have multiple companies.,Odaberite odgovarajući naziv tvrtke ako imate više tvrtki.
+Select who you want to send this newsletter to,Odaberite kome želite poslati ovaj bilten
+Select your home country and check the timezone and currency.,Odaberite zemlju i provjerite zonu i valutu.
+"Selecting ""Yes"" will allow this item to appear in Purchase Order , Purchase Receipt.","Odabir &quot;Da&quot; omogućit će ovu stavku da se pojavi u narudžbenice, Otkup primitka."
+"Selecting ""Yes"" will allow this item to figure in Sales Order, Delivery Note","Odabir &quot;Da&quot; omogućit će ovaj predmet shvatiti u prodajni nalog, otpremnici"
+"Selecting ""Yes"" will allow you to create Bill of Material showing raw material and operational costs incurred to manufacture this item.",Odabir &quot;Da&quot; će vam omogućiti da stvorite Bill materijala pokazuje sirovina i operativne troškove nastale za proizvodnju ovu stavku.
+"Selecting ""Yes"" will allow you to make a Production Order for this item.",Odabir &quot;Da&quot; će vam omogućiti da napravite proizvodnom nalogu za tu stavku.
+"Selecting ""Yes"" will give a unique identity to each entity of this item which can be viewed in the Serial No master.",Odabir &quot;Da&quot; će dati jedinstveni identitet svakog entiteta ove točke koja se može vidjeti u rednim brojem učitelja.
+Selling,Prodaja
+Selling Settings,Postavke prodaje
+"Selling must be checked, if Applicable For is selected as {0}","Prodaje se mora provjeriti, ako je primjenjivo za odabrano kao {0}"
+Send,Poslati
+Send Autoreply,Pošalji Automatski
+Send Email,Pošaljite e-poštu
+Send From,Pošalji Iz
+Send Notifications To,Slanje obavijesti
+Send Now,Pošalji odmah
+Send SMS,Pošalji SMS
+Send To,Pošalji
+Send To Type,Pošalji Upišite
+Send mass SMS to your contacts,Pošalji masovne SMS svojim kontaktima
+Send to this list,Pošalji na ovom popisu
+Sender Name,Pošiljatelj Ime
+Sent On,Poslan Na
+Separate production order will be created for each finished good item.,Poseban proizvodnja kako će biti izrađen za svakog gotovog dobrom stavke.
+Serial No,Serijski br
+Serial No / Batch,Serijski Ne / Batch
+Serial No Details,Serijski nema podataka
+Serial No Service Contract Expiry,Serijski Bez isteka Ugovor o pružanju usluga
+Serial No Status,Serijski Bez Status
+Serial No Warranty Expiry,Serijski Nema jamstva isteka
+Serial No is mandatory for Item {0},Serijski Nema je obvezna za točke {0}
+Serial No {0} created,Serijski Ne {0} stvorio
+Serial No {0} does not belong to Delivery Note {1},Serijski Ne {0} ne pripada isporuke Napomena {1}
+Serial No {0} does not belong to Item {1},Serijski Ne {0} ne pripada točki {1}
+Serial No {0} does not belong to Warehouse {1},Serijski Ne {0} ne pripada Warehouse {1}
+Serial No {0} does not exist,Serijski Ne {0} ne postoji
+Serial No {0} has already been received,Serijski Ne {0} već je primila
+Serial No {0} is under maintenance contract upto {1},Serijski Ne {0} je pod ugovorom za održavanje upto {1}
+Serial No {0} is under warranty upto {1},Serijski Ne {0} je pod jamstvom upto {1}
+Serial No {0} not in stock,Serijski Ne {0} nije u dioničko
+Serial No {0} quantity {1} cannot be a fraction,Serijski Ne {0} {1} količina ne može bitidio
+Serial No {0} status must be 'Available' to Deliver,Serijski Ne {0} status mora biti ' dostupna' za dovođenje
+Serial Nos Required for Serialized Item {0},Serijski Nos potrebna za serijaliziranom točke {0}
+Serial Number Series,Serijski broj serije
+Serial number {0} entered more than once,Serijski broj {0} ušao više puta
+Serialized Item {0} cannot be updated \					using Stock Reconciliation,Serijaliziranom Stavka {0} ne može biti obnovljeno \ korištenjem Stock pomirenja
+Series,serija
+Series List for this Transaction,Serija Popis za ovu transakciju
+Series Updated,Serija Updated
+Series Updated Successfully,Serija Updated uspješno
+Series is mandatory,Serija je obvezno
+Series {0} already used in {1},Serija {0} već koristi u {1}
+Service,usluga
+Service Address,Usluga Adresa
+Service Tax,Usluga Porezne
+Services,Usluge
+Set,set
+"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Zadane vrijednosti kao što su tvrtke , valute , tekuće fiskalne godine , itd."
+Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Postavite Stavka Grupa-mudre proračune na ovom području. Također možete uključiti sezonalnost postavljanjem Distribution.
+Set Status as Available,Postavi kao Status Available
+Set as Default,Postavi kao zadano
+Set as Lost,Postavi kao Lost
+Set prefix for numbering series on your transactions,Postavite prefiks za numeriranje niza na svoje transakcije
+Set targets Item Group-wise for this Sales Person.,Set cilja predmet Grupa-mudar za ovaj prodavač.
+Setting Account Type helps in selecting this Account in transactions.,Postavljanje Vrsta računa pomaže u odabiru ovaj račun u prometu.
+Setting this Address Template as default as there is no other default,"Postavljanje Ova adresa predloška kao zadano, jer nema drugog zadano"
+Setting up...,Postavljanje ...
+Settings,Postavke
+Settings for HR Module,Postavke za HR modula
+"Settings to extract Job Applicants from a mailbox e.g. ""jobs@example.com""",Postavke za izdvajanje posao zahtjeva iz spremnika npr. &quot;jobs@example.com&quot;
+Setup,Postavljanje
+Setup Already Complete!!,Postavljanje Već Kompletan !
+Setup Complete,postavljanje dovršeno
+Setup SMS gateway settings,Postavke Setup SMS gateway
+Setup Series,Postavljanje Serija
+Setup Wizard,Čarobnjak za postavljanje
+Setup incoming server for jobs email id. (e.g. jobs@example.com),Postavljanje dolazni poslužitelj za poslove e-ID . ( npr. jobs@example.com )
+Setup incoming server for sales email id. (e.g. sales@example.com),Postavljanje dolazni poslužitelj za id prodaja e-mail . ( npr. sales@example.com )
+Setup incoming server for support email id. (e.g. support@example.com),Postavljanje dolazni poslužitelj za podršku e-mail ID . ( npr. support@example.com )
+Share,Udio
+Share With,Podijelite s
+Shareholders Funds,Dioničari fondovi
+Shipments to customers.,Isporuke kupcima.
+Shipping,Utovar
+Shipping Account,Dostava račun
+Shipping Address,Dostava Adresa
+Shipping Amount,Dostava Iznos
+Shipping Rule,Dostava Pravilo
+Shipping Rule Condition,Dostava Pravilo Stanje
+Shipping Rule Conditions,Dostava Koje uvjete
+Shipping Rule Label,Dostava Pravilo Label
+Shop,Dućan
+Shopping Cart,Košarica
+Short biography for website and other publications.,Kratka biografija za web stranice i drugih publikacija.
+"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Show &quot;na lageru&quot; ili &quot;Nije u skladištu&quot; temelji se na skladištu dostupna u tom skladištu.
+"Show / Hide features like Serial Nos, POS etc.","Show / Hide značajke kao što su serijski brojevima , POS i sl."
+Show In Website,Pokaži Na web stranice
+Show a slideshow at the top of the page,Prikaži slideshow na vrhu stranice
+Show in Website,Prikaži u web
+Show rows with zero values,Prikaži retke s nula vrijednosti
+Show this slideshow at the top of the page,Prikaži ovaj slideshow na vrhu stranice
+Sick Leave,bolovanje
+Signature,Potpis
+Signature to be appended at the end of every email,Potpis se dodaje na kraju svakog e
+Single,Singl
+Single unit of an Item.,Jedna jedinica stavku.
+Sit tight while your system is being setup. This may take a few moments.,"Sjedi čvrsto , dok je vaš sustav se postava . To može potrajati nekoliko trenutaka ."
+Slideshow,Slideshow
+Soap & Detergent,Sapun i deterdžent
+Software,softver
+Software Developer,Software Developer
+"Sorry, Serial Nos cannot be merged","Žao nam je , Serial Nos ne mogu spojiti"
+"Sorry, companies cannot be merged","Žao nam je , tvrtke ne mogu spojiti"
+Source,Izvor
+Source File,izvor File
+Source Warehouse,Izvor galerija
+Source and target warehouse cannot be same for row {0},Izvor i ciljna skladište ne može biti isti za redom {0}
+Source of Funds (Liabilities),Izvor sredstava ( pasiva)
+Source warehouse is mandatory for row {0},Izvor skladište je obvezno za redom {0}
+Spartan,Spartanski
+"Special Characters except ""-"" and ""/"" not allowed in naming series","Posebne znakove osim "" - "" i "" / "" nisu dopušteni u imenovanja seriju"
+Specification Details,Specifikacija Detalji
+Specifications,tehnički podaci
+"Specify a list of Territories, for which, this Price List is valid","Navedite popis teritorijima, za koje, ovom cjeniku vrijedi"
+"Specify a list of Territories, for which, this Shipping Rule is valid","Navedite popis teritorijima, za koje, to Dostava Pravilo vrijedi"
+"Specify a list of Territories, for which, this Taxes Master is valid","Navedite popis teritorijima, za koje, to Porezi Master vrijedi"
+"Specify the operations, operating cost and give a unique Operation no to your operations.","Navedite operacija, operativni troškovi i dati jedinstven radom najkasnije do svojih operacija ."
+Split Delivery Note into packages.,Split otpremnici u paketima.
+Sports,sportovi
+Sr,Br
+Standard,Standard
+Standard Buying,Standardna kupnju
+Standard Reports,Standardni Izvješća
+Standard Selling,Standardna prodaja
+Standard contract terms for Sales or Purchase.,Standardni uvjeti ugovora za prodaju ili kupnju.
+Start,početak
+Start Date,Datum početka
+Start date of current invoice's period,Početak datum tekućeg razdoblja dostavnice
+Start date should be less than end date for Item {0},Početak bi trebao biti manji od krajnjeg datuma za točke {0}
+State,Država
+Statement of Account,Izjava o računu
+Static Parameters,Statički parametri
+Status,Status
+Status must be one of {0},Status mora biti jedan od {0}
+Status of {0} {1} is now {2},Status {0} {1} je sada {2}
+Status updated to {0},Status obnovljeno za {0}
+Statutory info and other general information about your Supplier,Zakonska info i druge opće informacije o vašem Dobavljaču
+Stay Updated,Budite u tijeku
+Stock,Zaliha
+Stock Adjustment,Stock Podešavanje
+Stock Adjustment Account,Stock Adjustment račun
+Stock Ageing,Kataloški Starenje
+Stock Analytics,Stock Analytics
+Stock Assets,dionicama u vrijednosti
+Stock Balance,Kataloški bilanca
+Stock Entries already created for Production Order ,Stock Entries already created for Production Order 
+Stock Entry,Kataloški Stupanje
+Stock Entry Detail,Kataloški Stupanje Detalj
+Stock Expenses,Stock Troškovi
+Stock Frozen Upto,Kataloški Frozen Upto
+Stock Ledger,Stock Ledger
+Stock Ledger Entry,Stock Ledger Stupanje
+Stock Ledger entries balances updated,Stock unose u knjigu salda ažurirane
+Stock Level,Kataloški Razina
+Stock Liabilities,Stock Obveze
+Stock Projected Qty,Stock Projekcija Kol
+Stock Queue (FIFO),Kataloški red (FIFO)
+Stock Received But Not Billed,Stock primljeni Ali ne Naplaćeno
+Stock Reconcilation Data,Stock Reconcilation podataka
+Stock Reconcilation Template,Stock Reconcilation Predložak
+Stock Reconciliation,Kataloški pomirenje
+"Stock Reconciliation can be used to update the stock on a particular date, usually as per physical inventory.","Stock Pomirenje može se koristiti za ažuriranje zaliha na određeni datum , najčešće po fizičke inventure ."
+Stock Settings,Stock Postavke
+Stock UOM,Kataloški UOM
+Stock UOM Replace Utility,Kataloški UOM Zamjena Utility
+Stock UOM updatd for Item {0},Stock UOM updatd za točku {0}
+Stock Uom,Kataloški Uom
+Stock Value,Stock vrijednost
+Stock Value Difference,Stock Vrijednost razlika
+Stock balances updated,Stock stanja izmijenjena
+Stock cannot be updated against Delivery Note {0},Dionica ne može biti obnovljeno protiv isporuke Napomena {0}
+Stock entries exist against warehouse {0} cannot re-assign or modify 'Master Name',Stock navodi koji postoje protiv skladište {0} se ne može ponovno zauzeti ili mijenjati ' Master Ime '
+Stock transactions before {0} are frozen,Stock transakcije prije {0} se zamrznut
+Stop,Stop
+Stop Birthday Reminders,Zaustavi Rođendan Podsjetnici
+Stop Material Request,Zaustavi Materijal Zahtjev
+Stop users from making Leave Applications on following days.,Prestani korisnike od izrade ostaviti aplikacija na sljedećim danima.
+Stop!,Stop!
+Stopped,Zaustavljen
+Stopped order cannot be cancelled. Unstop to cancel.,Zaustavljen nalog ne može prekinuti. Otpušiti otkazati .
+Stores,prodavaonice
+Stub,iskrčiti
+Sub Assemblies,pod skupštine
+"Sub-currency. For e.g. ""Cent""",Sub-valuta. Za npr. &quot;centi&quot;
+Subcontract,Podugovor
+Subject,Predmet
+Submit Salary Slip,Slanje plaće Slip
+Submit all salary slips for the above selected criteria,Slanje sve plaće gaćice za gore odabranih kriterija
+Submit this Production Order for further processing.,Pošaljite ovaj radnog naloga za daljnju obradu .
+Submitted,Prijavljen
+Subsidiary,Podružnica
+Successful: ,Uspješna:
+Successfully Reconciled,Uspješno Pomirio
+Suggestions,Prijedlozi
+Sunday,Nedjelja
+Supplier,Dobavljač
+Supplier (Payable) Account,Dobavljač (Plaća) račun
+Supplier (vendor) name as entered in supplier master,Dobavljač (prodavatelja) ime kao ušao u dobavljača gospodara
+Supplier > Supplier Type,Dobavljač> proizvođač tip
+Supplier Account Head,Dobavljač račun Head
+Supplier Address,Dobavljač Adresa
+Supplier Addresses and Contacts,Supplier Adrese i kontakti
+Supplier Details,Dobavljač Detalji
+Supplier Intro,Dobavljač Uvod
+Supplier Invoice Date,Dobavljač Datum fakture
+Supplier Invoice No,Dobavljač Račun br
+Supplier Name,Dobavljač Ime
+Supplier Naming By,Dobavljač nazivanje
+Supplier Part Number,Dobavljač Broj dijela
+Supplier Quotation,Dobavljač Ponuda
+Supplier Quotation Item,Dobavljač ponudu artikla
+Supplier Reference,Dobavljač Referenca
+Supplier Type,Dobavljač Tip
+Supplier Type / Supplier,Dobavljač Tip / Supplier
+Supplier Type master.,Dobavljač Vrsta majstor .
+Supplier Warehouse,Dobavljač galerija
+Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dobavljač skladišta obvezan je za sub - ugovoreni kupiti primitka
+Supplier database.,Dobavljač baza podataka.
+Supplier master.,Dobavljač majstor .
+Supplier warehouse where you have issued raw materials for sub - contracting,Dobavljač skladište gdje ste izdali sirovine za pod - ugovaranje
+Supplier-Wise Sales Analytics,Supplier -mudar prodaje Analytics
+Support,Podržati
+Support Analtyics,Podrška Analtyics
+Support Analytics,Podrška Analytics
+Support Email,Podrška e
+Support Email Settings,E-mail Settings Podrška
+Support Password,Podrška Lozinka
+Support Ticket,Podrška karata
+Support queries from customers.,Podrška upite od kupaca.
+Symbol,Simbol
+Sync Support Mails,Sinkronizacija Podrška mailova
+Sync with Dropbox,Sinkronizacija s Dropbox
+Sync with Google Drive,Sinkronizacija s Google Drive
+System,Sistem
+System Settings,Postavke sustava
+"System User (login) ID. If set, it will become default for all HR forms.","Sustav Korisničko (login) ID. Ako je postavljen, to će postati zadana za sve HR oblicima."
+TDS (Advertisement),TDS (Reklama)
+TDS (Commission),TDS (komisija)
+TDS (Contractor),TDS (Izvođač)
+TDS (Interest),TDS (kamate)
+TDS (Rent),TDS (Rent)
+TDS (Salary),TDS (plaće)
+Target  Amount,Ciljani iznos
+Target Detail,Ciljana Detalj
+Target Details,Ciljane Detalji
+Target Details1,Ciljana Details1
+Target Distribution,Ciljana Distribucija
+Target On,Target Na
+Target Qty,Ciljana Kol
+Target Warehouse,Ciljana galerija
+Target warehouse in row {0} must be same as Production Order,Target skladište u redu {0} mora biti ista kao Production Order
+Target warehouse is mandatory for row {0},Target skladište je obvezno za redom {0}
+Task,Zadatak
+Task Details,Zadatak Detalji
+Tasks,zadaci
+Tax,Porez
+Tax Amount After Discount Amount,Iznos poreza Nakon iznosa popusta
+Tax Assets,porezna imovina
+Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,Porezna Kategorija ne može biti ' Procjena ' ili ' Procjena i Total ' kao i svi proizvodi bez zaliha predmeta
+Tax Rate,Porezna stopa
+Tax and other salary deductions.,Porez i drugih isplata plaća.
+Tax detail table fetched from item master as a string and stored in this field.Used for Taxes and Charges,Porezna detalj stol preuzeta iz točke majstora kao string i pohranjene u ovom području. Koristi se za poreze i troškove
+Tax template for buying transactions.,Porezna Predložak za kupnju transakcije .
+Tax template for selling transactions.,Porezna predložak za prodaju transakcije .
+Taxable,Oporezivo
+Taxes,Porezi
+Taxes and Charges,Porezi i naknade
+Taxes and Charges Added,Porezi i naknade Dodano
+Taxes and Charges Added (Company Currency),Porezi i naknade uvrštenja (Društvo valuta)
+Taxes and Charges Calculation,Porezi i naknade Proračun
+Taxes and Charges Deducted,Porezi i naknade oduzeti
+Taxes and Charges Deducted (Company Currency),Porezi i naknade Umanjenja (Društvo valuta)
+Taxes and Charges Total,Porezi i naknade Ukupno
+Taxes and Charges Total (Company Currency),Porezi i naknade Ukupno (Društvo valuta)
+Technology,tehnologija
+Telecommunications,telekomunikacija
+Telephone Expenses,Telefonski troškovi
+Television,Televizija
+Template,Predložak
+Template for performance appraisals.,Predložak za ocjene rada .
+Template of terms or contract.,Predložak termina ili ugovor.
+Temporary Accounts (Assets),Privremene banke ( aktiva )
+Temporary Accounts (Liabilities),Privremene banke ( pasiva)
+Temporary Assets,Privremena Imovina
+Temporary Liabilities,Privremena Obveze
+Term Details,Oročeni Detalji
+Terms,Uvjeti
+Terms and Conditions,Odredbe i uvjeti
+Terms and Conditions Content,Uvjeti sadržaj
+Terms and Conditions Details,Uvjeti Detalji
+Terms and Conditions Template,Uvjeti predloška
+Terms and Conditions1,Odredbe i Conditions1
+Terretory,Terretory
+Territory,Teritorija
+Territory / Customer,Teritorij / Customer
+Territory Manager,Teritorij Manager
+Territory Name,Regija Ime
+Territory Target Variance Item Group-Wise,Teritorij Target varijance artikla Group - Wise
+Territory Targets,Teritorij Mete
+Test,Test
+Test Email Id,Test E-mail ID
+Test the Newsletter,Test Newsletter
+The BOM which will be replaced,BOM koji će biti zamijenjen
+The First User: You,Prvo Korisnik : Vi
+"The Item that represents the Package. This Item must have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes""",Stavka koja predstavlja paket. Ova stavka mora imati &quot;Je kataloški Stavka&quot; kao &quot;Ne&quot; i &quot;Je li prodaja artikla&quot; kao &quot;Da&quot;
+The Organization,Organizacija
+"The account head under Liability, in which Profit/Loss will be booked","Glava računa pod odgovornosti , u kojoj dobit / gubitak će biti rezerviran"
+The date on which next invoice will be generated. It is generated on submit.,Datum na koji pored faktura će biti generiran. To je izrađen podnose.
+The date on which recurring invoice will be stop,Datum na koji se ponavlja faktura će se zaustaviti
+"The day of the month on which auto invoice will be generated e.g. 05, 28 etc ","Dan u mjesecu na koji se automatski faktura će biti generiran npr. 05, 28 itd."
+The day(s) on which you are applying for leave are holiday. You need not apply for leave.,Dan (a ) na koji se prijavljujete za dopust su odmor . Ne trebaju podnijeti zahtjev za dopust .
+The first Leave Approver in the list will be set as the default Leave Approver,Prvi dopust Odobritelj na popisu će se postaviti kao zadani Odobritelj dopust
+The first user will become the System Manager (you can change that later).,Prvi korisnik će postatiSystem Manager ( možete promijeniti kasnije ) .
+The gross weight of the package. Usually net weight + packaging material weight. (for print),Bruto težina paketa. Obično neto težina + ambalaža težina. (Za tisak)
+The name of your company for which you are setting up this system.,Ime vaše tvrtke za koje ste postavljanje ovog sustava .
+The net weight of this package. (calculated automatically as sum of net weight of items),Neto težina tog paketa. (Automatski izračunava kao zbroj neto težini predmeta)
+The new BOM after replacement,Novi BOM nakon zamjene
+The rate at which Bill Currency is converted into company's base currency,Stopa po kojoj Bill valuta pretvara u tvrtke bazne valute
+The unique id for tracking all recurring invoices. It is generated on submit.,Jedinstveni ID za praćenje svih ponavljajući fakture. To je izrađen podnijeti.
+"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Zatim Cjenovna Pravila filtriraju se temelji na Kupca, Kupac Group, Teritorij, dobavljač, proizvođač tip, Kampanja, prodajni partner i sl."
+There are more holidays than working days this month.,Postoji više odmor nego radnih dana ovog mjeseca .
+"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Tu može biti samo jedan Dostava Pravilo Stanje sa 0 ili prazni vrijednost za "" Da Value """
+There is not enough leave balance for Leave Type {0},Nema dovoljno ravnotežu dopust za dozvolu tipa {0}
+There is nothing to edit.,Ne postoji ništa za uređivanje .
+There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,Došlo je do pogreške . Jedan vjerojatan razlog bi mogao biti da niste spremili obrazac. Molimo kontaktirajte support@erpnext.com ako se problem ne riješi .
+There were errors.,Bilo je grešaka .
+This Currency is disabled. Enable to use in transactions,Ova valuta je onemogućen . Moći koristiti u transakcijama
+This Leave Application is pending approval. Only the Leave Apporver can update status.,To Leave Aplikacija se čeka odobrenje . SamoOstavite Apporver može ažurirati status .
+This Time Log Batch has been billed.,Ovo Batch Vrijeme Log je naplaćeno.
+This Time Log Batch has been cancelled.,Ovo Batch Vrijeme Log je otkazan.
+This Time Log conflicts with {0},Ovaj put Prijavite se kosi s {0}
+This format is used if country specific format is not found,Ovaj format se koristi ako država specifičan format nije pronađena
+This is a root account and cannot be edited.,To jekorijen račun i ne može se mijenjati .
+This is a root customer group and cannot be edited.,To jekorijen skupini kupaca i ne može se mijenjati .
+This is a root item group and cannot be edited.,To jekorijen stavka grupa i ne može se mijenjati .
+This is a root sales person and cannot be edited.,To jekorijen prodavač i ne može se mijenjati .
+This is a root territory and cannot be edited.,To jekorijen teritorij i ne može se mijenjati .
+This is an example website auto-generated from ERPNext,Ovo je primjer web stranica automatski generira iz ERPNext
+This is the number of the last created transaction with this prefix,To je broj zadnjeg stvorio transakcije s ovim prefiksom
+This will be used for setting rule in HR module,To će se koristiti za postavljanje pravilu u HR modula
+Thread HTML,Temu HTML
+Thursday,Četvrtak
+Time Log,Vrijeme Log
+Time Log Batch,Vrijeme Log Hrpa
+Time Log Batch Detail,Vrijeme Log Batch Detalj
+Time Log Batch Details,Time Log Hrpa Brodu
+Time Log Batch {0} must be 'Submitted',"Vrijeme Log Batch {0} mora biti "" Postavio '"
+Time Log Status must be Submitted.,Vrijeme Log Status moraju biti dostavljeni.
+Time Log for tasks.,Vrijeme Prijava za zadatke.
+Time Log is not billable,Vrijeme Log nije naplatnih
+Time Log {0} must be 'Submitted',"Vrijeme Log {0} mora biti "" Postavio '"
+Time Zone,Time Zone
+Time Zones,Vremenske zone
+Time and Budget,Vrijeme i proračun
+Time at which items were delivered from warehouse,Vrijeme na stavke koje su isporučena iz skladišta
+Time at which materials were received,Vrijeme u kojem su materijali primili
+Title,Naslov
+Titles for print templates e.g. Proforma Invoice.,Naslovi za ispis predložaka pr Predračuna.
+To,Na
+To Currency,Valutno
+To Date,Za datum
+To Date should be same as From Date for Half Day leave,Za datum bi trebao biti isti kao i od datuma za poludnevni dopust
+To Date should be within the Fiscal Year. Assuming To Date = {0},Za datum mora biti unutar fiskalne godine. Pod pretpostavkom da bi datum = {0}
+To Discuss,Za Raspravljajte
+To Do List,Da li popis
+To Package No.,Za Paket br
+To Produce,proizvoditi
+To Time,Za vrijeme
+To Value,Za vrijednost
+To Warehouse,Za galeriju
+"To add child nodes, explore tree and click on the node under which you want to add more nodes.","Da biste dodali djece čvorova , istražiti stablo i kliknite na čvoru pod kojima želite dodati više čvorova ."
+"To assign this issue, use the ""Assign"" button in the sidebar.","Za dodjelu taj problem, koristite &quot;dodijeliti&quot; gumb u sidebar."
+To create a Bank Account,Za stvaranje bankovni račun
+To create a Tax Account,Za stvaranje porezno
+"To create an Account Head under a different company, select the company and save customer.","Za stvaranje računa glavu pod drugom tvrtkom, odaberite tvrtku i spasiti kupca."
+To date cannot be before from date,Do danas ne može biti prije od datuma
+To enable <b>Point of Sale</b> features,Da biste omogućili <b>Point of Sale</b> značajke
+To enable <b>Point of Sale</b> view,Da biste omogućili <b> prodajnom </ b> pogledom
+To get Item Group in details table,Da biste dobili predmeta Group u tablici pojedinosti
+"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","To uključuje porez u redu {0} u stopu točke , porezi u redovima {1} također moraju biti uključeni"
+"To merge, following properties must be same for both items","Spojiti , ova svojstva moraju biti isti za obje stavke"
+"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Da se ne primjenjuje pravilo Cijene u određenoj transakciji, svim primjenjivim pravilima cijena bi trebala biti onemogućen."
+"To set this Fiscal Year as Default, click on 'Set as Default'","Za postavljanje ove fiskalne godine kao zadano , kliknite na "" Set as Default '"
+To track any installation or commissioning related work after sales,Za praćenje bilo koju instalaciju ili puštanje vezane raditi nakon prodaje
+"To track brand name in the following documents Delivery Note, Opportunity, Material Request, Item, Purchase Order, Purchase Voucher, Purchaser Receipt, Quotation, Sales Invoice, Sales BOM, Sales Order, Serial No","Za praćenje branda u sljedećim dokumentima Dostavnica, Opportunity , materijal zahtjev, predmet, narudžbenice , kupnju vouchera Kupac prijemu, ponude, prodaje fakture , prodaje sastavnice , prodajnog naloga , rednim brojem"
+To track item in sales and purchase documents based on their serial nos. This is can also used to track warranty details of the product.,Za praćenje stavke u prodaji i kupnji dokumenata na temelju njihovih serijskih br. To je također može koristiti za praćenje jamstvene podatke o proizvodu.
+To track items in sales and purchase documents with batch nos<br><b>Preferred Industry: Chemicals etc</b>,Za praćenje stavke u prodaji i kupnji dokumenata s batch br <br> <b>Prošle Industrija: Kemikalije itd</b>
+To track items using barcode. You will be able to enter items in Delivery Note and Sales Invoice by scanning barcode of item.,Za praćenje stavki pomoću barkod. Vi ćete biti u mogućnosti da unesete stavke u otpremnici i prodaje Računa skeniranjem barkod stavke.
+Too many columns. Export the report and print it using a spreadsheet application.,Previše stupovi. Izvesti izvješće i ispisati pomoću aplikacije za proračunske tablice.
+Tools,Alat
+Total,Ukupan
+Total ({0}),Ukupno ({0})
+Total Advance,Ukupno Predujam
+Total Amount,Ukupan iznos
+Total Amount To Pay,Ukupan iznos platiti
+Total Amount in Words,Ukupan iznos u riječi
+Total Billing This Year: ,Ukupno naplate Ova godina:
+Total Characters,Ukupno Likovi
+Total Claimed Amount,Ukupno Zatražio Iznos
+Total Commission,Ukupno komisija
+Total Cost,Ukupan trošak
+Total Credit,Ukupna kreditna
+Total Debit,Ukupno zaduženje
+Total Debit must be equal to Total Credit. The difference is {0},Ukupno zaduženje mora biti jednak ukupnom kreditnom .
+Total Deduction,Ukupno Odbitak
+Total Earning,Ukupna zarada
+Total Experience,Ukupno Iskustvo
+Total Hours,Ukupno vrijeme
+Total Hours (Expected),Ukupno vrijeme (Očekivani)
+Total Invoiced Amount,Ukupno Iznos dostavnice
+Total Leave Days,Ukupno Ostavite Dani
+Total Leaves Allocated,Ukupno Lišće Dodijeljeni
+Total Message(s),Ukupno poruka ( i)
+Total Operating Cost,Ukupni trošak
+Total Points,Ukupno bodova
+Total Raw Material Cost,Ukupno troškova sirovine
+Total Sanctioned Amount,Ukupno kažnjeni Iznos
+Total Score (Out of 5),Ukupna ocjena (od 5)
+Total Tax (Company Currency),Ukupno poreza (Društvo valuta)
+Total Taxes and Charges,Ukupno Porezi i naknade
+Total Taxes and Charges (Company Currency),Ukupno Porezi i naknade (Društvo valuta)
+Total allocated percentage for sales team should be 100,Ukupno dodijeljeno postotak za prodajni tim bi trebao biti 100
+Total amount of invoices received from suppliers during the digest period,Ukupan iznos primljenih računa od dobavljača tijekom razdoblja digest
+Total amount of invoices sent to the customer during the digest period,Ukupan iznos računa šalje kupcu tijekom razdoblja digest
+Total cannot be zero,Ukupna ne može biti nula
+Total in words,Ukupno je u riječima
+Total points for all goals should be 100. It is {0},Ukupni broj bodova za sve ciljeve trebao biti 100 . To je {0}
+Total valuation for manufactured or repacked item(s) can not be less than total valuation of raw materials,Ukupna procjena za proizvodnu ili prepakirani točke (a) ne može biti manja od ukupnog vrednovanja sirovina
+Total weightage assigned should be 100%. It is {0},Ukupno bi trebalo biti dodijeljena weightage 100 % . To je {0}
+Totals,Ukupan rezultat
+Track Leads by Industry Type.,Trag vodi prema tip industrije .
+Track this Delivery Note against any Project,Prati ovu napomenu isporuke protiv bilo Projekta
+Track this Sales Order against any Project,Prati ovu prodajni nalog protiv bilo Projekta
+Transaction,Transakcija
+Transaction Date,Transakcija Datum
+Transaction not allowed against stopped Production Order {0},Transakcija nije dopuštena protiv zaustavljena proizvodnja Reda {0}
+Transfer,Prijenos
+Transfer Material,Prijenos materijala
+Transfer Raw Materials,Prijenos sirovine
+Transferred Qty,prebačen Kol
+Transportation,promet
+Transporter Info,Transporter Info
+Transporter Name,Transporter Ime
+Transporter lorry number,Transporter kamion broj
+Travel,putovanje
+Travel Expenses,putni troškovi
+Tree Type,Tree Type
+Tree of Item Groups.,Tree stavke skupina .
+Tree of finanial Cost Centers.,Drvo finanial troška .
+Tree of finanial accounts.,Drvo finanial račune .
+Trial Balance,Pretresno bilanca
+Tuesday,Utorak
+Type,Vrsta
+Type of document to rename.,Vrsta dokumenta za promjenu naziva.
+"Type of leaves like casual, sick etc.","Tip lišća poput casual, bolovanja i sl."
+Types of Expense Claim.,Vrste Rashodi zahtjevu.
+Types of activities for Time Sheets,Vrste aktivnosti za vrijeme listova
+"Types of employment (permanent, contract, intern etc.).","Vrste zapošljavanja ( trajni ugovor , pripravnik i sl. ) ."
+UOM Conversion Detail,UOM pretvorbe Detalj
+UOM Conversion Details,UOM pretvorbe Detalji
+UOM Conversion Factor,UOM konverzijski faktor
+UOM Conversion factor is required in row {0},Faktor UOM pretvorbe je potrebno u redu {0}
+UOM Name,UOM Ime
+UOM coversion factor required for UOM: {0} in Item: {1},UOM faktor coversion potrebna za UOM: {0} u točki: {1}
+Under AMC,Pod AMC
+Under Graduate,Pod diplomski
+Under Warranty,Pod jamstvo
+Unit,jedinica
+Unit of Measure,Jedinica mjere
+Unit of Measure {0} has been entered more than once in Conversion Factor Table,Jedinica mjere {0} je ušao više od jednom u konverzije Factor tablici
+"Unit of measurement of this item (e.g. Kg, Unit, No, Pair).","Jedinica za mjerenje ove točke (npr. kg, Jedinica Ne, Par)."
+Units/Hour,Jedinice / sat
+Units/Shifts,Jedinice / smjene
+Unpaid,Neplaćen
+Unreconciled Payment Details,Nesaglašen Detalji plaćanja
+Unscheduled,Neplanski
+Unsecured Loans,unsecured krediti
+Unstop,otpušiti
+Unstop Material Request,Otpušiti Materijal Zahtjev
+Unstop Purchase Order,Otpušiti narudžbenice
+Unsubscribed,Pretplatu
+Update,Ažurirati
+Update Clearance Date,Ažurirajte provjeri datum
+Update Cost,Update cost
+Update Finished Goods,Update gotovih proizvoda
+Update Landed Cost,Update Sletio trošak
+Update Series,Update serija
+Update Series Number,Update serije Broj
+Update Stock,Ažurirajte Stock
+Update bank payment dates with journals.,Update banka datum plaćanja s časopisima.
+Update clearance date of Journal Entries marked as 'Bank Vouchers',"Datum Update klirens navoda označene kao ""Banka bon '"
+Updated,Obnovljeno
+Updated Birthday Reminders,Obnovljeno Rođendan Podsjetnici
+Upload Attendance,Upload Attendance
+Upload Backups to Dropbox,Upload sigurnosne kopije za ispuštanje
+Upload Backups to Google Drive,Upload sigurnosne kopije na Google Drive
+Upload HTML,Prenesi HTML
+Upload a .csv file with two columns: the old name and the new name. Max 500 rows.,Učitajte CSV datoteku s dva stupca.: Stari naziv i novi naziv. Max 500 redaka.
+Upload attendance from a .csv file,Prenesi dolazak iz. Csv datoteku
+Upload stock balance via csv.,Prenesi dionica ravnotežu putem CSV.
+Upload your letter head and logo - you can edit them later.,Pošalji svoje pismo glavu i logo - možete ih urediti kasnije .
+Upper Income,Gornja Prihodi
+Urgent,Hitan
+Use Multi-Level BOM,Koristite multi-level BOM
+Use SSL,Koristite SSL
+Used for Production Plan,Koristi se za plan proizvodnje
+User,Korisnik
+User ID,Korisnički ID
+User ID not set for Employee {0},Korisnik ID nije postavljen za zaposlenika {0}
+User Name,Korisničko ime
+User Name or Support Password missing. Please enter and try again.,Korisničko ime ili podrška Lozinka nedostaje . Unesite i pokušajte ponovno .
+User Remark,Upute Zabilješka
+User Remark will be added to Auto Remark,Upute Napomena će biti dodan Auto Napomena
+User Remarks is mandatory,Korisničko Primjedbe je obvezno
+User Specific,Korisnik Specifična
+User must always select,Korisničko uvijek mora odabrati
+User {0} is already assigned to Employee {1},Korisnik {0} već dodijeljena zaposlenika {1}
+User {0} is disabled,Korisnik {0} je onemogućen
+Username,Korisničko ime
+Users with this role are allowed to create / modify accounting entry before frozen date,Korisnici koji imaju tu ulogu mogu kreirati / modificirati knjiženje prije zamrznute dana
+Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Korisnici s ovom ulogom smiju postaviti zamrznute račune i izradu / izmjenu računovodstvenih unosa protiv zamrznutih računa
+Utilities,Komunalne usluge
+Utility Expenses,komunalna Troškovi
+Valid For Territories,Vrijedi za teritorijima
+Valid From,vrijedi od
+Valid Upto,Vrijedi Upto
+Valid for Territories,Vrijedi za teritorijima
+Validate,Potvrditi
+Valuation,Procjena
+Valuation Method,Vrednovanje metoda
+Valuation Rate,Vrednovanje Stopa
+Valuation Rate required for Item {0},Vrednovanje stopa potrebna za točke {0}
+Valuation and Total,Vrednovanje i Total
+Value,Vrijednost
+Value or Qty,"Vrijednost, ili Kol"
+Vehicle Dispatch Date,Vozilo Dispatch Datum
+Vehicle No,Ne vozila
+Venture Capital,venture Capital
+Verified By,Ovjeren od strane
+View Ledger,Pogledaj Ledger
+View Now,Pregled Sada
+Visit report for maintenance call.,Posjetite izvješće za održavanje razgovora.
+Voucher #,bon #
+Voucher Detail No,Bon Detalj Ne
+Voucher Detail Number,Bon Detalj broj
+Voucher ID,Bon ID
+Voucher No,Bon Ne
+Voucher Type,Bon Tip
+Voucher Type and Date,Tip bon i datum
+Walk In,Šetnja u
+Warehouse,skladište
+Warehouse Contact Info,Skladište Kontakt Info
+Warehouse Detail,Skladište Detalj
+Warehouse Name,Skladište Ime
+Warehouse and Reference,Skladište i upute
+Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Skladište se ne može izbrisati , kao entry stock knjiga postoji za to skladište ."
+Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Skladište se može mijenjati samo preko Stock Stupanje / Dostavnica / kupiti primitka
+Warehouse cannot be changed for Serial No.,Skladište se ne može promijeniti za serijskog broja
+Warehouse is mandatory for stock Item {0} in row {1},Skladište je obvezna za dionice točke {0} je u redu {1}
+Warehouse is missing in Purchase Order,Skladište nedostaje u narudžbenice
+Warehouse not found in the system,Skladište se ne nalaze u sustavu
+Warehouse required for stock Item {0},Skladište potreban dionica točke {0}
+Warehouse where you are maintaining stock of rejected items,Skladište gdje ste održavanju zaliha odbijenih stavki
+Warehouse {0} can not be deleted as quantity exists for Item {1},Skladište {0} ne može biti izbrisan kao količina postoji točka {1}
+Warehouse {0} does not belong to company {1},Skladište {0} ne pripada tvrtka {1}
+Warehouse {0} does not exist,Skladište {0} ne postoji
+Warehouse {0}: Company is mandatory,Skladište {0}: Društvo je obvezno
+Warehouse {0}: Parent account {1} does not bolong to the company {2},Skladište {0}: Parent račun {1} ne Bolong tvrtki {2}
+Warehouse-Wise Stock Balance,Skladište-Wise Stock Balance
+Warehouse-wise Item Reorder,Warehouse-mudar Stavka redoslijeda
+Warehouses,Skladišta
+Warehouses.,Skladišta.
+Warn,Upozoriti
+Warning: Leave application contains following block dates,Upozorenje: Ostavite program sadrži sljedeće blok datume
+Warning: Material Requested Qty is less than Minimum Order Qty,Upozorenje : Materijal Tražena količina manja nego minimalna narudžba kol
+Warning: Sales Order {0} already exists against same Purchase Order number,Upozorenje : prodajnog naloga {0} već postoji od broja ista narudžbenice
+Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Upozorenje : Sustav neće provjeravati overbilling od iznosa za točku {0} u {1} je nula
+Warranty / AMC Details,Jamstveni / AMC Brodu
+Warranty / AMC Status,Jamstveni / AMC Status
+Warranty Expiry Date,Jamstvo Datum isteka
+Warranty Period (Days),Jamstveno razdoblje (dani)
+Warranty Period (in days),Jamstveno razdoblje (u danima)
+We buy this Item,Mi smo kupiti ovu stavku
+We sell this Item,Prodajemo ovu stavku
+Website,Website
+Website Description,Web stranica Opis
+Website Item Group,Web stranica artikla Grupa
+Website Item Groups,Website Stavka Grupe
+Website Settings,Website Postavke
+Website Warehouse,Web stranica galerije
+Wednesday,Srijeda
+Weekly,Tjedni
+Weekly Off,Tjedni Off
+Weight UOM,Težina UOM
+"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Težina je spomenuto , \ nDa spominjem "" Težina UOM "" previše"
+Weightage,Weightage
+Weightage (%),Weightage (%)
+Welcome,dobrodošli
+Welcome to ERPNext. Over the next few minutes we will help you setup your ERPNext account. Try and fill in as much information as you have even if it takes a bit longer. It will save you a lot of time later. Good Luck!,"Dobrodošli na ERPNext . Tijekom sljedećih nekoliko minuta, mi ćemo vam pomoći postava tvoj ERPNext računa . Pokušajte i ispunite što više informacija kao što su , čak i ako to trajemalo duže . To će vam uštedjeti puno vremena kasnije . Sretno !"
+Welcome to ERPNext. Please select your language to begin the Setup Wizard.,Dobrodošli na ERPNext . Molimo odaberite svoj jezik kako bi početak čarobnjaka za postavljanje .
+What does it do?,Što učiniti ?
+"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.","Kada bilo koji od provjerenih transakcija &quot;Postavio&quot;, e-mail pop-up automatski otvorio poslati e-mail na povezane &quot;Kontakt&quot; u toj transakciji, s transakcijom u privitku. Korisnik može ili ne može poslati e-mail."
+"When submitted, the system creates difference entries to set the given stock and valuation on this date.","Kada se podnosi ,sustav stvara razlika unose postaviti zadani zaliha i procjenu vrijednosti tog datuma ."
+Where items are stored.,Gdje predmeti su pohranjeni.
+Where manufacturing operations are carried out.,Gdje proizvodni postupci provode.
+Widowed,Udovički
+Will be calculated automatically when you enter the details,Hoće li biti izračunata automatski kada unesete podatke
+Will be updated after Sales Invoice is Submitted.,Hoće li se obnavljaju nakon prodaje fakture je Prijavljen.
+Will be updated when batched.,Hoće li biti ažurirani kada izmiješane.
+Will be updated when billed.,Hoće li biti promjena kada je naplaćeno.
+Wire Transfer,Wire Transfer
+With Operations,Uz operacije
+With Period Closing Entry,S Zatvaranje razdoblja upisa
+Work Details,Radni Brodu
+Work Done,Rad Done
+Work In Progress,Radovi u tijeku
+Work-in-Progress Warehouse,Rad u tijeku Warehouse
+Work-in-Progress Warehouse is required before Submit,Rad u tijeku Warehouse je potrebno prije Podnijeti
+Working,Rad
+Working Days,Radnih dana
+Workstation,Workstation
+Workstation Name,Ime Workstation
+Write Off Account,Napišite Off račun
+Write Off Amount,Napišite paušalni iznos
+Write Off Amount <=,Otpis Iznos &lt;=
+Write Off Based On,Otpis na temelju
+Write Off Cost Center,Otpis troška
+Write Off Outstanding Amount,Otpisati preostali iznos
+Write Off Voucher,Napišite Off bon
+Wrong Template: Unable to find head row.,Pogrešna Predložak: Nije moguće pronaći glave red.
+Year,Godina
+Year Closed,Godina Zatvoreno
+Year End Date,Godina Datum završetka
+Year Name,Godina Ime
+Year Start Date,Godina Datum početka
+Year of Passing,Godina Prolazeći
+Yearly,Godišnje
+Yes,Da
+You are not authorized to add or update entries before {0},Niste ovlašteni za dodati ili ažurirati unose prije {0}
+You are not authorized to set Frozen value,Niste ovlašteni za postavljanje Frozen vrijednost
+You are the Expense Approver for this record. Please Update the 'Status' and Save,"Vi steRashodi Odobritelj za ovaj rekord . Molimo Ažuriranje "" status"" i Save"
+You are the Leave Approver for this record. Please Update the 'Status' and Save,"Vi steOstavite Odobritelj za ovaj rekord . Molimo Ažuriranje "" status"" i Save"
+You can enter any date manually,Možete unijeti bilo koji datum ručno
+You can enter the minimum quantity of this item to be ordered.,Možete unijeti minimalnu količinu ove točke biti naređeno.
+You can not change rate if BOM mentioned agianst any item,Ne možete promijeniti brzinu ako BOM spomenuo agianst bilo predmet
+You can not enter both Delivery Note No and Sales Invoice No. Please enter any one.,Vi ne možete unositi oba isporuke Napomena Ne i prodaje Račun br Unesite bilo jedno .
+You can not enter current voucher in 'Against Journal Voucher' column,Ne možete unijeti trenutni voucher u ' Protiv Journal vaučer ' kolonu
+You can set Default Bank Account in Company master,Možete postaviti Default bankovni račun u gospodara tvrtke
+You can start by selecting backup frequency and granting access for sync,Možete početi odabirom sigurnosnu frekvenciju i davanje pristupa za sinkronizaciju
+You can submit this Stock Reconciliation.,Možete poslati ovu zaliha pomirenja .
+You can update either Quantity or Valuation Rate or both.,Možete ažurirati ili količini ili vrednovanja Ocijenite ili oboje .
+You cannot credit and debit same account at the same time,Ne možete kreditnim i debitnim isti račun u isto vrijeme
+You have entered duplicate items. Please rectify and try again.,Unijeli duple stavke . Molimo ispraviti i pokušajte ponovno .
+You may need to update: {0},Možda ćete morati ažurirati : {0}
+You must Save the form before proceeding,Morate spremiti obrazac prije nastavka
+Your Customer's TAX registration numbers (if applicable) or any general information,Vaš klijent je poreznoj registraciji brojevi (ako je primjenjivo) ili bilo opće informacije
+Your Customers,vaši klijenti
+Your Login Id,Vaš Id Prijava
+Your Products or Services,Svoje proizvode ili usluge
+Your Suppliers,vaši Dobavljači
+Your email address,Vaša e-mail adresa
+Your financial year begins on,Vaša financijska godina počinje
+Your financial year ends on,Vaš Financijska godina završava
+Your sales person who will contact the customer in future,Vaš prodaje osobi koja će kontaktirati kupca u budućnosti
+Your sales person will get a reminder on this date to contact the customer,Vaš prodavač će dobiti podsjetnik na taj datum kontaktirati kupca
+Your setup is complete. Refreshing...,Vaš postava je potpuni . Osvježavajući ...
+Your support email id - must be a valid email - this is where your emails will come!,Vaša podrška e-mail id - mora biti valjana e-mail - ovo je mjesto gdje svoje e-mailove će doći!
+[Error],[Error]
+[Select],[ Select ]
+`Freeze Stocks Older Than` should be smaller than %d days.,` Freeze Dionice starije od ` bi trebao biti manji od % d dana .
+and,i
+are not allowed.,nisu dopušteni.
+assigned by,dodjeljuje
+cannot be greater than 100,ne može biti veća od 100
+"e.g. ""Build tools for builders""","na primjer "" Izgraditi alate za graditelje """
+"e.g. ""MC""","na primjer ""MC"""
+"e.g. ""My Company LLC""","na primjer ""Moja tvrtka LLC"""
+e.g. 5,na primjer 5
+"e.g. Bank, Cash, Credit Card","npr. banka, gotovina, kreditne kartice"
+"e.g. Kg, Unit, Nos, m","npr. kg, Jedinica, br, m"
+e.g. VAT,na primjer PDV
+eg. Cheque Number,npr.. Ček Broj
+example: Next Day Shipping,Primjer: Sljedeći dan Dostava
+lft,LFT
+old_parent,old_parent
+rgt,ustaša
+subject,subjekt
+to,na
+website page link,web stranica vode
+{0} '{1}' not in Fiscal Year {2},{0} ' {1} ' nije u fiskalnoj godini {2}
+{0} Credit limit {0} crossed,{0} Kreditni limit {0} prešao
+{0} Serial Numbers required for Item {0}. Only {0} provided.,{0} serijski brojevi potrebni za točke {0} . Samo {0} uvjetom .
+{0} budget for Account {1} against Cost Center {2} will exceed by {3},{0} proračun za račun {1} od troška {2} premašit će po {3}
+{0} can not be negative,{0} ne može biti negativna
+{0} created,{0} stvorio
+{0} does not belong to Company {1},{0} ne pripada Društvu {1}
+{0} entered twice in Item Tax,{0} dva puta ušao u točki poreza
+{0} is an invalid email address in 'Notification Email Address',"{0} jenevažeća e-mail adresu u "" obavijesti e-mail adresa '"
+{0} is mandatory,{0} je obavezno
+{0} is mandatory for Item {1},{0} je obavezno za točku {1}
+{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je obavezno. Možda Mjenjačnica zapis nije stvoren za {1} na {2}.
+{0} is not a stock Item,{0} nijestock Stavka
+{0} is not a valid Batch Number for Item {1},{0} nije ispravan broj serije za točku {1}
+{0} is not a valid Leave Approver. Removing row #{1}.,{0} nije ispravan Leave Odobritelj. Uklanjanje red # {1}.
+{0} is not a valid email id,{0} nije ispravan id e-mail
+{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} je sadazadana Fiskalna godina . Osvježite svoj preglednik za promjene stupiti na snagu.
+{0} is required,{0} je potrebno
+{0} must be a Purchased or Sub-Contracted Item in row {1},{0} mora bitikupljen ili pod-ugovori stavka u nizu {1}
+{0} must be reduced by {1} or you should increase overflow tolerance,{0} mora biti smanjena za {1} ili bi trebali povećati overflow toleranciju
+{0} must have role 'Leave Approver',{0} mora imati ulogu ' Leave odobravatelju '
+{0} valid serial nos for Item {1},{0} valjani serijski nos za Stavka {1}
+{0} {1} against Bill {2} dated {3},{0} {1} od {2} Billa od {3}
+{0} {1} against Invoice {2},{0} {1} protiv fakture {2}
+{0} {1} has already been submitted,{0} {1} je već poslan
+{0} {1} has been modified. Please refresh.,{0} {1} je izmijenjen . Osvježite.
+{0} {1} is not submitted,{0} {1} nije podnesen
+{0} {1} must be submitted,{0} {1} mora biti podnesen
+{0} {1} not in any Fiscal Year,{0} {1} nije u poslovnu godinu
+{0} {1} status is 'Stopped',{0} {1} status ' Zaustavljen '
+{0} {1} status is Stopped,{0} {1} status zaustavljen
+{0} {1} status is Unstopped,{0} {1} status Unstopped
+{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: troška je obvezno za točku {2}
+{0}: {1} not found in Invoice Details table,{0}: {1} nije pronađen u Pojedinosti dostavnice stolu
