 (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 nazivom već postoji. Promijenite naziv kupca ili promijenite naziv grupe kupaca.
A Customer exists with same name,Kupac sa istim nazivom 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 nazivom već postoji
A symbol for this currency. For e.g. $,Simbol za ovu valutu. Kao npr. $
AMC Expiry Date,AMC Datum isteka
Abbr,Skraćeni naziv
Abbreviation cannot have more than 5 characters,Skraćeni naziv 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 proizvoda {0}
Accepted Quantity,Prihvaćena količina
Accepted Warehouse,Prihvaćeno skladište
Account,Konto
Account Balance,Bilans konta
Account Created: {0},Konto je kreiran: {0}
Account Details,Detalji konta
Account Head,Zaglavlje konta
Account Name,Naziv konta
Account Type,Vrsta konta
"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.,Konto za skladište (stalni inventar) stvorit će se na osnovu ovog konta .
Account head {0} created,Zaglavlje konta {0} je kreirano
Account must be a balance sheet account,Konto mora biti konto bilansa
Account with child nodes cannot be converted to ledger,Konto sa pod-kontima se ne može pretvoriti u glavnoj knjizi
Account with existing transaction can not be converted to group.,Konto sa postojećim transakcijama se ne može pretvoriti u grupu konta .
Account with existing transaction can not be deleted,Konto sa postojećim transakcijama se ne može izbrisati
Account with existing transaction cannot be converted to ledger,Konto sa postojećim transakcijama se ne može pretvoriti u glavnu knjigu
Account {0} cannot be a Group,Konto {0} ne može biti grupa konta
Account {0} does not belong to Company {1},Konto {0} ne pripada preduzeću {1}
Account {0} does not belong to company: {1},Konto {0} ne pripada preduzeću {1}
Account {0} does not exist,Konto {0} ne postoji
Account {0} has been entered more than once for fiscal year {1},Konto {0} je upisan više od jednom za fiskalnu godinu {1}
Account {0} is frozen,Konto {0} je zamrznut
Account {0} is inactive,Konto {0} nije aktivan
Account {0} is not valid,Konto {0} nije ispravan
Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,Konto {0} mora biti tipa 'Nepokretne imovine' jer je proizvod {1} imovina proizvoda
Account {0}: Parent account {1} can not be a ledger,Konto {0}: Nadređeni konto {1} Ne može biti knjiga
Account {0}: Parent account {1} does not belong to company: {2},Konto {0}: Nadređeni konto {1} ne pripada preduzeću: {2}
Account {0}: Parent account {1} does not exist,Konto {0}: Nadređeni konto {1} ne postoji
Account {0}: You can not assign itself as parent account,Konto {0}: Ne može se označiti kao nadređeni konto samom sebi
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čunovodstvene stavke
Accounts,Konta
Accounts Browser,Šifrarnik konta
Accounts Frozen Upto,Računi Frozen Upto
Accounts Payable,Naplativa konta
Accounts Receivable,Konto potraživanja
Accounts Settings,Podešavanja konta
Active,Aktivan
Active: Will extract emails from ,Aktivno: Izdvojiće se e-mail
Activity,Aktivnost
Activity Log,Dnevnik aktivnosti
Activity Log:,Dnevnik aktivnosti:
Activity Type,Tip aktivnosti
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,Stvarna kol
Actual Qty (at source/target),Stvarna kol (na izvoru/cilju)
Actual Qty After Transaction,Stvarna količina nakon transakcije
Actual Qty: Quantity available in the warehouse.,Stvarna kol: količina dostupna na skladištu.
Actual Quantity,Stvarna količina
Actual Start Date,Stvarni datum početka
Add,Dodaj
Add / Edit Taxes and Charges,Dodaj / uredi poreze i troškove
Add Child,Dodaj podređenu stavku
Add Serial No,Dodaj serijski broj
Add Taxes,Dodaj poreze
Add Taxes and Charges,Dodaj poreze i troškove
Add or Deduct,Zbrajanje ili oduzimanje
Add rows to set annual budgets on Accounts.,Dodaj redak za izračun godišnjeg proračuna.
Add to Cart,Dodaj u košaricu
Add to calendar on this date,Dodaj u kalendar na ovaj datum
Add/Remove Recipients,Dodaj / ukloni primaoce
Address,Adresa
Address & Contact,Adresa i kontakt
Address & Contacts,Adresa i kontakti
Address Desc,Adresa silazno
Address Details,Adresa - detalji
Address HTML,Adressa u HTML-u
Address Line 1,Adresa - linija 1
Address Line 2,Adresa - linija 2
Address Template,Predložak adrese
Address Title,Naziv adrese
Address Title is mandatory.,Naziv adrese je obavezan.
Address Type,Tip adrese
Address master.,Master adresa
Administrative Expenses,Administrativni troškovi
Administrative Officer,Administrativni službenik
Advance Amount,Iznos avansa
Advance amount,Predujam iznos
Advances,Avansi
Advertisement,Oglas
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,Svi kontakti
All Contacts.,Svi kontakti.
All Customer Contact,Svi kontakti kupaca
All Customer Groups,Sve grupe kupaca
All Day,Cijeli dan
All Employee (Active),Svi zaposleni (aktivni)
All Item Groups,Sve grupe artikala
All Lead (Open),Svi potencijalni kupci (aktualni)
All Products or Services.,Svi proizvodi i usluge.
All Sales Partner Contact,Svi kontakti distributera
All Sales Person,Svi prodavači
All Supplier Contact,Svi kontakti dobavljača
All Supplier Types,Sve vrste dobavljača
All Territories,Sve teritorije
"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 artikli su već fakturisani
All these items have already been invoiced,Svi ovi artikli su već fakturisani
Allocate,Dodijeli
Allocate leaves for a period.,Dodijeli odsustva za period.
Allocate leaves for the year.,Dodijeli odsustva za godinu.
Allocated Amount,Dodijeljeni iznos
Allocated Budget,Dodijeljeni proračun
Allocated amount,Dodijeljeni iznos
Allocated amount can not be negative,Dodijeljeni iznos ne može biti negativan
Allocated amount can not greater than unadusted amount,Dodijeljeni iznos ne može veći od iznosa unadusted
Allow Bill of Materials,Dopusti sastavnice
Allow Bill of Materials should be 'Yes'. Because one or many active BOMs present for this item,Dopusti sastavnice treba biti 'Da'. Budući da je jedna ili više aktivnih sastavnica prisutno za ovaj proizvod
Allow Children,Dopustiti podređene stavke
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 zalihu
Allow Production Order,Dopustite proizvodni nalog
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 uređivanje cjenika u transakcijama
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 preduzeća)
Amount Paid,Plaćeni iznos
Amount to Bill,Iznos za naplatu
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 odsustvo.
Applies to Company,Odnosi se na preduzeće
Apply On,Primjeni 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,Odobreno
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,Korisnik koji odobrava ne može biti isti kao i korisnik na kojeg se odnosi pravilo.
Are you sure you want to STOP ,Jeste li sigurni da želite da stopirate
Are you sure you want to UNSTOP ,Jeste li sigurni da želite da nastavite
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,Priložiti slike
Attach Letterhead,Priložiti zaglavlje
Attach Logo,Priložiti logo
Attach Your Picture,Priložite 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,Automobilska industrija
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 proizvode
"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet","Dostupno u sastavnicama, otpremnicama, računu kupnje, nalogu za proizvodnju, narudžbi kupnje, primci, prodajnom računu, narudžbi kupca, ulaznog naloga i kontrolnoj kartici"
Average Age,Prosječna starost
Average Commission Rate,Prosječna stopa komisija
Average Discount,Prosječni popust
Awesome Products,Nevjerovatni proizvodi
Awesome Services,Nevjerovatne usluge
BOM Detail No,BOM detalji - broj
BOM Explosion Item,BOM eksplozije artikla
BOM Item,BOM proizvod
BOM No,BOM br.
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 zamijeni alat
BOM number is required for manufactured Item {0} in row {1},BOM broj je potreban za proizvedeni proizvod {0} u redku {1}
BOM number not allowed for non-manufactured Item {0} in row {1},BOM broj nije dopušten za neproizvedene proizvode {0} u redku {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 zamijenjeno
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 potvrđen
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,Upravitelj sigurnosnih kopija
Backup Right Now,Odmah napravi sigurnosnu kopiju
Backups will be uploaded to,Sigurnosne kopije će biti učitane na
Balance Qty,Bilans kol
Balance Sheet,Završni račun
Balance Value,Vrijednost bilance
Balance for Account {0} must always be {1},Bilans konta {0} uvijek mora biti {1}
Balance must be,Bilans 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.,Bankovni  A/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,Naziv 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} se već koristi u artiklu {1}
Based On,Na osnovu
Basic,Osnovni
Basic Info,Osnovne info.
Basic Information,Osnovne informacije
Basic Rate,Osnovna stopa
Basic Rate (Company Currency),Osnovna stopa (valuta preduzeća)
Batch,Serija
Batch (lot) of an Item.,Serija (puno) proizvoda.
Batch Finished Date,Završni datum serije
Batch ID,ID serije
Batch No,Broj serije
Batch Started Date,Početni datum serije
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,Datum računa
Bill No,Račun br
Bill No {0} already booked in Purchase Invoice {1},Bill Ne {0} već rezervirani kupnje proizvoda {1}
Bill of Material,Sastavnica
Bill of Material to be considered for manufacturing,Sastavnica koja će ići u proizvodnju
Bill of Materials (BOM),Sastavnice (BOM)
Billable,Naplativo
Billed,Naplaćeno
Billed Amount,Naplaćeni iznos
Billed Amt,Naplaćeni izn
Billing,Naplata
Billing Address,Adresa za naplatu
Billing Address Name,Naziv adrese za naplatu
Billing Status,Status naplate
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 članak
Blog Subscriber,Blog pretplatnik
Blood Group,Krvna grupa
Both Warehouse must belong to same Company,Oba skladišta moraju pripadati istom preduzeću
Box,Kutija
Branch,Ogranak
Brand,Brend
Brand Name,Naziv brenda
Brand master.,Šifarnik brendova
Brands,Brendovi
Breakdown,Slom
Broadcasting,radiodifuzija
Brokerage,posredništvo
Budget,Budžet
Budget Allocated,Dodijeljeni proračun
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,Izrada izvještaja
Bundle items at time of sale.,Bala stavke na vrijeme prodaje.
Business Development Manager,Business Development Manager
Buying,Nabavka
Buying & Selling,Nabavka i prodaja
Buying Amount,Iznos nabavke
Buying Settings,Podešavanja nabavke
"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čun zasnovan na
Calculate Total Score,Izračunaj ukupan rezultat
Calendar Events,Kalendar - događanja
Call,Poziv
Calls,Pozivi
Campaign,Kampanja
Campaign Name,Naziv kampanje
Campaign Name is required,Potreban je naziv kampanje
Campaign Naming By,Imenovanje kampanja po
Campaign-.####,Kampanja-.####
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,Otkazano
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,Dobrotvorne svrhe i donacije
Chart Name,Ime grafikona
Chart of Accounts,Šifarnik konta
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,Označiti za aktiviranje
Check to make Shipping Address,Označiti za adresu isporuke
Check to make primary address,Označiti za primarnu adresu
Chemical,Hemijski
Cheque,Ček
Cheque Date,Datum čeka
Cheque Number,Broj čeka
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,Poništi tabelu
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,Komentar
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,Istorija komunikacije
Communication log.,Komunikacija dnevnik.
Communications,Communications
Company,Preduzeće
Company (not Customer or Supplier) master.,Društvo ( ne kupaca i dobavljača ) majstor .
Company Abbreviation,Skraćeni naziv preduzeća
Company Details,Detalji preduzeća
Company Email,Zvanični e-mail
"Company Email ID not found, hence mail not sent","E-mail nije poslan, preduzeće nema definisan e-mail"
Company Info,Podaci o preduzeću
Company Name,Naziv preduzeća
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čunar
Computers,Računari
Confirmation Date,potvrda Datum
Confirmed orders from Customers.,Potvrđene 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,Kreiraj novog kupca
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,Kupci
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.,Šifarnik kupaca
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,Format 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,Podrazumjevano
Default Account,Podrazumjevani konto
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 proizvoda
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 proizvoda 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 skladišni proizvod.
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,Stavka otpremnice
Delivery Note Items,Stavke otpremnice
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,Zavis od 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,Konto 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 proizvoda će dovesti do ukupne pogrešne neto težine. Budite sigurni da je neto težina svakog proizvoda u istoj mjernoj jedinici.
Direct Expenses,Direktni troškovi
Direct Income,Direktni prihodi
Disable,Ugasiti
Disable Rounded Total,Ugasiti zaokruženi iznos
Disabled,Ugašeno
Discount  %,Popust%
Discount %,Popust%
Discount (%),Rabat (%)
Discount Amount,Iznos rabata
"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 rabata
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,Rabatt mora biti manji od 100
Discount(%),Rabat (%)
Dispatch,Otpremanje
Display all the individual items delivered with the main items,Prikaži sve pojedinačne proizvode isporučene sa glavnim proizvodima
Distribute transport overhead across items.,Podijeli cijenu transporta po proizvodima.
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 poput $ 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 je unešen za artikl {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 ulaz
Gantt Chart,Gantogram
Gantt chart of all tasks.,Gantogram svih zadataka.
Gender,Rod
General,Opšti
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,Kreiraj avansno plaćanje
Get Advances Received,Kreiraj avansno primanje
Get Current Stock,Kreiraj trenutne zalihe
Get Items,Kreiraj proizvode
Get Items From Sales Orders,Kreiraj proizvode iz narudžbe
Get Items from BOM,Kreiraj proizvode od sastavnica (BOM)
Get Last Purchase Rate,Kreiraj zadnju nabavnu cijenu
Get Outstanding Invoices,Kreiraj neplaćene račune
Get Relevant Entries,Kreiraj relevantne ulaze
Get Sales Orders,Kreiraj narudžbe
Get Specification Details,Kreiraj detalje specifikacija
Get Stock and Rate,Kreiraj zalihu i stopu
Get Template,Kreiraj predložak
Get Terms and Conditions,Kreiraj uvjete i pravila
Get Unreconciled Entries,Kreiraj neusklađene ulaze
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,Globalne zadane postavke
Global POS Setting {0} already created for company {1},Globalne POS postavke {0} su već kreirane za tvrtku {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ću skupinu (obično na Aplikacija fondova > Tekuće imovine > Bankovni računi i kreiraj novu Glavnu knjigu (klikom na Dodaj potomka) 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 dobijena od dobavljača.
Google Drive,Google Drive
Google Drive Access Allowed,Google Drive - pristup dopušten
Government,Vlada
Graduate,Diplomski
Grand Total,Ukupno za platiti
Grand Total (Company Currency),Sveukupno (valuta tvrtke)
"Grid ""","Grid """
Grocery,Trgovina prehrambenom robom
Gross Margin %,Bruto marža %
Gross Margin Value,Vrijednost bruto marže
Gross Pay,Bruto plaća
Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,Bruto plaće + + zaostatak Iznos Iznos Encashment - Ukupno Odbitak
Gross Profit,Bruto dobit
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 jamcu
Group or Ledger,Grupa ili glavna knjiga
Groups,Grupe
HR Manager,Šef ljudskih resursa
HR Settings,Podešavanja ljudskih resursa
HTML / Banner that will show on the top of product list.,HTML / baner koji će se prikazivati ​​na vrhu liste proizvoda.
Half Day,Pola dana
Half Yearly,Polu 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 serijski br
Head of Marketing and Sales,Voditelj marketinga i prodaje
Header,Zaglavlje
Health Care,Zdravstvena zaštita
Health Concerns,Zdravlje Zabrinutost
Health Details,Zdravlje Detalji
Held On,Održanoj
Help HTML,HTML pomoć
"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 tvrtke
Hold,Zadrži
Holiday,Odmor
Holiday List,Lista odmora
Holiday List Name,Naziv liste odmora
Holiday master.,Majstor za odmor .
Holidays,Praznici
Home,Naslovna
Host,Host
"Host, Email and Password required if emails are to be pulled","U slučaju izvlačenja mailova potrebni su host, email i zaporka."
Hour,Sat
Hour Rate,Cijena sata
Hour Rate Labour,Cijena sata rada
Hours,Sati
How Pricing Rule is applied?,Kako se primjenjuje pravilo cijena?
How frequently?,Koliko često?
"How should this currency be formatted? If not set, will use system defaults","Kako bi ova valuta morala biti formatirana? 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: ,Zanemareno:
Image,Slika
Image View,Prikaz slike
Implementation Partner,Provedba partner
Import Attendance,Uvoz posjećenost
Import Failed!,Uvoz nije uspio!
Import Log,Uvoz Prijavite
Import Successful!,Uvoz uspješan!
Imports,Uvozi
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.,Riječima (izvoz) će biti vidljivo nakon što spremite otpremnicu.
In Words will be visible once you save the Delivery Note.,Riječima će biti vidljivo nakon što spremite otpremnicu.
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,Konto prihoda
Income Booked,Rezervirani prihodi
Income Tax,Porez 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,Neizravni dohodak
Individual,Pojedinac
Industry,Industrija
Industry Type,Industrija Tip
Inspected By,Provjereno od strane
Inspection Criteria,Inspekcijski Kriteriji
Inspection Required,Inspekcija Obvezno
Inspection Type,Inspekcija Tip
Installation Date,Instalacija Datum
Installation Note,Napomena instalacije
Installation Note Item,Napomena instalacije proizvoda
Installation Note {0} has already been submitted,Napomena instalacije {0} je već potvrđena
Installation Status,Status instalacije
Installation Time,Vrijeme instalacije
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.,Instalacijski zapis za serijski broj
Installed Qty,Instalirana kol
Instructions,Instrukcije
Integrate incoming support emails to Support Ticket,Integracija dolaznih e-mailova podrške za tiket podrške
Interested,Zainteresiran
Intern,stažista
Internal,Interni
Internet Publishing,Internet izdavaštvo
Introduction,Uvod
Invalid Barcode,Nevažeći bar kod
Invalid Barcode or Serial No,Nevažeći bar kod ili serijski broj
Invalid Mail Server. Please rectify and try again.,Nevažeći mail server. Ispravi i pokušaj ponovno.
Invalid Master Name,Nevažeće Master ime
Invalid User Name or Support Password. Please rectify and try again.,Neispravno korisničko ime ili zaporka podrške. Ispravi i pokušaj ponovno.
Invalid quantity specified for item {0}. Quantity should be greater than 0.,Navedena je pogrešna količina za proizvod {0}. Količina treba biti veći od 0.
Inventory,Inventar
Inventory & Support,Inventar i podrška
Investment Banking,Investicijsko bankarstvo
Investments,Investicije
Invoice Date,Datum fakture
Invoice Details,Detalji računa
Invoice No,Račun br
Invoice Number,Račun broj
Invoice Period From,Račun u periodu 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 u periodu do
Invoice Type,Tip fakture
Invoice/Journal Voucher Details,Račun / Časopis bon Detalji
Invoiced Amount (Exculsive Tax),Dostavljeni iznos ( Exculsive poreza )
Is Active,Je aktivan
Is Advance,Je avans
Is Cancelled,Je otkazan
Is Carry Forward,Je Carry Naprijed
Is Default,Je podrazumjevani
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 primarni kontakt
Is Purchase Item,Je dobavljivi proizvod
Is Sales Item,Je artikl namijenjen prodaji
Is Service Item,Je usluga
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,Artikal - napredna
Item Barcode,Barkod artikla
Item Batch Nos,Broj serije artikla
Item Code,Šifra artikla
Item Code > Item Group > Brand,Šifra artikla > Grupa artikla > Brend
Item Code and Warehouse should already exist.,Šifra artikla i skladište moraju već postojati.
Item Code cannot be changed for Serial No.,Kod artikla ne može se mijenjati za serijski broj.
Item Code is mandatory because Item is not automatically numbered,Kod artikla je obvezan jer artikli nisu automatski numerirani
Item Code required at Row No {0},Kod artikla je potreban u redu broj {0}
Item Customer Detail,Artikal - detalji kupca
Item Description,Opis artikla
Item Desription,Opis artikla
Item Details,Detalji artikla
Item Group,Grupa artikla
Item Group Name,Naziv grupe artikla
Item Group Tree,Raspodjela grupe artikala
Item Group not mentioned in item master for item {0},Stavka artikla se ne spominje u master artiklu za artikal {0}
Item Groups in Details,Grupe artikala u detaljima
Item Image (if not slideshow),Slika proizvoda (ako nije slide prikaz)
Item Name,Naziv artikla
Item Naming By,Artikal imenovan po
Item Price,Cijena artikla
Item Prices,Cijene artikala
Item Quality Inspection Parameter,Parametar provjere kvalitete artikala
Item Reorder,Ponovna narudžba artikla
Item Serial No,Serijski broj artikla
Item Serial Nos,Serijski br artikla
Item Shortage Report,Nedostatak izvješća za artikal
Item Supplier,Dobavljač artikla
Item Supplier Details,Detalji o dobavljaču artikla
Item Tax,Porez artikla
Item Tax Amount,Iznos poreza artikla
Item Tax Rate,Poreska stopa artikla
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,Porez-1 artikla
Item To Manufacture,Artikal za proizvodnju
Item UOM,Mjerna jedinica artikla
Item Website Specification,Specifikacija web stranice artikla
Item Website Specifications,Specifikacije web stranice artikla
Item Wise Tax Detail,Stavka Wise Porezna Detalj
Item Wise Tax Detail ,Stavka Wise Porezna Detalj
Item is required,Artikal je potreban
Item is updated,Artikl je ažuriran
Item master.,Master artikla.
"Item must be a purchase item, as it is present in one or many Active BOMs","Artikal mora biti kupovni, kao što je to prisutno u jednom ili više aktivnih sastavnica (BOMs)"
Item or Warehouse for row {0} does not match Material Request,Artikal ili skladište za redak {0} ne odgovara Zahtjevu za materijalom
Item table can not be blank,Tablica ne može biti prazna
Item to be manufactured or repacked,Artikal će biti proizveden ili prepakiran
Item valuation updated,Vrednovanje artikla je izmijenjeno
Item will be saved by this name in the data base.,Artikal će biti spremljen pod ovim imenom u bazi podataka.
Item {0} appears multiple times in Price List {1},Artikal {0} se pojavljuje više puta u cjeniku {1}
Item {0} does not exist,Artikal {0} ne postoji
Item {0} does not exist in the system or has expired,Artikal {0} ne postoji u sustavu ili je istekao
Item {0} does not exist in {1} {2},Artikal {0} ne postoji u {1} {2}
Item {0} has already been returned,Artikal {0} je već vraćen
Item {0} has been entered multiple times against same operation,Artikal {0} je unesen više puta na istoj operaciji
Item {0} has been entered multiple times with same description or date,Artikal {0} je unesen više puta sa istim opisom ili datumom
Item {0} has been entered multiple times with same description or date or warehouse,"Artikal {0} je unesen više puta sa istim opisom, datumom ili skladištem"
Item {0} has been entered twice,Artikal {0} je unešen dva puta
Item {0} has reached its end of life on {1},Artikal {0} je dosegao svoj rok trajanja na {1}
Item {0} ignored since it is not a stock item,Artikal {0} se ignorira budući da nije skladišni artikal
Item {0} is cancelled,Artikal {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,Artikli
Items To Be Requested,Potraživani artikli
Items required,Potrebni artikli
"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.,Pratite komunikacije vezane uz ovaj upit koja ć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,Područje djelovanja
Key Responsibility Area,Područje odgovornosti
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 kupovna cijena
Latest,Najnovije
Lead,Potencijalni kupac
Lead Details,Detalji potenciajalnog kupca
Lead Id,Id potencijalnog kupca
Lead Name,Ime potencijalnog kupca
Lead Owner,Vlasnik potencijalnog kupca
Lead Source,Izvor potencijalnog kupca
Lead Status,Status potencijalnog kupca
Lead Time Date,Potencijalni kupac - datum
Lead Time Days,Potencijalni kupac - ukupno dana
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.,Potencijalni kupac - ukupno dana je broj dana kojim se ovaj artikal očekuje u skladištu. Ovi dani su preuzeti u Zahtjevu za materijalom kada odaberete ovu stavku.
Lead Type,Tip potencijalnog kupca
Lead must be set if Opportunity is made from Lead,Potencijalni kupac mora biti postavljen ako je prilika iz njega izrađena
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,Pravni troškovi
Letter Head,Zaglavlje
Letter Heads for print templates.,Zaglavlja za ispis predložaka.
Level,Nivo
Lft,LFT
Liability,Odgovornost
List a few of your customers. They could be organizations or individuals.,Navedite nekoliko svojih kupaca. Oni mogu biti tvrtke ili fizičke osobe.
List a few of your suppliers. They could be organizations or individuals.,Navedite nekoliko svojih dobavljača. Oni mogu biti tvrtke ili fizičke osobe.
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...,Učitavanje ...
Loans (Liabilities),Zajmovi (pasiva)
Loans and Advances (Assets),Zajmovi i predujmovi (aktiva)
Local,Lokalno
Login,Prijava
Login with your new User ID,Prijavite se s novim korisničkim ID
Logo,Logo
Logo and Letter Heads,Logo i zaglavlje
Lost,Izgubljen
Lost Reason,Razlog gubitka
Low,Nisko
Lower Income,Donja Prihodi
MTN Details,MTN Detalji
Main,Glavni
Main Reports,Glavni izvještaji
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 ,Napravi
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 (%),Max rabat (%)
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 količina za naručiti
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 informacija
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-din
Ms,G-đ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,Muzika
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ći 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,Otvoreni 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,Datum prilike
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},Tip narudžbe mora biti jedan od {0}
Ordered,Naručeno
Ordered Items To Be Billed,Naručeni artikli za naplatu
Ordered Items To Be Delivered,Naručeni proizvodi za dostavu
Ordered Qty,Naručena kol
"Ordered Qty: Quantity ordered for purchase, but not received.","Naručena količina: količina naručena za kupnju, ali nije došla ."
Ordered Quantity,Naručena količina
Orders released for production.,Narudžbe objavljen za proizvodnju.
Organization Name,Naziv organizacije
Organization Profile,Profil organizacije
Organization branch master.,Organizacija grana majstor .
Organization unit (department) master.,Organizacija jedinica ( odjela ) majstor .
Other,Drugi
Other Details,Ostali detalji
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,Period
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 brendiranje
Priority,Prioritet
Private Equity,Private Equity
Privilege Leave,Privilege dopust
Probation,Probni rad
Process Payroll,Proces plaće
Produced,Proizvedeno
Produced Quantity,Proizvedena 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,Poruka narudžbenice
Purchase Order Required,Narudžbenica kupnje je obavezna
Purchase Order Trends,Trendovi narudžbenica kupnje
Purchase Order number required for Item {0},Broj narudžbenice kupnje je potreban za artikal {0}
Purchase Order {0} is 'Stopped',Narudžbenica {0} je ' zaustavljena '
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,Primka proizvoda
Purchase Receipt Message,Poruka primke
Purchase Receipt No,Primka br.
Purchase Receipt Required,Kupnja Potvrda Obvezno
Purchase Receipt Trends,Račun kupnje trendovi
Purchase Receipt number required for Item {0},Broj primke je potreban za artikal {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,Kvalitet
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,Kvartalno
Quick Help,Brza pomoć
Quotation,Ponude
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 dobijene od dobavljača.
Quotes to Leads or Customers.,Ponude za kupce ili potencijalne kupce.
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,Nasumično
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ži
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 log
SMS Parameter,SMS parametar
SMS Sender Name,SMS naziv pošiljaoca
SMS Settings,Podešavanja SMS-a
SO Date,SO Datum
SO Pending Qty,SO čekanju Kol
SO Qty,SO Kol
Salary,Plata
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,E-mail podešavanja prodaje
Sales Expenses,Prodajni troškovi
Sales Extras,Prodajni dodaci
Sales Funnel,prodaja dimnjak
Sales Invoice,Faktura prodaje
Sales Invoice Advance,Predujam prodajnog računa
Sales Invoice Item,Stavka fakture prodaje
Sales Invoice Items,Stavke fakture prodaje
Sales Invoice Message,Poruka prodajnog  računa
Sales Invoice No,Faktura prodaje 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žbe kupca
Sales Order Date,Datum narudžbe kupca
Sales Order Item,Stavka narudžbe kupca
Sales Order Items,Stavke narudžbe kupca
Sales Order Message,Poruka narudžbe kupca
Sales Order No,Narudžba kupca br
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,Referent prodaje
Sales Person Name,Ime referenta prodaje
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,Prodajni tim
Sales Team Details,Prodaja Team Detalji
Sales Team1,Prodaja Team1
Sales and Purchase,Prodaja i nabavka
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,Planirano
Scheduled Date,Planski datum
Scheduled to send to {0},Planirano za slanje na {0}
Scheduled to send to {0} recipients,Planirano za slanje na {0} primaoca
Scheduler Failed Events,Raspored događanja Neuspjeli
School/University,Škola / Univerzitet
Score (0-5),Ocjena (0-5)
Score Earned,Ocjena Zarađeni
Score must be less than or equal to 5,Ocjena mora biti manja od ili jednaka 5
Scrap %,Otpad%
Seasonality for setting budgets.,Sezonalnost za postavljanje proračuna.
Secretary,Sekretarica
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 preduzeće...
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 preduzeća.
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,Podešavanja 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-mail
Send From,Pošalji sa adrese
Send Notifications To,Pošalji obavještenje na adresu
Send Now,Pošalji odmah
Send SMS,Pošalji SMS
Send To,Pošalji na adresu
Send To Type,Pošalji Upišite
Send mass SMS to your contacts,Pošalji masovne SMS poruke svojim kontaktima
Send to this list,Pošalji na adrese sa ove liste
Sender Name,Ime / Naziv pošiljaoca
Sent On,Poslano na adresu
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 podrazumjevano
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...,Podešavanje ...
Settings,Podešavanja
Settings for HR Module,Podešavanja modula ljudskih resursa
"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,Podešavanje
Setup Already Complete!!,Podešavanja je već okončano!!
Setup Complete,Podešavanje je okončano
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,Podijeli
Share With,Podijeli sa
Shareholders Funds,Dioničari fondovi
Shipments to customers.,Isporuke kupcima.
Shipping,Transport
Shipping Account,Konto transporta
Shipping Address,Adresa isporuke
Shipping Amount,Iznos transporta
Shipping Rule,Pravilo transporta
Shipping Rule Condition,Uslov pravila transporta
Shipping Rule Conditions,Uslovi pravila transporta
Shipping Rule Label,Naziv pravila transporta
Shop,Prodavnica
Shopping Cart,Korpa
Short biography for website and other publications.,Kratka biografija za web stranice i druge publikacije.
"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,Dodati potpis na kraj svakog e-maila
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,Software
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,Izvorna datoteka
Source Warehouse,Izvorno skladište
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,Potvrđeno
Subsidiary,Podružnica
Successful: ,Uspješna:
Successfully Reconciled,Uspješno Pomirio
Suggestions,Prijedlozi
Sunday,Nedjelja
Supplier,Dobavljači
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.,Šifarnik dobavljača
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ška
Support Analtyics,Analitike podrške
Support Analytics,Analitike podrške
Support Email,Email podrška
Support Email Settings,E-mail postavke podrške
Support Password,Zaporka podrške
Support Ticket,Tiket za podršku
Support queries from customers.,Upiti podršci.
Symbol,Simbol
Sync Support Mails,Sinkronizacija mailova podrške
Sync with Dropbox,Sinkronizacija s Dropbox
Sync with Google Drive,Sinkronizacija s Google Drive
System,Sustav
System Settings,Postavke sustava
"System User (login) ID. If set, it will become default for all HR forms.","ID korisnika sustava. Ako je postavljen, postat će zadani za sve HR oblike."
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,Popis podsjetnika
To Package No.,Za Paket br
To Produce,proizvoditi
To Time,Za vrijeme
To Value,Za vrijednost
To Warehouse,Za skladište
"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,Alati
Total,Ukupno
Total ({0}),Ukupno ({0})
Total Advance,Ukupno predujma
Total Amount,Ukupan iznos
Total Amount To Pay,Ukupan iznos platiti
Total Amount in Words,Ukupan iznos riječima
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},
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,Ulaz u
Warehouse,Skladište
Warehouse Contact Info,Kontakt informacije skladišta
Warehouse Detail,Detalji o skladištu
Warehouse Name,Naziv skladišta
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 obvezno za skladišne proizvode {0} u redu {1}
Warehouse is missing in Purchase Order,Skladište nedostaje u narudžbenice
Warehouse not found in the system,Skladište nije pronađeno u sistemu
Warehouse required for stock Item {0},Skladište je potrebno za skladišne proizvode {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 izbrisano ako na njemu ima artikal {1}
Warehouse {0} does not belong to company {1},Skladište {0} ne pripada tvrtki {1}
Warehouse {0} does not exist,Skladište {0} ne postoji
Warehouse {0}: Company is mandatory,Skladište {0}: Kompanija je obvezna
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,Datum isteka jamstva
Warranty Period (Days),Jamstveni period (dani)
Warranty Period (in days),Jamstveni period (u danima)
We buy this Item,Kupili smo ovaj artikal
We sell this Item,Prodajemo ovaj artikal
Website,Web stranica
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. Sljedećih nekoliko minuta,  ćemo vam pomoći da postavite svoj ERPNext nalog. Pokušajte da popunite o vama što više informacija. To će vam kasnije uštedjeti puno vremena. 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 toku
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,Zatvorena godina
Year End Date,Završni datum godine
Year Name,Naziv godine
Year Start Date,Početni datum u godini
Year of Passing,Tekuća godina
Yearly,Godišnji
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š prijavni ID
Your Products or Services,Vaši proizvodi 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ša financijska godina završava
Your sales person who will contact the customer in future,Vaš prodavač koji će ubuduće kontaktirati kupca
Your sales person will get a reminder on this date to contact the customer,Prodavač će dobiti podsjetnik na taj datum kako bi pravovremeno kontaktirao kupca
Your setup is complete. Refreshing...,Vaša podešavanja su ažurirana. Osvježavanje aplikacije...
Your support email id - must be a valid email - this is where your emails will come!,Vaš email ID za podršku - mora biti ispravan email - ovo je mjesto gdje će Vaši e-mailovi 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
